Returns all property descriptors for a given class.
171808
private List<PropertyDescriptor> getPropertyDescriptorsForClass(Class<?> clasz) {
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(clasz);
            return Arrays.asList(beanInfo.getPropertyDescriptors());
        } catch (IntrospectionException e) {
            LOGGER.error("instantiation exception while trying to create instance of class {}", clasz.getName());
        }
        return Lists.newArrayList();
    }
744079
private static function getProperties($class): array
    {
        $reflect = new \ReflectionClass($class);
        $prop = $reflect->getProperties(
            \ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED | \ReflectionProperty::IS_PRIVATE
        );
        $properties = [];
        foreach ($prop as $property) {
            $properties[] = $property->name;
        }
        $parent = \get_parent_class($class);
        if ($parent) {
            $properties = \array_merge(self::getProperties($parent), $properties);
        }
        return $properties;
    }
843625
protected static PropertyDescriptor findPropertyDescriptor(Class aClass, String aPropertyName)
    {
        BeanInfo info;
        PropertyDescriptor[] pd;
        PropertyDescriptor descriptor = null;

        try
        {
            info = Introspector.getBeanInfo(aClass);
            pd = info.getPropertyDescriptors();
            for (int i = 0; i < pd.length; i++)
            {
                if (pd[i].getName().equals(aPropertyName))
                {
                    descriptor = pd[i];
                    break;
                }
            }
            if (descriptor == null)
            {
                /*
				 * Daren Drummond: 	Throw here so we are consistent
				 * 					with PersistentFieldDefaultImpl.
				 */
                throw new MetadataException("Can't find property " + aPropertyName + " in " + aClass.getName());
            }
            return descriptor;
        }
        catch (IntrospectionException ex)
        {
            /*
			 * Daren Drummond: 	Throw here so we are consistent
			 * 					with PersistentFieldDefaultImpl.
			 */
            throw new MetadataException("Can't find property " + aPropertyName + " in " + aClass.getName(), ex);
        }
    }
1199160
private static List<Method> getPropertyMethods(Class entityClass) {
        List<Method> result = new ArrayList<Method>();
        for (Method m : entityClass.getMethods()) {
            if (m.getParameterTypes().length == 0 && m.getName().startsWith("get") && m.getReturnType() != void.class) {
                if (m.getName().equals("getClass")) continue;
                result.add(m);
            }
        }
        return result;
    }
1264522
public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      return new PropertyDescriptor[] {
        new PropertyDescriptor("fileURL", LogFilePatternReceiver.class),
        new PropertyDescriptor(
          "timestampFormat", LogFilePatternReceiver.class),
        new PropertyDescriptor("logFormat", LogFilePatternReceiver.class),
        new PropertyDescriptor("name", LogFilePatternReceiver.class),
        new PropertyDescriptor("tailing", LogFilePatternReceiver.class),
        new PropertyDescriptor(
          "filterExpression", LogFilePatternReceiver.class),
        new PropertyDescriptor("waitMillis", LogFilePatternReceiver.class),
        new PropertyDescriptor("appendNonMatches", LogFilePatternReceiver.class),
        new PropertyDescriptor("customLevelDefinitions", LogFilePatternReceiver.class),
        new PropertyDescriptor("useCurrentThread", LogFilePatternReceiver.class),
      };
    } catch (Exception e) {
    }

    return null;
  }
1062636
private static PropertyDescriptor getPropertyDescriptor( final Class<?> type, final String propertyName ) {

        Exceptions.requireNonNull(type);
        Exceptions.requireNonNull(propertyName);

        if ( !propertyName.contains( "." ) ) {
            return doGetPropertyDescriptor( type, propertyName );
        } else {
            String[] propertyNames = propertyName.split( "[.]" );
            Class<?> clazz = type;
            PropertyDescriptor propertyDescriptor = null;
            for ( String pName : propertyNames ) {
                propertyDescriptor = doGetPropertyDescriptor( clazz, pName );
                if ( propertyDescriptor == null ) {
                    return null;
                }
                clazz = propertyDescriptor.getPropertyType();
            }
            return propertyDescriptor;
        }
    }
