gets class properties metadata
179723
private function getClassProperties($class)
    {
        $properties = $this->getCache()->get('_PHX.serialze_properties.'. $class);
        if (!isset($properties)) {
            $classResolver = $this->getClassResolver();
            $properties = $this->getReflectionProperties($class);
            foreach ($this->getAnnotations()->get($class) as $annotation) {
                if ($annotation instanceof IsA) {
                    $properties[$this->getAnnotationProperty($annotation)]['type']
                        = $classResolver->resolve($annotation->class, $annotation->getDeclaringClass());
                } elseif ($annotation instanceof IsArray && is_scalar($annotation->element)) {
                    $name = $this->getAnnotationProperty($annotation);
                    $properties[$name]['type'] = 'array';
                    $properties[$name]['element']
                        = $classResolver->resolve($annotation->element, $annotation->getDeclaringClass());
                } elseif ($annotation instanceof SerializeName) {
                    $properties[$this->getAnnotationProperty($annotation)]['serializeName']
                        = $annotation->value;
                }
            }
            $this->getCache()->save('_PHX.serialze_properties.'.$class, $properties);
        }
        return $properties;
    }
484199
def _get_metadata(self):
        """"""
        self.metadata = self.fetch_header()
        self.variables = {g.name for g in self.metadata.grids}
1012767
def _parse_properties(response, result_class):
    '''
    
    '''

    if response is None or response.headers is None:
        return None

    props = result_class()
    for key, value in response.headers.items():
        info = GET_PROPERTIES_ATTRIBUTE_MAP.get(key)
        if info:
            if info[0] is None:
                setattr(props, info[1], info[2](value))
            else:
                attr = getattr(props, info[0])
                setattr(attr, info[1], info[2](value))

    if hasattr(props, 'blob_type') and props.blob_type == 'PageBlob' and hasattr(props, 'blob_tier') and props.blob_tier is not None:
        props.blob_tier = _to_upper_str(props.blob_tier)
    return props
64763
private function getProperties(ClassMetadata $metadata)
    {
        return array_merge(
            $metadata->getFieldNames(),
            array_map(function (array $mapping) {
                return $mapping['fieldName'];
            }, $metadata->getEmbeddedFieldsMappings())
        );
    }
313272
def get_name(cls):
        
        if not hasattr(cls.Meta, 'name'):
            class_name = getattr(cls.get_model(), '__name__', None)
            setattr(
                cls.Meta,
                'name',
                inflection.underscore(class_name) if class_name else None
            )

        return cls.Meta.name
866859
def meta(cls):
        """"""
        if getattr(cls, '__from_class__', None) is not None:
            cls = cls.__from_class__
        attribute_info = {}
        for name, value in cls.__table__.columns.items():
            attribute_info[name] = str(value.type).lower()

        return {cls.__name__: attribute_info}
146598
public static String[] getPropertyStrings(Class<?> aClass, String key)
	{
		return Text.split(getProperty(aClass, key));
	}
357176
@Override
	public String[] getPropertyStrings(Class<?> aClass, String key,
			String aDefault)
	{
		String[] defaultArray = {aDefault};
		
		return getPropertyStrings(aClass, key, defaultArray);
	}
1161246
def dict(self):
        
        metadata = {}
        properties = {}
        for name, prop in list(self.properties.items()):
            properties[name] = prop.dict
        metadata['properties'] = properties
        return metadata
810045
public static List<Field> retrievePropertyList(final Class<?> cls) {
        final List<Field> propertyList = new ArrayList<>();
        for (final Field f : cls.getFields()) {
            propertyList.add(f);
        }
        return propertyList;
    }
753497
@Override
  public <T> CpoClass getMetaClass(T obj) throws CpoException {
    CpoClass cpoClass = null;
    String className;
    String requestedName;
    List<Class<?>> classList = new ArrayList<>();
    Class<?> requestedClass;

    if (obj != null) {
      requestedClass = obj.getClass();
      classList.add(requestedClass);
      requestedName = requestedClass.getName();
      className = requestedName;
      cpoClass = classMap.get(className);

      while (cpoClass == null && !classList.isEmpty()) {
        classList = getSuperClasses(classList);
        for (Class<?> clazz : classList) {
          className = clazz.getName();
          cpoClass = classMap.get(className);
          if (cpoClass != null)
            break;
        }
      }
      if (cpoClass == null) {
        throw new CpoException("No Metadata found for class:" + requestedName);
      }
    }

    return cpoClass;
  }
