{@inheritDoc}

<p>
We will bubble up the hierarchy, starting at class {@code T}. As soon as a {@link MemberInjector} is found,
we use it to inject the members of {@code obj}.
</p>
558790
@Override
  public <T> void inject(T obj, Scope scope) {
    Class<? super T> currentClass = (Class<T>) obj.getClass();
    do {
      MemberInjector<? super T> memberInjector = MemberInjectorLocator.getMemberInjector(currentClass);
      if (memberInjector != null) {
        memberInjector.inject(obj, scope);
        return;
      } else {
        currentClass = currentClass.getSuperclass();
      }
    } while (currentClass != null);
  }
1267005
public void setClientContainer(boolean clientContainer) // F48603.7
    {
        setOwningFlow(clientContainer ? ReferenceFlowKind.CLIENT : null);
        if (isClientContainer() && ivInjectionClasses != null && !ivInjectionClasses.isEmpty()) {
            ivClientMainClass = ivInjectionClasses.get(0);
        }
    }
1153097
public Member addMember(Member member) {
		if (haveMember(member.getName())) {
			throw new FuzzerException(member.getName() + ": member already exists of variable '" + name + "'");
		}
		members.add(member);
		return member;
	}
274872
public void initializeAll(InjectionManager injectionManager) {
        if (injectionManager != null) {
            for (Converter<?> converter : _converters) {
                Field[] fields = ReflectionUtils.getFields(converter.getClass(), Inject.class);
                for (Field field : fields) {
                    final Object value;
                    if (field.getType() == Converter.class) {
                        // Injected converters are used as callbacks. They
                        // should be assigned to the outer converter, which is
                        // this.
                        value = this;
                    } else {
                        InjectionPoint<Object> injectionPoint = new MemberInjectionPoint<Object>(field, converter);
                        value = injectionManager.getInstance(injectionPoint);
                    }
                    field.setAccessible(true);
                    try {
                        field.set(converter, value);
                    } catch (Exception e) {
                        throw new IllegalStateException("Could not initialize converter: " + converter, e);
                    }
                }
            }
        }
    }
300065
function (member, memberValue, visibility) {
        if (undefined === visibility) {
            visibility = _GPF_VISIBILITY_PUBLIC;
        } else {
            visibility = _gpfVisibilityKeywords.indexOf(visibility);
            if (-1 === visibility) {
                gpf.Error.classInvalidVisibility();
            }
        }
        this._addMember(member, memberValue, visibility);
    }
501859
protected <T, X> FieldInjectionPointAttributes<T, X> processInjectionPoint(
            FieldInjectionPointAttributes<T, X> injectionPointAttributes, Class<?> declaringComponentClass,
            BeanManagerImpl manager) {
        return manager.getContainerLifecycleEvents().fireProcessInjectionPoint(injectionPointAttributes,
                declaringComponentClass, manager);
    }
403535
public static <T> ObjIterator<T> of(final Supplier<? extends Iterator<? extends T>> iteratorSupplier) {
        N.checkArgNotNull(iteratorSupplier, "iteratorSupplier");

        return new ObjIterator<T>() {
            private Iterator<? extends T> iter = null;
            private boolean isInitialized = false;

            @Override
            public boolean hasNext() {
                if (isInitialized == false) {
                    init();
                }

                return iter.hasNext();
            }

            @Override
            public T next() {
                if (isInitialized == false) {
                    init();
                }

                return iter.next();
            }

            private void init() {
                if (isInitialized == false) {
                    isInitialized = true;
                    iter = iteratorSupplier.get();
                }
            }
        };
    }
1311806
@Deprecated
    public void add(Object obj) throws Exception
    {
        add(obj, null, new LifecycleMethods(obj.getClass()));
    }
57148
@Override
    public InjectionBinding<PersistenceUnit> createInjectionBinding
                    (PersistenceUnit annotation, Class<?> instanceClass, Member member, String jndiName)
                                    throws InjectionException
    {
        JPAPUnitInjectionBinding injectionBindingResource = new JPAPUnitInjectionBinding(annotation, ivNameSpaceConfig);
        return injectionBindingResource;
    }
1274020
@Pure
	protected Injector getInjector() {
		if (this.builderInjector == null) {
			ImportManager importManager = this.importManagerProvider.get();
			this.builderInjector = createOverridingInjector(this.originalInjector, new CodeBuilderModule(importManager));
		}
		return builderInjector;
	}
680474
@Override
    public InjectionBinding<AdministeredObjectDefinition> createInjectionBinding(AdministeredObjectDefinition annotation, Class<?> instanceClass, Member member, String jndiName) throws InjectionException {
        InjectionBinding<AdministeredObjectDefinition> injectionBinding =
                        new AdministeredObjectDefinitionInjectionBinding(jndiName, ivNameSpaceConfig);
        injectionBinding.merge(annotation, instanceClass, null);
        return injectionBinding;
    }
728052
void root(ProtoType type) {
    if (type == null) throw new NullPointerException("type == null");
    checkArgument(!identifierSet.excludes(type));
    checkArgument(!members.containsKey(type));
    types.add(type);
  }
168859
@Override
    public Ref memberRef(Context cx, Object namespace, Object elem,
            int memberTypeFlags)
    {
        boolean attribute = (memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0;
        boolean descendants = (memberTypeFlags & Node.DESCENDANTS_FLAG) != 0;
        XMLName rv = XMLName.create(lib.toNodeQName(cx, namespace, elem),
                attribute, descendants);
        rv.initXMLObject(this);
        return rv;
    }
354596
public void processAnnotations(Class<?> classHierarchy)
                    throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "processAnnotations: " + classHierarchy);

        for (Class<?> klass = classHierarchy; klass != null && klass != Object.class; klass = klass.getSuperclass())
        {
            Field[] fields = getAllDeclaredFields(klass, classHierarchy);

            for (int processorIndex = 0; processorIndex < ivProviders.size(); processorIndex++)
            {
                InjectionProcessorProvider<?, ?> provider = ivProviders.get(processorIndex);

                processClassAnnotations(processorIndex, provider, klass);

                if (fields != null)
                {
                    processMemberAnnotations(processorIndex, provider, fields, fields);
                }
            }
        }

        Method[] methods = getAllDeclaredMethods(classHierarchy);
        for (int processorIndex = 0; processorIndex < ivProviders.size(); processorIndex++)
        {
            processMemberAnnotations(processorIndex, ivProviders.get(processorIndex), methods, methods);
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "processAnnotations");
    }
211337
static Class<?> getTypeFromMember(Member member) throws InjectionException {
        Class<?> memberType = null;
        if (member instanceof Field) {
            memberType = ((Field) member).getType();
        } else if (member instanceof Method) {
            Method method = (Method) member;
            if (method.getParameterTypes() == null || method.getParameterTypes().length != 1) {
                String msg = Tr.formatMessage(tc, "error.service.ref.member.level.annotation.wrong.method.name",
                                              method.getName(), method.getDeclaringClass().getName());
                throw new InjectionException(msg);
            }
            memberType = method.getParameterTypes()[0];
        }
        return memberType;
    }
1303719
public <T> T inject(Class<T> targetClass, T targetObject) {
		try {
			doInject(targetClass, targetObject);
			return targetObject;
		} catch (ReflectiveOperationException e) {
			throw new RuntimeException(e);
		}
	}
1337994
@Override
    public final InjectionBinding<A> createInjectionBinding(A annotation,
                                                            Class<?> instanceClass,
                                                            Member member,
                                                            String jndiName)
                    throws InjectionException
    {
        return createInjectionBinding(annotation, instanceClass, member);
    }