Return the list of properties by introspecting the annotated fields for {@link PluginProperty}
@param aClass class
@return list of properties, may be empty
518564
public static List<Property> buildFieldProperties(final Class<?> aClass) {
        DescriptionBuilder builder = DescriptionBuilder.builder();
        buildFieldProperties(aClass, builder);
        return builder.buildProperties();
    }
945005
@Override
	public String[] getPropertyStrings(Class<?> aClass, String key,
			String[] aDefault)
	{
		String property = getProperty(aClass, key,"");
		
		if("".equals(property))
			return aDefault;
		
		return Text.split(property);
	}
357176
@Override
	public String[] getPropertyStrings(Class<?> aClass, String key,
			String aDefault)
	{
		String[] defaultArray = {aDefault};
		
		return getPropertyStrings(aClass, key, defaultArray);
	}
1099799
public static final Set<String> getProperties(Class<?> cls)
    {
        if (cls.isPrimitive() || cls.isAnnotation() || cls.isEnum() || String.class.equals(cls))
        {
            return Collections.EMPTY_SET;
        }
        NavigableSet<String> set = setFor(cls);
        Method[] methods = cls.getMethods();
        for (Method method : methods)
        {
            if ((method.getModifiers() & ModifierMask) == 0)
            {
                String name = method.getName();
                if ((name.startsWith("get") || name.startsWith("is"))
                        && method.getParameterCount() == 0)
                {
                    String property = getProperty(method);
                    Class<?> returnType = method.getReturnType();
                    if (
                            returnType.isArray() ||
                            List.class.isAssignableFrom(returnType)
                            )
                    {
                        set.add(property);
                    }
                    else
                    {
                        if (hasMethod(methods, setter(property)))
                        {
                            set.add(property);
                        }
                    }
                }
            }
        }
        for (Field field : cls.getFields())
        {
            if ((field.getModifiers() & ModifierMask) == 0)
            {
                set.add(field.getName());
            }
        }
        return set;
    }
865909
private static PropertyDescriptor getPropertyDescriptorOptional(
        Class<?> beanClass, String propertyName)
    {
        List<PropertyDescriptor> propertyDescriptors = 
            getPropertyDescriptorsOptional(beanClass);
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors)
        {
            if (propertyDescriptor.getName().equals(propertyName))
            {
                return propertyDescriptor;
            }
        }
        return null;
    }
1104638
public String[] getMethods(String pluginClass) throws Exception {
        ArrayList<String> methodNames = new ArrayList<String>();

        Method[] methods = getClass(pluginClass).getDeclaredMethods();
        for (Method method : methods) {
            logger.info("Checking {}", method.getName());

            com.groupon.odo.proxylib.models.Method methodInfo = this.getMethod(pluginClass, method.getName());
            if (methodInfo == null) {
                continue;
            }

            // check annotations
            Boolean matchesAnnotation = false;
            if (methodInfo.getMethodType().endsWith(Constants.PLUGIN_RESPONSE_OVERRIDE_CLASS) ||
                methodInfo.getMethodType().endsWith(Constants.PLUGIN_RESPONSE_OVERRIDE_V2_CLASS)) {
                matchesAnnotation = true;
            }

            if (!methodNames.contains(method.getName()) && matchesAnnotation) {
                methodNames.add(method.getName());
            }
        }

        return methodNames.toArray(new String[0]);
    }
213133
public List<MetaProperty> getProperties() {
        checkInitalised();
        SingleKeyHashMap propertyMap = classPropertyIndex.getNullable(theCachedClass);
        if (propertyMap==null) {
            // GROOVY-6903: May happen in some special environment, like under Android, due
            // to classloading issues
            propertyMap = new SingleKeyHashMap();
        }
        // simply return the values of the metaproperty map as a List
        List ret = new ArrayList(propertyMap.size());
        for (ComplexKeyHashMap.EntryIterator iter = propertyMap.getEntrySetIterator(); iter.hasNext();) {
            MetaProperty element = (MetaProperty) ((SingleKeyHashMap.Entry) iter.next()).value;
            if (element instanceof CachedField) continue;
            // filter out DGM beans
            if (element instanceof MetaBeanProperty) {
                MetaBeanProperty mp = (MetaBeanProperty) element;
                boolean setter = true;
                boolean getter = true;
                if (mp.getGetter() == null || mp.getGetter() instanceof GeneratedMetaMethod || mp.getGetter() instanceof NewInstanceMetaMethod) {
                    getter = false;
                }
                if (mp.getSetter() == null || mp.getSetter() instanceof GeneratedMetaMethod || mp.getSetter() instanceof NewInstanceMetaMethod) {
                    setter = false;
                }
                if (!setter && !getter) continue;
//  TODO: I (ait) don't know why these strange tricks needed and comment following as it effects some Grails tests
//                if (!setter && mp.getSetter() != null) {
//                    element = new MetaBeanProperty(mp.getName(), mp.getType(), mp.getGetter(), null);
//                }
//                if (!getter && mp.getGetter() != null) {
//                    element = new MetaBeanProperty(mp.getName(), mp.getType(), null, mp.getSetter());
//                }
            }
            ret.add(element);
        }
        return ret;
    }
1135108
public static Optional<CasConfigurationProperties> getCasConfigurationProperties() {
        if (CONTEXT != null) {
            return Optional.of(CONTEXT.getBean(CasConfigurationProperties.class));
        }
        return Optional.empty();
    }