654459
public function getClassMetadata()
    {
        $class = $this->class;
        if ($this->classMetadata === null) {
            $classMetadata = $this->metadata->loadMetadataForClass($class);
            $this->classMetadata = $classMetadata;
        }

        return $this->classMetadata;
    }
1014863
def get_attrs(cls):
        
        ignore = dir(type('dummy', (object,), {})) + ['__metaclass__']
        attrs = [
            item for item in inspect.getmembers(cls) if item[0] not in ignore
            and not isinstance(
                item[1], (
                    types.FunctionType,
                    types.MethodType,
                    classmethod,
                    staticmethod,
                    property))]
        # sort by idx and use attribute name to break ties
        attrs.sort(key=lambda attr: (getattr(attr[1], 'idx', -1), attr[0]))
        return attrs
980245
function findPropertyMetaInfo(type, property) {
    if (!type) {
        return;
    }
    if (typeof type === 'string') {
        var context = findTypeMetaInfo(type);
    } else {
        var context = type;
        type = type.name;
    }
    if (!context) {
        return;
    }

    var info = (context.inputsClass || []).find(i => i.name == property) ||
        (context.outputsClass || []).find(i => i.name == property) ||
        mergeProperties(context).find(i => i.name == property) ||
        (context.methodsClass || context.methods || []).find(i => i.name == property);
    if (info) {
        return {type: context, property: info};
    }
    return findPropertyMetaInfo(context.extends, property);
}
948035
def getattr(self, key):
		
		if key in _MethodFactoryMeta[self.classId]:
			""" property exists """
			return self.__dict__[key]
		else:
			""" property does not exist """
			return None
1321209
public function getMetadataForUser()
    {
        $reflection = new ReflectionClass($this->userClass);
        $properties = $reflection->getProperties();
        $metadata = [
            ClassMetadata::LOGIN_PROPERTY       => null,
            ClassMetadata::PASSWORD_PROPERTY    => null,
            ClassMetadata::API_KEY_PROPERTY     => null,
            ClassMetadata::LAST_ACTION_PROPERTY => null,
        ];

        foreach ($properties as $reflectionProperty) {
            foreach (['login', 'password', 'apiKey', 'lastAction'] as $annotation) {
                $class = sprintf('Ma27\\ApiKeyAuthenticationBundle\\Annotation\\%s', ucfirst($annotation));
                $annotationObject = $this->reader->getPropertyAnnotation($reflectionProperty, $class);

                if (!$annotationObject) {
                    continue;
                }

                switch ($annotation) {
                    case 'login':
                        $this->assertUnique($metadata[ClassMetadata::LOGIN_PROPERTY]);
                        $metadata[ClassMetadata::LOGIN_PROPERTY] = $reflectionProperty;
                        break;
                    case 'password':
                        $this->assertUnique($metadata[ClassMetadata::PASSWORD_PROPERTY]);
                        $metadata[ClassMetadata::PASSWORD_PROPERTY] = $reflectionProperty;
                        break;
                    case 'apiKey':
                        $this->assertUnique($metadata[ClassMetadata::API_KEY_PROPERTY]);
                        $metadata[ClassMetadata::API_KEY_PROPERTY] = $reflectionProperty;
                        break;
                    case 'lastAction':
                        $this->assertUnique($metadata[ClassMetadata::LAST_ACTION_PROPERTY]);
                        $metadata[ClassMetadata::LAST_ACTION_PROPERTY] = $reflectionProperty;
                        break;
                }

                if ($this->isMetadataFullyLoaded($metadata)) {
                    break 2;
                }
            }
        }

        if (!$metadata[ClassMetadata::LOGIN_PROPERTY] || !$metadata[ClassMetadata::PASSWORD_PROPERTY] || !$metadata[ClassMetadata::API_KEY_PROPERTY]) {
            throw new \LogicException('A user class must have a "Login", "Password", "ApiKey" annotation!');
        }

        return $metadata;
    }
152541
public static Properties getProperties(SystemStoreClient<String, String> versionStore) {
        Properties props = null;
        Versioned<String> versioned = versionStore.getSysStore(SystemStoreConstants.VERSIONS_METADATA_KEY);
        if(versioned != null && versioned.getValue() != null) {
            try {
                String versionList = versioned.getValue();
                props = new Properties();
                props.load(new ByteArrayInputStream(versionList.getBytes()));
            } catch(Exception e) {
                logger.warn("Error retrieving properties ", e);
            }
        }

        return props;
    }