184857
protected function getPropertyTypes($class)
    {
        $class = new \ReflectionClass($class);
        $properties = $class->getDefaultProperties();
        $propertyTypes = [];

        // This prevents any default string value, so it could be enhanced
        foreach ($properties as $propName => $property) {
            if (is_string($property) && (class_exists($property) || interface_exists($property))) {
                $propertyTypes[$propName] = $property;
            }
        }
        return $propertyTypes;
    }
738492
public static DescriptorExtensionList<ListViewColumn, Descriptor<ListViewColumn>> all() {
        return Jenkins.getInstance().<ListViewColumn, Descriptor<ListViewColumn>>getDescriptorList(ListViewColumn.class);
    }
532100
def list_properties(cls):
    
    rtn_dict = {}
    for attr in dir(cls):
        if attr not in ["properties", "__doc__", "doc"]:
            attr_val = getattr(cls, attr)

            if isinstance(attr_val, MODULE.rdfclass.RdfPropertyMeta):
                rtn_dict[attr] = attr_val
    return rtn_dict
248283
public static DescriptorExtensionList<MyViewsTabBar, Descriptor<MyViewsTabBar>> all() {
        return Jenkins.getInstance().<MyViewsTabBar, Descriptor<MyViewsTabBar>>getDescriptorList(MyViewsTabBar.class);
    }
836591
def get_lookups(cls):
        """"""
        class_lookups = [parent.__dict__.get('class_lookups', {}) for parent in inspect.getmro(cls)]
        return cls.merge_dicts(class_lookups)
591666
private static PropertyDescriptor[] getPropertyDescriptors(Object bean)
   {
       if(bean == null)
           throw new IllegalArgumentException("No bean specified");
       else
           return getPropertyDescriptors(bean.getClass());
   }
407871
def extract_descriptor(self, obj):
        """"""
        descriptor = []

        def flatten(current):
            """Flatten descriptor."""
            if isinstance(current, dict):
                for key in current:
                    flatten(current[key])
            elif isinstance(current, list):
                for val in current:
                    flatten(val)
            elif isinstance(current, (int, bool, float, str)):
                descriptor.append(str(current))

        flatten(obj.descriptor)

        return descriptor
167911
public static List<String> getPropNameList(final Class<?> cls) {
        List<String> propNameList = entityDeclaredPropNameListPool.get(cls);

        if (propNameList == null) {
            loadPropGetSetMethodList(cls);
            propNameList = entityDeclaredPropNameListPool.get(cls);
        }

        return propNameList;
    }
304591
public static DescriptorExtensionList<LabelAtomProperty,LabelAtomPropertyDescriptor> all() {
        return Jenkins.getInstance().<LabelAtomProperty,LabelAtomPropertyDescriptor>getDescriptorList(LabelAtomProperty.class);
    }
1313824
def class_types(self):
        """"""

        if None is self.__class_types:
            self.__class_types = []
            for type_ in self.argument_types:
                decl = None
                type_ = type_traits.remove_reference(type_)
                if type_traits_classes.is_class(type_):
                    decl = type_traits_classes.class_traits.get_declaration(
                        type_)
                elif type_traits_classes.is_class_declaration(type_):
                    tt = type_traits_classes.class_declaration_traits
                    decl = tt.get_declaration(type_)
                else:
                    pass
                if decl:
                    self.__class_types.append(decl)
        return self.__class_types
1207889
private static function getProps($class)
    {
        if ($class == NULL) {
            return array();
        }
        $class = new \ReflectionClass($class);
        $properties = array_filter($class->getProperties(), function ($prop) use($class)
        {
            return $prop->getDeclaringClass()->name == $class->name;
        });
        return $properties;
    }