442084
@Override
    public PropertyDescriptor[] getPropertyDescriptors() {
        try {
            ArrayList<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
            PropertyDescriptor descriptor;

            try {
                descriptor = new PropertyDescriptor("animated",
                        com.l2fprod.common.swing.JCollapsiblePane.class);
            } catch (IntrospectionException e) {
                descriptor = new PropertyDescriptor("animated",
                        com.l2fprod.common.swing.JCollapsiblePane.class, "getAnimated", null);
            }

            descriptor.setPreferred(true);

            descriptor.setBound(true);

            descriptors.add(descriptor);
            try {
                descriptor = new PropertyDescriptor("collapsed",
                        com.l2fprod.common.swing.JCollapsiblePane.class);
            } catch (IntrospectionException e) {
                descriptor = new PropertyDescriptor("collapsed",
                        com.l2fprod.common.swing.JCollapsiblePane.class, "getCollapsed", null);
            }

            descriptor.setPreferred(true);

            descriptor.setBound(true);

            descriptors.add(descriptor);

            return (PropertyDescriptor[]) descriptors
                    .toArray(new PropertyDescriptor[descriptors.size()]);
        } catch (Exception e) {
            // do not ignore, bomb politely so use has chance to discover what went
            // wrong...
            // I know that this is suboptimal solution, but swallowing silently is
            // even worse... Propose better solution!
            Logger.getLogger(JCollapsiblePane.class.getName()).log(Level.SEVERE, null, e);
        }
        return null;
    }
13747
public function findProperties(ReflectionClass $reflectionClass)
	{
		$allProperties = [];

		/** @var ReflectionClass $currentReflectionClass */
		$currentReflectionClass = $reflectionClass;

		while ($currentReflectionClass) {// class without parent has null in getParentClass()

			$properties = $currentReflectionClass->getProperties();

			foreach ($properties as $property) {
				if (isset($allProperties[$property->getName()])) {
					// Do not add the same property few times
					// If parent class has public or protected property - the same property will be returned for the Child class
					// As child class is processed first - its property will be taken
					continue;
				}

				$allProperties[$property->getName()] = $property;
			}

			$currentReflectionClass = $currentReflectionClass->getParentClass();
		}

		return $allProperties;
	}
644234
public List<ConstantField> getConstants(Class<?> aClass) {
        List<ConstantField> constants = new ArrayList<>();
        List<Field> fields = Arrays.asList(aClass.getDeclaredFields());

        for (Field field : fields) {
            if (Modifier.isStatic(field.getModifiers()) && !Modifier.isFinal(field.getModifiers())) {
                if (!Modifier.isPublic(field.getModifiers()))
                    if (tryMakeAccessible)
                        field.setAccessible(true);
                    else
                        continue;
                constants.add(processField(aClass, field));
            }
        }

        Iterator<ConstantField> itr = constants.iterator();
        while (itr.hasNext()) {
            if (itr.next() == null)
                itr.remove();
        }

        return constants;
    }
823196
private static Stream<PropertyDescriptor> getPropertyDescriptors(Class<?> clazz) {

		return Arrays.stream(BeanUtils.getPropertyDescriptors(clazz))
				.filter(descriptor -> !FIELDS_TO_IGNORE.contains(descriptor.getName()))
				.filter(descriptor -> !descriptorToBeIgnoredByJackson(clazz, descriptor))
				.filter(descriptor -> !toBeIgnoredByJackson(clazz, descriptor.getName()))
				.filter(descriptor -> !readerIsNotToBeIgnoredByJackson(descriptor));
	}
216733
public List<WarningsGroup> getByProperty(Class<? extends ICalProperty> propertyClass) {
		List<WarningsGroup> warnings = new ArrayList<WarningsGroup>();
		for (WarningsGroup group : this.warnings) {
			ICalProperty property = group.getProperty();
			if (property == null) {
				continue;
			}

			if (propertyClass == property.getClass()) {
				warnings.add(group);
			}
		}
		return warnings;
	}
904175
public static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz) {
        PropertyDescriptor[] properties = propertyDescriptors(clazz);
        Map<String, PropertyDescriptor> mappedProperties = new HashMap<String, PropertyDescriptor>();

        for (PropertyDescriptor property : properties) {
            if ("class".equals(property.getName()) == false) {
                mappedProperties.put(property.getName(), property);
            }
        }

        return mappedProperties;
    }
376149
private List<ModelProperty> propertiesFor(ResolvedType type, ModelContext givenContext, String namePrefix) {
    Set<ModelProperty> properties = new TreeSet<>(byPropertyName());
    BeanDescription beanDescription = beanDescription(type, givenContext);
    Map<String, BeanPropertyDefinition> propertyLookup = beanDescription.findProperties().stream().collect(toMap(
        beanPropertyByInternalName(), identity()));
    for (Map.Entry<String, BeanPropertyDefinition> each : propertyLookup.entrySet()) {
      LOG.debug("Reading property {}", each.getKey());
      BeanPropertyDefinition jacksonProperty = each.getValue();
      Optional<AnnotatedMember> annotatedMember
          = ofNullable(safeGetPrimaryMember(jacksonProperty, givenContext));
      annotatedMember.ifPresent(
          member -> properties.addAll(
              candidateProperties(
                  type,
                  member,
                  jacksonProperty,
                  givenContext,
                  namePrefix)));
    }
    return new ArrayList<>(properties);
  }
464356
private XmlClass findXmlClass(Class<?> aClass){
		for (XmlClass xmlClass : xmlJmapper.classes) 
			if(xmlClass.name.equals(aClass.getName())) return xmlClass;
		return null;
	}
1247186
@Override
	public Boolean getPropertyBoolean(Class<?> aClass, String key,
			boolean aBool)
	{
		return getPropertyBoolean(new StringBuilder(aClass.getName()).append(".").append(key).toString(), aBool);
	}