modules/core/src/main/java/org/apache/ignite/internal/processors/resource/GridResourceIoc.java - ignite - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.ignite.internal.processors.resource;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicReference;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.internal.managers.deployment.GridDeployment;
 import org.apache.ignite.internal.util.GridLeanIdentitySet;
 import org.apache.ignite.internal.util.IgniteUtils;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.T2;
 import org.apache.ignite.internal.util.typedef.X;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.resources.CacheNameResource;
 import org.apache.ignite.resources.CacheStoreSessionResource;
 import org.apache.ignite.resources.FileSystemResource;
 import org.apache.ignite.resources.IgniteInstanceResource;
 import org.apache.ignite.resources.JobContextResource;
 import org.apache.ignite.resources.LoadBalancerResource;
 import org.apache.ignite.resources.LoggerResource;
 import org.apache.ignite.resources.ServiceResource;
 import org.apache.ignite.resources.SpringApplicationContextResource;
 import org.apache.ignite.resources.SpringResource;
 import org.apache.ignite.resources.TaskContinuousMapperResource;
 import org.apache.ignite.resources.TaskSessionResource;
 import org.jetbrains.annotations.Nullable;
 import java.util.concurrent.ConcurrentHashMap;

 /**
  * Resource container contains caches for classes used for injection.
  * Caches used to improve the efficiency of standard Java reflection mechanism.
  */
 public class GridResourceIoc {
     /** Task class resource mapping. Used to efficiently cleanup resources related to class loader. */
     private final ConcurrentMap<ClassLoader, Set<Class<?>>> taskMap = new ConcurrentHashMap<>();

     /** Class descriptors cache. */
     private AtomicReference<Map<Class<?>, ClassDescriptor>> clsDescs = new AtomicReference<>();

     /**
      * @param ldr Class loader.
      */
     void onUndeployed(ClassLoader ldr) {
         Set<Class<?>> clss = taskMap.remove(ldr);

         if (clss != null) {
             Map<Class<?>, ClassDescriptor> newMap, oldMap;

             do {
                 oldMap = clsDescs.get();

                 if (oldMap == null)
                     break;

                 newMap = new HashMap<>(oldMap.size() - clss.size());

                 for (Map.Entry<Class<?>, ClassDescriptor> entry : oldMap.entrySet()) {
                     if (!clss.contains(entry.getKey()))
                         newMap.put(entry.getKey(), entry.getValue());
                 }
             }
             while (!clsDescs.compareAndSet(oldMap, newMap));
         }
     }

     /**
      * Clears all internal caches.
      */
     void undeployAll() {
         taskMap.clear();

         clsDescs.set(null);
     }

     /**
      * Injects given resource via field or setter with specified annotations on provided target object.
      *
      * @param target Target object.
      * @param annCls Setter annotation.
      * @param injector Resource to inject.
      * @param dep Deployment.
      * @param depCls Deployment class.
      * @return {@code True} if resource was injected.
      * @throws IgniteCheckedException Thrown in case of any errors during injection.
      */
     @SuppressWarnings("SimplifiableIfStatement")
     boolean inject(Object target,
         Class<? extends Annotation> annCls,
         GridResourceInjector injector,
         @Nullable GridDeployment dep,
         @Nullable Class<?> depCls)
         throws IgniteCheckedException {
         return injectInternal(target, annCls, injector, dep, depCls, null);
     }

     /**
      * @param dep Deployment.
      * @param cls Class.
      * @return Descriptor.
      */
     ClassDescriptor descriptor(@Nullable GridDeployment dep, Class<?> cls) {
         Map<Class<?>, ClassDescriptor> newMap, oldMap;
         ClassDescriptor res, newDesc = null;

         do {
             oldMap = clsDescs.get();

             if (oldMap != null && (res = oldMap.get(cls)) != null)
                 break;

             if (dep != null) {
                 Set<Class<?>> classes = F.addIfAbsent(taskMap, dep.classLoader(), F.<Class<?>>newCSet());

                 classes.add(cls);

                 dep = null;
             }

             if (oldMap == null)
                 newMap = new HashMap<>();
             else
                 (newMap = new HashMap<>(oldMap.size() + 1)).putAll(oldMap);

             newMap.put(cls, res = newDesc == null ? (newDesc = new ClassDescriptor(cls)) : newDesc);
         }
         while (!clsDescs.compareAndSet(oldMap, newMap));

         return res;
     }

     /**
      * @param target Target object.
      * @param annCls Setter annotation.
      * @param injector Resource to inject.
      * @param dep Deployment.
      * @param depCls Deployment class.
      * @param checkedObjs Set of already inspected objects to avoid indefinite recursion.
      * @return {@code True} if resource was injected.
      * @throws IgniteCheckedException Thrown in case of any errors during injection.
      */
     private boolean injectInternal(Object target,
         Class<? extends Annotation> annCls,
         GridResourceInjector injector,
         @Nullable GridDeployment dep,
         @Nullable Class<?> depCls,
         @Nullable Set<Object> checkedObjs)
         throws IgniteCheckedException {
         Class<?> targetCls = target.getClass();

         ClassDescriptor descr = descriptor(dep, targetCls);

         T2<GridResourceField[], GridResourceMethod[]> annotatedMembers = descr.annotatedMembers(annCls);

         return descr.injectInternal(target, annCls, annotatedMembers, injector, dep, depCls, checkedObjs);
     }

     /**
      * Checks if annotation is presented on a field or method of the specified object.
      *
      * @param target Target object.
      * @param annCls Annotation class to find on fields or methods of target object.
      * @param dep Deployment.
      * @return {@code true} if annotation is presented, {@code false} if it's not.
      */
     boolean isAnnotationPresent(Object target, Class<? extends Annotation> annCls, @Nullable GridDeployment dep) {
         assert target != null;
         assert annCls != null;

         ClassDescriptor desc = descriptor(dep, target.getClass());

         return desc.recursiveFields().length > 0 || desc.annotatedMembers(annCls) != null;
     }

     /**
      * Checks if annotation is presented on a field or method of the specified object.
      *
      * @param target Target object.
      * @param annSet Annotation classes to find on fields or methods of target object.
      * @param dep Deployment.
      * @return {@code true} if any annotation is presented, {@code false} if it's not.
      */
     boolean isAnnotationsPresent(@Nullable GridDeployment dep, Object target, AnnotationSet annSet) {
         assert target != null;
         assert annSet != null;

         return descriptor(dep, target.getClass()).isAnnotated(annSet) != 0;
     }

     /**
      * Gets set of methods with given annotation.
      *
      * @param dep Deployment.
      * @param cls Class in which search for methods.
      * @param annCls Annotation.
      * @return Set of methods with given annotations.
      */
     GridResourceMethod[] getMethodsWithAnnotation(@Nullable GridDeployment dep, Class<?> cls,
         Class<? extends Annotation> annCls) {
         ClassDescriptor desc = descriptor(dep, cls);

         T2<GridResourceField[], GridResourceMethod[]> t2 = desc.annotatedMembers(annCls);

         return t2 == null ? GridResourceMethod.EMPTY_ARRAY : t2.get2();
     }

     /** Print memory statistics */
     public void printMemoryStats() {
         X.println(">>>   taskMapSize: " + taskMap.size());

         Map<Class<?>, ClassDescriptor> map = clsDescs.get();
         X.println(">>>   classDescriptorsCacheSize: " + (map == null ? 0 : map.size()));
     }

     /**
      *
      */
     class ClassDescriptor {
         /** */
         private final Field[] recursiveFields;

         /** */
         private final Map<Class<? extends Annotation>, T2<GridResourceField[], GridResourceMethod[]>> annMap;

         /**
          * Uses as enum-map with enum {@link AnnotationSet} member as key,
          * and bitmap as a result of matching found annotations with enum set {@link ResourceAnnotation} as value.
          */
         private final int[] containsAnnSets;

         /** Uses as enum-map with enum {@link ResourceAnnotation} member as a keys. */
         private final T2<GridResourceField[], GridResourceMethod[]>[] annArr;

         /**
          * @param cls Class.
          */
         @SuppressWarnings("unchecked")
         ClassDescriptor(Class<?> cls) {
             Map<Class<? extends Annotation>, T2<List<GridResourceField>, List<GridResourceMethod>>> annMap
                 = new HashMap<>();

             List<Field> recursiveFieldsList = new ArrayList<>();

             boolean allowImplicitInjection = !GridNoImplicitInjection.class.isAssignableFrom(cls);

             for (Class cls0 = cls; !cls0.equals(Object.class); cls0 = cls0.getSuperclass()) {
                 for (Field field : cls0.getDeclaredFields()) {
                     Annotation[] fieldAnns = field.getAnnotations();

                     for (Annotation ann : fieldAnns) {
                         T2<List<GridResourceField>, List<GridResourceMethod>> t2 = annMap.get(ann.annotationType());

                         if (t2 == null) {
                             t2 = new T2<List<GridResourceField>, List<GridResourceMethod>>(
                                 new ArrayList<GridResourceField>(),
                                 new ArrayList<GridResourceMethod>());

                             annMap.put(ann.annotationType(), t2);
                         }

                         t2.get1().add(new GridResourceField(field, ann));
                     }

                     if (allowImplicitInjection
                         && fieldAnns.length == 0
                         && GridResourceUtils.mayRequireResources(field)) {
                         field.setAccessible(true);

                         // Account for anonymous inner classes.
                         recursiveFieldsList.add(field);
                     }
                 }

                 for (Method mtd : cls0.getDeclaredMethods()) {
                     for (Annotation ann : mtd.getAnnotations()) {
                         T2<List<GridResourceField>, List<GridResourceMethod>> t2 = annMap.get(ann.annotationType());

                         if (t2 == null) {
                             t2 = new T2<List<GridResourceField>, List<GridResourceMethod>>(
                                 new ArrayList<GridResourceField>(),
                                 new ArrayList<GridResourceMethod>());

                             annMap.put(ann.annotationType(), t2);
                         }

                         t2.get2().add(new GridResourceMethod(mtd, ann));
                     }
                 }
             }

             recursiveFields = recursiveFieldsList.isEmpty() ? U.EMPTY_FIELDS
                 : recursiveFieldsList.toArray(new Field[recursiveFieldsList.size()]);

             this.annMap = IgniteUtils.limitedMap(annMap.size());

             for (Map.Entry<Class<? extends Annotation>, T2<List<GridResourceField>, List<GridResourceMethod>>> entry
                 : annMap.entrySet()) {
                 GridResourceField[] fields = GridResourceField.toArray(entry.getValue().get1());
                 GridResourceMethod[] mtds = GridResourceMethod.toArray(entry.getValue().get2());

                 this.annMap.put(entry.getKey(), new T2<>(fields, mtds));
             }

             T2<GridResourceField[], GridResourceMethod[]>[] annArr = null;

             if (annMap.isEmpty())
                 containsAnnSets = null;
             else {
                 int annotationsBits = 0;

                 for (ResourceAnnotation ann : ResourceAnnotation.values()) {
                     T2<GridResourceField[], GridResourceMethod[]> member = annotatedMembers(ann.clazz);

                     if (member != null) {
                         if (annArr == null)
                             annArr = new T2[ResourceAnnotation.values().length];

                         annArr[ann.ordinal()] = member;

                         annotationsBits |= 1 << ann.ordinal();
                     }
                 }

                 AnnotationSet[] annotationSets = AnnotationSet.values();

                 containsAnnSets = new int[annotationSets.length];

                 for (int i = 0; i < annotationSets.length; i++)
                     containsAnnSets[i] = annotationsBits & annotationSets[i].annotationsBitSet;
             }

             this.annArr = annArr;
         }

         /**
          * @return Recursive fields.
          */
         Field[] recursiveFields() {
             return recursiveFields;
         }

         /**
          * @param annCls Annotation class.
          * @return Fields.
          */
         @Nullable T2<GridResourceField[], GridResourceMethod[]> annotatedMembers(Class<? extends Annotation> annCls) {
             return annMap.get(annCls);
         }

         /**
          * @param set annotation set.
          * @return {@code Bitmask} > 0 if any annotation is presented, otherwise return 0;
          */
         int isAnnotated(AnnotationSet set) {
             return recursiveFields.length > 0 ? set.annotationsBitSet :
                 (containsAnnSets == null ? 0 : containsAnnSets[set.ordinal()]);
         }

         /**
          * @param ann Annotation.
          * @return {@code True} if annotation is presented.
          */
         boolean isAnnotated(ResourceAnnotation ann) {
             return recursiveFields.length > 0 || (annArr != null && annArr[ann.ordinal()] != null);
         }

         /**
          * @param target Target object.
          * @param annCls Annotation class.
          * @param annotatedMembers Setter annotation.
          * @param injector Resource to inject.
          * @param dep Deployment.
          * @param depCls Deployment class.
          * @param checkedObjs Set of already inspected objects to avoid indefinite recursion.
          * @return {@code True} if resource was injected.
          * @throws IgniteCheckedException Thrown in case of any errors during injection.
          */
         boolean injectInternal(Object target,
             Class<? extends Annotation> annCls,
             T2<GridResourceField[], GridResourceMethod[]> annotatedMembers,
             GridResourceInjector injector,
             @Nullable GridDeployment dep,
             @Nullable Class<?> depCls,
             @Nullable Set<Object> checkedObjs)
             throws IgniteCheckedException {
             if (recursiveFields.length == 0 && annotatedMembers == null)
                 return false;

             if (checkedObjs == null && recursiveFields.length > 0)
                 checkedObjs = new GridLeanIdentitySet<>();

             if (checkedObjs != null && !checkedObjs.add(target))
                 return false;

             boolean injected = false;

             for (Field field : recursiveFields) {
                 try {
                     Object obj = field.get(target);

                     if (obj != null) {
                         assert checkedObjs != null;

                         ClassDescriptor desc = descriptor(dep, obj.getClass());
                         injected |= desc.injectInternal(obj, annCls, desc.annotatedMembers(annCls),
                             injector, dep, depCls, checkedObjs);
                     }
                 }
                 catch (IllegalAccessException e) {
                     throw new IgniteCheckedException("Failed to inject resource [field=" + field.getName() +
                         ", target=" + target + ']', e);
                 }
             }

             if (annotatedMembers != null) {
                 for (GridResourceField field : annotatedMembers.get1()) {
                     injector.inject(field, target, depCls, dep);

                     injected = true;
                 }

                 for (GridResourceMethod mtd : annotatedMembers.get2()) {
                     injector.inject(mtd, target, depCls, dep);

                     injected = true;
                 }
             }

             return injected;
         }

         /**
          * @param target Target object.
          * @param ann Setter annotation.
          * @param injector Resource to inject.
          * @param dep Deployment.
          * @param depCls Deployment class.
          * @return {@code True} if resource was injected.
          * @throws IgniteCheckedException Thrown in case of any errors during injection.
          */
         public boolean inject(Object target,
             ResourceAnnotation ann,
             GridResourceInjector injector,
             @Nullable GridDeployment dep,
             @Nullable Class<?> depCls)
             throws IgniteCheckedException {
             return injectInternal(target,
                 ann.clazz,
                 annArr == null ? null : annArr[ann.ordinal()],
                 injector,
                 dep,
                 depCls,
                 null);
         }
     }

     /**
      *
      */
     enum ResourceAnnotation {
         /** */
         CACHE_NAME(CacheNameResource.class),

         /** */
         SPRING_APPLICATION_CONTEXT(SpringApplicationContextResource.class),

         /** */
         SPRING(SpringResource.class),

         /** */
         IGNITE_INSTANCE(IgniteInstanceResource.class),

         /** */
         LOGGER(LoggerResource.class),

         /** */
         SERVICE(ServiceResource.class),

         /** */
         TASK_SESSION(TaskSessionResource.class),

         /** */
         LOAD_BALANCER(LoadBalancerResource.class),

         /** */
         TASK_CONTINUOUS_MAPPER(TaskContinuousMapperResource.class),

         /** */
         JOB_CONTEXT(JobContextResource.class),

         /** */
         CACHE_STORE_SESSION(CacheStoreSessionResource.class),

         /** */
         FILESYSTEM_RESOURCE(FileSystemResource.class);

         /** */
         public final Class<? extends Annotation> clazz;

         /**
          * @param clazz annotation class.
          */
         ResourceAnnotation(Class<? extends Annotation> clazz) {
             this.clazz = clazz;
         }
     }

     /**
      *
      */
     public enum AnnotationSet {
         /** */
         GENERIC(
             ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
             ResourceAnnotation.SPRING,
             ResourceAnnotation.IGNITE_INSTANCE,
             ResourceAnnotation.LOGGER,
             ResourceAnnotation.SERVICE
         ),

         /** */
         ENTRY_PROCESSOR(
             ResourceAnnotation.CACHE_NAME,

             ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
             ResourceAnnotation.SPRING,
             ResourceAnnotation.IGNITE_INSTANCE,
             ResourceAnnotation.LOGGER,
             ResourceAnnotation.SERVICE
         ),

         /** */
         TASK(
             ResourceAnnotation.TASK_SESSION,
             ResourceAnnotation.LOAD_BALANCER,
             ResourceAnnotation.TASK_CONTINUOUS_MAPPER,

             ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
             ResourceAnnotation.SPRING,
             ResourceAnnotation.IGNITE_INSTANCE,
             ResourceAnnotation.LOGGER,
             ResourceAnnotation.SERVICE
         ),

         /** */
         JOB(
             ResourceAnnotation.TASK_SESSION,
             ResourceAnnotation.JOB_CONTEXT,

             ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
             ResourceAnnotation.SPRING,
             ResourceAnnotation.IGNITE_INSTANCE,
             ResourceAnnotation.LOGGER,
             ResourceAnnotation.SERVICE
         );

         /** Resource annotations bits for fast checks. */
         public final int annotationsBitSet;

         /** Holds annotations in order */
         public final ResourceAnnotation[] annotations;

         /**
          * @param annotations ResourceAnnotations.
          */
         AnnotationSet(ResourceAnnotation... annotations) {
             assert annotations.length < 32 : annotations.length;

             this.annotations = annotations;

             int mask = 0;

             for (ResourceAnnotation ann : annotations)
                 mask |= 1 << ann.ordinal();

             annotationsBitSet = mask;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.ignite.internal.processors.resource;

	import java.lang.annotation.Annotation;
	import java.lang.reflect.Field;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.ConcurrentMap;
	import java.util.concurrent.atomic.AtomicReference;
	import org.apache.ignite.IgniteCheckedException;
	import org.apache.ignite.internal.managers.deployment.GridDeployment;
	import org.apache.ignite.internal.util.GridLeanIdentitySet;
	import org.apache.ignite.internal.util.IgniteUtils;
	import org.apache.ignite.internal.util.typedef.F;
	import org.apache.ignite.internal.util.typedef.T2;
	import org.apache.ignite.internal.util.typedef.X;
	import org.apache.ignite.internal.util.typedef.internal.U;
	import org.apache.ignite.resources.CacheNameResource;
	import org.apache.ignite.resources.CacheStoreSessionResource;
	import org.apache.ignite.resources.FileSystemResource;
	import org.apache.ignite.resources.IgniteInstanceResource;
	import org.apache.ignite.resources.JobContextResource;
	import org.apache.ignite.resources.LoadBalancerResource;
	import org.apache.ignite.resources.LoggerResource;
	import org.apache.ignite.resources.ServiceResource;
	import org.apache.ignite.resources.SpringApplicationContextResource;
	import org.apache.ignite.resources.SpringResource;
	import org.apache.ignite.resources.TaskContinuousMapperResource;
	import org.apache.ignite.resources.TaskSessionResource;
	import org.jetbrains.annotations.Nullable;
	import java.util.concurrent.ConcurrentHashMap;

	/**
	* Resource container contains caches for classes used for injection.
	* Caches used to improve the efficiency of standard Java reflection mechanism.
	*/
	public class GridResourceIoc {
	/** Task class resource mapping. Used to efficiently cleanup resources related to class loader. */
	private final ConcurrentMap<ClassLoader, Set<Class<?>>> taskMap = new ConcurrentHashMap<>();

	/** Class descriptors cache. */
	private AtomicReference<Map<Class<?>, ClassDescriptor>> clsDescs = new AtomicReference<>();

	/**
	* @param ldr Class loader.
	*/
	void onUndeployed(ClassLoader ldr) {
	Set<Class<?>> clss = taskMap.remove(ldr);

	if (clss != null) {
	Map<Class<?>, ClassDescriptor> newMap, oldMap;

	do {
	oldMap = clsDescs.get();

	if (oldMap == null)
	break;

	newMap = new HashMap<>(oldMap.size() - clss.size());

	for (Map.Entry<Class<?>, ClassDescriptor> entry : oldMap.entrySet()) {
	if (!clss.contains(entry.getKey()))
	newMap.put(entry.getKey(), entry.getValue());
	}
	}
	while (!clsDescs.compareAndSet(oldMap, newMap));
	}
	}

	/**
	* Clears all internal caches.
	*/
	void undeployAll() {
	taskMap.clear();

	clsDescs.set(null);
	}

	/**
	* Injects given resource via field or setter with specified annotations on provided target object.
	*
	* @param target Target object.
	* @param annCls Setter annotation.
	* @param injector Resource to inject.
	* @param dep Deployment.
	* @param depCls Deployment class.
	* @return {@code True} if resource was injected.
	* @throws IgniteCheckedException Thrown in case of any errors during injection.
	*/
	@SuppressWarnings("SimplifiableIfStatement")
	boolean inject(Object target,
	Class<? extends Annotation> annCls,
	GridResourceInjector injector,
	@Nullable GridDeployment dep,
	@Nullable Class<?> depCls)
	throws IgniteCheckedException {
	return injectInternal(target, annCls, injector, dep, depCls, null);
	}

	/**
	* @param dep Deployment.
	* @param cls Class.
	* @return Descriptor.
	*/
	ClassDescriptor descriptor(@Nullable GridDeployment dep, Class<?> cls) {
	Map<Class<?>, ClassDescriptor> newMap, oldMap;
	ClassDescriptor res, newDesc = null;

	do {
	oldMap = clsDescs.get();

	if (oldMap != null && (res = oldMap.get(cls)) != null)
	break;

	if (dep != null) {
	Set<Class<?>> classes = F.addIfAbsent(taskMap, dep.classLoader(), F.<Class<?>>newCSet());

	classes.add(cls);

	dep = null;
	}

	if (oldMap == null)
	newMap = new HashMap<>();
	else
	(newMap = new HashMap<>(oldMap.size() + 1)).putAll(oldMap);

	newMap.put(cls, res = newDesc == null ? (newDesc = new ClassDescriptor(cls)) : newDesc);
	}
	while (!clsDescs.compareAndSet(oldMap, newMap));

	return res;
	}

	/**
	* @param target Target object.
	* @param annCls Setter annotation.
	* @param injector Resource to inject.
	* @param dep Deployment.
	* @param depCls Deployment class.
	* @param checkedObjs Set of already inspected objects to avoid indefinite recursion.
	* @return {@code True} if resource was injected.
	* @throws IgniteCheckedException Thrown in case of any errors during injection.
	*/
	private boolean injectInternal(Object target,
	Class<? extends Annotation> annCls,
	GridResourceInjector injector,
	@Nullable GridDeployment dep,
	@Nullable Class<?> depCls,
	@Nullable Set<Object> checkedObjs)
	throws IgniteCheckedException {
	Class<?> targetCls = target.getClass();

	ClassDescriptor descr = descriptor(dep, targetCls);

	T2<GridResourceField[], GridResourceMethod[]> annotatedMembers = descr.annotatedMembers(annCls);

	return descr.injectInternal(target, annCls, annotatedMembers, injector, dep, depCls, checkedObjs);
	}

	/**
	* Checks if annotation is presented on a field or method of the specified object.
	*
	* @param target Target object.
	* @param annCls Annotation class to find on fields or methods of target object.
	* @param dep Deployment.
	* @return {@code true} if annotation is presented, {@code false} if it's not.
	*/
	boolean isAnnotationPresent(Object target, Class<? extends Annotation> annCls, @Nullable GridDeployment dep) {
	assert target != null;
	assert annCls != null;

	ClassDescriptor desc = descriptor(dep, target.getClass());

	return desc.recursiveFields().length > 0 \|\| desc.annotatedMembers(annCls) != null;
	}

	/**
	* Checks if annotation is presented on a field or method of the specified object.
	*
	* @param target Target object.
	* @param annSet Annotation classes to find on fields or methods of target object.
	* @param dep Deployment.
	* @return {@code true} if any annotation is presented, {@code false} if it's not.
	*/
	boolean isAnnotationsPresent(@Nullable GridDeployment dep, Object target, AnnotationSet annSet) {
	assert target != null;
	assert annSet != null;

	return descriptor(dep, target.getClass()).isAnnotated(annSet) != 0;
	}

	/**
	* Gets set of methods with given annotation.
	*
	* @param dep Deployment.
	* @param cls Class in which search for methods.
	* @param annCls Annotation.
	* @return Set of methods with given annotations.
	*/
	GridResourceMethod[] getMethodsWithAnnotation(@Nullable GridDeployment dep, Class<?> cls,
	Class<? extends Annotation> annCls) {
	ClassDescriptor desc = descriptor(dep, cls);

	T2<GridResourceField[], GridResourceMethod[]> t2 = desc.annotatedMembers(annCls);

	return t2 == null ? GridResourceMethod.EMPTY_ARRAY : t2.get2();
	}

	/** Print memory statistics */
	public void printMemoryStats() {
	X.println(">>> taskMapSize: " + taskMap.size());

	Map<Class<?>, ClassDescriptor> map = clsDescs.get();
	X.println(">>> classDescriptorsCacheSize: " + (map == null ? 0 : map.size()));
	}

	/**
	*
	*/
	class ClassDescriptor {
	/** */
	private final Field[] recursiveFields;

	/** */
	private final Map<Class<? extends Annotation>, T2<GridResourceField[], GridResourceMethod[]>> annMap;

	/**
	* Uses as enum-map with enum {@link AnnotationSet} member as key,
	* and bitmap as a result of matching found annotations with enum set {@link ResourceAnnotation} as value.
	*/
	private final int[] containsAnnSets;

	/** Uses as enum-map with enum {@link ResourceAnnotation} member as a keys. */
	private final T2<GridResourceField[], GridResourceMethod[]>[] annArr;

	/**
	* @param cls Class.
	*/
	@SuppressWarnings("unchecked")
	ClassDescriptor(Class<?> cls) {
	Map<Class<? extends Annotation>, T2<List<GridResourceField>, List<GridResourceMethod>>> annMap
	= new HashMap<>();

	List<Field> recursiveFieldsList = new ArrayList<>();

	boolean allowImplicitInjection = !GridNoImplicitInjection.class.isAssignableFrom(cls);

	for (Class cls0 = cls; !cls0.equals(Object.class); cls0 = cls0.getSuperclass()) {
	for (Field field : cls0.getDeclaredFields()) {
	Annotation[] fieldAnns = field.getAnnotations();

	for (Annotation ann : fieldAnns) {
	T2<List<GridResourceField>, List<GridResourceMethod>> t2 = annMap.get(ann.annotationType());

	if (t2 == null) {
	t2 = new T2<List<GridResourceField>, List<GridResourceMethod>>(
	new ArrayList<GridResourceField>(),
	new ArrayList<GridResourceMethod>());

	annMap.put(ann.annotationType(), t2);
	}

	t2.get1().add(new GridResourceField(field, ann));
	}

	if (allowImplicitInjection
	&& fieldAnns.length == 0
	&& GridResourceUtils.mayRequireResources(field)) {
	field.setAccessible(true);

	// Account for anonymous inner classes.
	recursiveFieldsList.add(field);
	}
	}

	for (Method mtd : cls0.getDeclaredMethods()) {
	for (Annotation ann : mtd.getAnnotations()) {
	T2<List<GridResourceField>, List<GridResourceMethod>> t2 = annMap.get(ann.annotationType());

	if (t2 == null) {
	t2 = new T2<List<GridResourceField>, List<GridResourceMethod>>(
	new ArrayList<GridResourceField>(),
	new ArrayList<GridResourceMethod>());

	annMap.put(ann.annotationType(), t2);
	}

	t2.get2().add(new GridResourceMethod(mtd, ann));
	}
	}
	}

	recursiveFields = recursiveFieldsList.isEmpty() ? U.EMPTY_FIELDS
	: recursiveFieldsList.toArray(new Field[recursiveFieldsList.size()]);

	this.annMap = IgniteUtils.limitedMap(annMap.size());

	for (Map.Entry<Class<? extends Annotation>, T2<List<GridResourceField>, List<GridResourceMethod>>> entry
	: annMap.entrySet()) {
	GridResourceField[] fields = GridResourceField.toArray(entry.getValue().get1());
	GridResourceMethod[] mtds = GridResourceMethod.toArray(entry.getValue().get2());

	this.annMap.put(entry.getKey(), new T2<>(fields, mtds));
	}

	T2<GridResourceField[], GridResourceMethod[]>[] annArr = null;

	if (annMap.isEmpty())
	containsAnnSets = null;
	else {
	int annotationsBits = 0;

	for (ResourceAnnotation ann : ResourceAnnotation.values()) {
	T2<GridResourceField[], GridResourceMethod[]> member = annotatedMembers(ann.clazz);

	if (member != null) {
	if (annArr == null)
	annArr = new T2[ResourceAnnotation.values().length];

	annArr[ann.ordinal()] = member;

	annotationsBits \|= 1 << ann.ordinal();
	}
	}

	AnnotationSet[] annotationSets = AnnotationSet.values();

	containsAnnSets = new int[annotationSets.length];

	for (int i = 0; i < annotationSets.length; i++)
	containsAnnSets[i] = annotationsBits & annotationSets[i].annotationsBitSet;
	}

	this.annArr = annArr;
	}

	/**
	* @return Recursive fields.
	*/
	Field[] recursiveFields() {
	return recursiveFields;
	}

	/**
	* @param annCls Annotation class.
	* @return Fields.
	*/
	@Nullable T2<GridResourceField[], GridResourceMethod[]> annotatedMembers(Class<? extends Annotation> annCls) {
	return annMap.get(annCls);
	}

	/**
	* @param set annotation set.
	* @return {@code Bitmask} > 0 if any annotation is presented, otherwise return 0;
	*/
	int isAnnotated(AnnotationSet set) {
	return recursiveFields.length > 0 ? set.annotationsBitSet :
	(containsAnnSets == null ? 0 : containsAnnSets[set.ordinal()]);
	}

	/**
	* @param ann Annotation.
	* @return {@code True} if annotation is presented.
	*/
	boolean isAnnotated(ResourceAnnotation ann) {
	return recursiveFields.length > 0 \|\| (annArr != null && annArr[ann.ordinal()] != null);
	}

	/**
	* @param target Target object.
	* @param annCls Annotation class.
	* @param annotatedMembers Setter annotation.
	* @param injector Resource to inject.
	* @param dep Deployment.
	* @param depCls Deployment class.
	* @param checkedObjs Set of already inspected objects to avoid indefinite recursion.
	* @return {@code True} if resource was injected.
	* @throws IgniteCheckedException Thrown in case of any errors during injection.
	*/
	boolean injectInternal(Object target,
	Class<? extends Annotation> annCls,
	T2<GridResourceField[], GridResourceMethod[]> annotatedMembers,
	GridResourceInjector injector,
	@Nullable GridDeployment dep,
	@Nullable Class<?> depCls,
	@Nullable Set<Object> checkedObjs)
	throws IgniteCheckedException {
	if (recursiveFields.length == 0 && annotatedMembers == null)
	return false;

	if (checkedObjs == null && recursiveFields.length > 0)
	checkedObjs = new GridLeanIdentitySet<>();

	if (checkedObjs != null && !checkedObjs.add(target))
	return false;

	boolean injected = false;

	for (Field field : recursiveFields) {
	try {
	Object obj = field.get(target);

	if (obj != null) {
	assert checkedObjs != null;

	ClassDescriptor desc = descriptor(dep, obj.getClass());
	injected \|= desc.injectInternal(obj, annCls, desc.annotatedMembers(annCls),
	injector, dep, depCls, checkedObjs);
	}
	}
	catch (IllegalAccessException e) {
	throw new IgniteCheckedException("Failed to inject resource [field=" + field.getName() +
	", target=" + target + ']', e);
	}
	}

	if (annotatedMembers != null) {
	for (GridResourceField field : annotatedMembers.get1()) {
	injector.inject(field, target, depCls, dep);

	injected = true;
	}

	for (GridResourceMethod mtd : annotatedMembers.get2()) {
	injector.inject(mtd, target, depCls, dep);

	injected = true;
	}
	}

	return injected;
	}

	/**
	* @param target Target object.
	* @param ann Setter annotation.
	* @param injector Resource to inject.
	* @param dep Deployment.
	* @param depCls Deployment class.
	* @return {@code True} if resource was injected.
	* @throws IgniteCheckedException Thrown in case of any errors during injection.
	*/
	public boolean inject(Object target,
	ResourceAnnotation ann,
	GridResourceInjector injector,
	@Nullable GridDeployment dep,
	@Nullable Class<?> depCls)
	throws IgniteCheckedException {
	return injectInternal(target,
	ann.clazz,
	annArr == null ? null : annArr[ann.ordinal()],
	injector,
	dep,
	depCls,
	null);
	}
	}

	/**
	*
	*/
	enum ResourceAnnotation {
	/** */
	CACHE_NAME(CacheNameResource.class),

	/** */
	SPRING_APPLICATION_CONTEXT(SpringApplicationContextResource.class),

	/** */
	SPRING(SpringResource.class),

	/** */
	IGNITE_INSTANCE(IgniteInstanceResource.class),

	/** */
	LOGGER(LoggerResource.class),

	/** */
	SERVICE(ServiceResource.class),

	/** */
	TASK_SESSION(TaskSessionResource.class),

	/** */
	LOAD_BALANCER(LoadBalancerResource.class),

	/** */
	TASK_CONTINUOUS_MAPPER(TaskContinuousMapperResource.class),

	/** */
	JOB_CONTEXT(JobContextResource.class),

	/** */
	CACHE_STORE_SESSION(CacheStoreSessionResource.class),

	/** */
	FILESYSTEM_RESOURCE(FileSystemResource.class);

	/** */
	public final Class<? extends Annotation> clazz;

	/**
	* @param clazz annotation class.
	*/
	ResourceAnnotation(Class<? extends Annotation> clazz) {
	this.clazz = clazz;
	}
	}

	/**
	*
	*/
	public enum AnnotationSet {
	/** */
	GENERIC(
	ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
	ResourceAnnotation.SPRING,
	ResourceAnnotation.IGNITE_INSTANCE,
	ResourceAnnotation.LOGGER,
	ResourceAnnotation.SERVICE
	),

	/** */
	ENTRY_PROCESSOR(
	ResourceAnnotation.CACHE_NAME,

	ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
	ResourceAnnotation.SPRING,
	ResourceAnnotation.IGNITE_INSTANCE,
	ResourceAnnotation.LOGGER,
	ResourceAnnotation.SERVICE
	),

	/** */
	TASK(
	ResourceAnnotation.TASK_SESSION,
	ResourceAnnotation.LOAD_BALANCER,
	ResourceAnnotation.TASK_CONTINUOUS_MAPPER,

	ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
	ResourceAnnotation.SPRING,
	ResourceAnnotation.IGNITE_INSTANCE,
	ResourceAnnotation.LOGGER,
	ResourceAnnotation.SERVICE
	),

	/** */
	JOB(
	ResourceAnnotation.TASK_SESSION,
	ResourceAnnotation.JOB_CONTEXT,

	ResourceAnnotation.SPRING_APPLICATION_CONTEXT,
	ResourceAnnotation.SPRING,
	ResourceAnnotation.IGNITE_INSTANCE,
	ResourceAnnotation.LOGGER,
	ResourceAnnotation.SERVICE
	);

	/** Resource annotations bits for fast checks. */
	public final int annotationsBitSet;

	/** Holds annotations in order */
	public final ResourceAnnotation[] annotations;

	/**
	* @param annotations ResourceAnnotations.
	*/
	AnnotationSet(ResourceAnnotation... annotations) {
	assert annotations.length < 32 : annotations.length;

	this.annotations = annotations;

	int mask = 0;

	for (ResourceAnnotation ann : annotations)
	mask \|= 1 << ann.ordinal();

	annotationsBitSet = mask;
	}
	}
	}