Whenever this method is called, all objects in input argument are searched for
annotated fields. Then, the fields are injected by dependency objects.

@param objects List of objects which they should be injected.
761039
public static void inject(Object... objects) {
        try {
            for (Object object : objects) {
                Class clazz = object.getClass();
                for (Field field : ReflectionHelper.getFields(clazz)) {
                    if (field.isAnnotationPresent(InjectHere.class)) {
                        qualifiers.clear();
                        for (Annotation annotation : field.getAnnotations()) {
                            if (annotation.annotationType().isAnnotationPresent(Qualifier.class)) {
                                qualifiers.add(annotation.annotationType().getCanonicalName());
                            }
                        }
                        field.setAccessible(true);
                        field.set(object, dependencyContainer.get(DependencyIdentifier
                                .getDependencyIdentifierForClass(field, qualifiers)));
                    }
                }
            }
        } catch (Exception e) {
            throw new AvicennaRuntimeException(e);
        }
    }
1012913
public void setExtraFields(Collection<String> fields) {
        extraFields = new HashSet<String>();
        if (fields != null) {
            extraFields.addAll(fields);
        }
    }
434453
@SuppressWarnings({ "rawtypes", "unchecked" })
    @Override
    public void injectFields(Object target) {
        BeanManager mgr = BeanManagerLookup.getBeanManager();
        AnnotatedType annotatedType = mgr.createAnnotatedType(target.getClass());
        InjectionTarget injectionTarget = mgr.createInjectionTarget(annotatedType);
        CreationalContext context = mgr.createCreationalContext(null);
        injectionTarget.inject(target, context);
    }
455473
protected void initUserObject() {

        if (m_fieldconfiguration == null) {
            try {
                m_fieldconfiguration = m_searchManager.getFieldConfiguration(getParamFieldconfiguration());
                if (m_fieldconfiguration == null) {
                    m_fieldconfiguration = new CmsLuceneFieldConfiguration();
                }
            } catch (Exception e) {
                m_fieldconfiguration = new CmsLuceneFieldConfiguration();
            }
        }
    }
1124328
protected void println(Object... objects) throws IOException {
        for (Object object : objects) {
            pageContext.getOut().println(object);
        }
    }
743847
private void fillServices(Object object)
    {
        final List<Field> fields = getServiceFields(object);
        final int length = fields.size();
        for (int i = 0; i < length; i++)
        {
            final Field field = fields.get(i);
            UtilReflection.setAccessible(field, true);

            final Class<?> type = field.getType();
            setField(field, object, type);
        }
    }
963194
void setFields(Field[] fields) {
    this.fields = fields;
    this.resultSetColumnNameIndexMap = null;
    this.cachedMaxResultRowSize = null;
    this.needUpdateFieldFormats = fields != null;
    this.hasBinaryFields = false; // just in case
  }
1168847
public void addObjects(List[] objects)
  {
    if (tc.isEntryEnabled())
      tc.entry(this,cclass, "addObjects", "objects: " + objects);

    if (delegate != null)
      delegate.addObjects(objects);

    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "addObjects");
  }
1234526
public void setFields(java.util.Collection<Field> fields) {
        if (fields == null) {
            this.fields = null;
            return;
        }

        this.fields = new com.amazonaws.internal.SdkInternalList<Field>(fields);
    }
277740
@SuppressWarnings({"unchecked", "vararg"})
    public static Filter<InstanceField> annotatedBy(final Class<? extends Annotation>... annotations) {
        return new Filter<InstanceField>() {
            public boolean isOut(InstanceField instanceField) {
                Checks.checkNotNull(annotations, "Provide at least one annotation class");

                for (Class<? extends Annotation> annotation : annotations) {
                    if(instanceField.isAnnotatedBy(annotation)) {
                        return false;
                    }
                }
                return true;
            }
        };
    }
170475
@Deprecated
    public void add(Object... objects) throws Exception
    {
        for ( Object obj : objects )
        {
            add(obj);
        }
    }
929036
private void initializeAnnotations() {
        this.applicationContext.getBeansOfType(null, false, false).values()
                .stream()
                .filter(Objects::nonNull)
                .forEach(bean -> ReflectionUtils.doWithMethods(bean.getClass(), method -> {
                    int order = AnnotationUtils.findAnnotation(method, PostInitialize.class).order();
                    postInitializingMethods.add(order, new PostInitializingMethod(method, bean));
                }, this.methodFilter));
    }
858923
public void setObjects(Object object) {
        if (Collection.class.isAssignableFrom(object.getClass())) {
            this.objects = (Collection) object;
        }
    }
49778
public void setAnnotations(java.util.Map<String, java.util.List<ValueWithServiceIds>> annotations) {
        this.annotations = annotations;
    }
146331
public void writeFields (Object object) {
		Class type = object.getClass();

		Object[] defaultValues = getDefaultValues(type);

		OrderedMap<String, FieldMetadata> fields = getFields(type);
		int i = 0;
		for (FieldMetadata metadata : new OrderedMapValues<FieldMetadata>(fields)) {
			Field field = metadata.field;
			try {
				Object value = field.get(object);
				if (defaultValues != null) {
					Object defaultValue = defaultValues[i++];
					if (value == null && defaultValue == null) continue;
					if (value != null && defaultValue != null) {
						if (value.equals(defaultValue)) continue;
						if (value.getClass().isArray() && defaultValue.getClass().isArray()) {
							equals1[0] = value;
							equals2[0] = defaultValue;
							if (Arrays.deepEquals(equals1, equals2)) continue;
						}
					}
				}

				if (debug) System.out.println("Writing field: " + field.getName() + " (" + type.getName() + ")");
				writer.name(field.getName());
				writeValue(value, field.getType(), metadata.elementType);
			} catch (IllegalAccessException ex) {
				throw new JsonException("Error accessing field: " + field.getName() + " (" + type.getName() + ")", ex);
			} catch (JsonException ex) {
				ex.addTrace(field + " (" + type.getName() + ")");
				throw ex;
			} catch (Exception runtimeEx) {
				JsonException ex = new JsonException(runtimeEx);
				ex.addTrace(field + " (" + type.getName() + ")");
				throw ex;
			}
		}
	}
1017114
private void evaluateObject() {
        if (evaluatedClasses.contains(clazz)) {
            return;
        }

        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            if (field.isAnnotationPresent(ModelField.class)
            && !isAllowed(field)) {
                throw new RuntimeException("Field '"
                        + field.getName()
                        + "' has type '" + field.getType().getSimpleName()
                        + "' that is not allowed!");
            }
        }

        evaluatedClasses.add(clazz);
    }
1059967
public static <T> List<Field> getAnnotatedFields(Object object, Class<? extends Annotation> annotationClass) {
		return getAnnotatedFields(object.getClass(), annotationClass);
	}