Scans class tree of component to process all its methods.

@param component all methods of its class tree will be processed.
@param context used to resolve dependencies.
@param contextDestroyer used to register destruction callbacks.
425830
private void processMethods(final Object component, final Context context,
            final ContextDestroyer contextDestroyer) {
        Class<?> componentClass = component.getClass();
        while (componentClass != null && !componentClass.equals(Object.class)) {
            final Method[] methods = ClassReflection.getDeclaredMethods(componentClass);
            if (methods != null && methods.length > 0) {
                processMethods(component, methods, context, contextDestroyer);
            }
            componentClass = componentClass.getSuperclass();
        }
    }
1161715
@Override
    public void visitClassContext(ClassContext classContext) {
        try {
            stack = new OpcodeStack();
            storeToUserValue = new HashMap<>();
            allocLocation = new HashMap<>();
            allocToAddPCs = new HashMap<>();
            optionalRanges = new ArrayList<>();
            super.visitClassContext(classContext);
        } finally {
            stack = null;
            storeToUserValue = null;
            allocLocation = null;
            allocToAddPCs = null;
            optionalRanges = null;
        }
    }
1067391
protected void fireContextDestroyed(AgentContext context) {
		final ContextRepositoryListener[] ilisteners = this.listeners.getListeners(ContextRepositoryListener.class);
		this.logger.getKernelLogger().info(MessageFormat.format(Messages.StandardContextSpaceService_1, context.getID()));
		for (final ContextRepositoryListener listener : ilisteners) {
			listener.contextDestroyed(context);
		}
	}
1040694
protected void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, "deactivate", "deactivating service references");
        }
        embeddableWebSphereTransactionManagerRef.deactivate(context);
        localTransactionCurrentRef.deactivate(context);
        resourceConfigFactoryRef.deactivate(context);
        dataSourceFactoryRef.deactivate(context);
        uowCurrentRef.deactivate(context);
        userTransactionRef.deactivate(context);
        if (isCompletedPassivation()) { //START 128284
            serializationServiceRef.deactivate(context);
        } else {

            while (!isCompletedPassivation()){
                try {
                    Thread.sleep(100L); // sleep 1/10th of a second
                } catch (InterruptedException e) {
                    FFDCFilter.processException(e, this.getClass().getName(), "180");
                } finally {
                    serializationServiceRef.deactivate(context);
                }
            }
        } // END 128284

    }
1277744
private synchronized void removeContext(final EvaluatorContext context) {
    this.contextStack.remove(context);
    this.contextIds.remove(context.getId());
  }
406477
public synchronized void destroyed(AppContextWrapper context) {
		try {
			ContainerRegistryBuilder cb = (ContainerRegistryBuilder) context
					.getAttribute(ContainerRegistryBuilder.APPLICATION_CONTEXT_ATTRIBUTE_NAME);
			if (cb != null) {
				ContainerDirector cd = new ContainerDirector(cb);
				cd.shutdown();
				context.removeAttribute(ContainerRegistryBuilder.APPLICATION_CONTEXT_ATTRIBUTE_NAME);
				containerBuilderContext = null;
				// context.removeAttribute(ContainerBuilder.APPLICATION_CONTEXT_ATTRIBUTE_NAME);
				Debug.logVerbose("[JdonFramework] stop the container ..", module);
			}
		} catch (Exception e) {
			Debug.logError("[JdonFramework] destroyed error: " + e, module);
		}

	}
224733
protected void deactivate(ComponentContext componentContext) {
        isShutdown.set(true);

        contextSvcRef.deactivate(componentContext);

        threadGroupTracker.threadFactoryDestroyed(name, threadGroup);
    }
830210
protected void destroyOldEngineComponent(ComponentList component) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, "destroyOldEngineComponent", component);
        }

        boolean removed = jmeComponents.remove(component);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            SibTr.debug(tc, "destroyOldEngineComponent, component removed from jmeComponents?", removed);
        }

        JsEngineComponent engineComponent = component.getRef();

        if (_state == STATE_STARTING || _state == STATE_STARTED || _state == STATE_STOPPING || _state == STATE_STOPPING_MEMBER || _state == STATE_FAILED) {
            // Stop engine component
            engineComponent.stop(JsConstants.ME_STOP_IMMEDIATE);
        }

        if (_state != STATE_UNINITIALIZED && _state != STATE_DESTROYED) {
            // Destroy
            engineComponent.destroy();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, "destroyOldEngineComponent");
        }
    }
208999
@SuppressWarnings({ "rawtypes", "unchecked" }) // Using correct types, but wildcards fail to see that.
    private void processType(final Object component, final Context context, final ContextDestroyer contextDestroyer) {
        final com.badlogic.gdx.utils.reflect.Annotation[] annotations = getAnnotations(component.getClass());
        if (annotations == null || annotations.length == 0) {
            return;
        }
        for (final com.badlogic.gdx.utils.reflect.Annotation annotation : annotations) {
            if (typeProcessors.containsKey(annotation.getAnnotationType())) {
                final Array<AnnotationProcessor<?>> typeProcessorsForAnnotation = typeProcessors
                        .get(annotation.getAnnotationType());
                // This might get resized in the process, so we're not using an iterator or assigning size.
                for (int index = 0; index < typeProcessorsForAnnotation.size; index++) {
                    final AnnotationProcessor processor = typeProcessorsForAnnotation.get(index);
                    processor.processType(component.getClass(),
                            annotation.getAnnotation(annotation.getAnnotationType()), component, context, this,
                            contextDestroyer);
                }
            }
        }
    }
871233
@Override
    public void visitClassContext(ClassContext classContext) {
        try {
            if ((invocationHandlerClass != null) && classContext.getJavaClass().implementationOf(invocationHandlerClass)) {
                return;
            }
            iConst0Looped = new BitSet();
            stack = new OpcodeStack();
            super.visitClassContext(classContext);
        } catch (ClassNotFoundException cnfe) {
            bugReporter.reportMissingClass(cnfe);
        } finally {
            iConst0Looped = null;
            stack = null;
        }
    }
877025
protected void deactivate(ComponentContext context) {
        deactivated = true;
        if (mbean != null)
            mbean.unregister();
        if (taskStore != null)
            DatabaseTaskStore.unget(persistentStore);
        appTrackerRef.deactivate(context);
        contextSvcRef.deactivate(context);
        controllerRef.deactivate(context);
        localTranCurrentRef.deactivate(context);
        serializationSvcRef.deactivate(context);
        tranMgrRef.deactivate(context);

    }
270373
@Trivial
    @Activate
    protected void activate(ComponentContext context) {
        Dictionary<String, ?> props = context.getProperties();
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(this, tc, "activate", props);

        String contextSvcName = (String) props.get(JNDI_NAME);
        if (contextSvcName == null)
            contextSvcName = (String) props.get(CONFIG_ID);

        lock.writeLock().lock();
        try {
            componentContext = context;
            properties = props;
            name = contextSvcName;
        } finally {
            lock.writeLock().unlock();
        }

        if (trace && tc.isEntryEnabled())
            Tr.exit(this, tc, "activate");
    }
348947
@SuppressWarnings("unchecked")
	public void contextDestroyed(ServletContextEvent sce) {
		WebContext<ServletContext> context = (WebContext<ServletContext>) container.component(container.contexts().get(Application.class));
		context.deassociate(sce.getServletContext());
		
		synchronized (Jaguar.class) {
			if (running()) {
				shutdown();
			}
		}
	}
3724
@Deactivate
    protected void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Deactivating");
        }
        instance.get().compareAndSet(this, null);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Destroying all endpoints");
        }
        EndPointMgrImpl.destroyEndpoints();

        try {
            this.chfw.destroy();
        } catch (Throwable t) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(this, tc, "Error destroying framework: " + t);
            }
        }

        this.chfw.deregisterFactory("TCPChannel");
        this.chfw.deregisterFactory("UDPChannel");
    }
873366
public void validate(FacesContext context,
                         UIComponent  component,
                         Object       value) throws ValidatorException {
	if (null == context || null == component) {
	    throw new NullPointerException();
	}
        try {
            methodBinding.invoke(context, new Object[] {context, component, 
							value});
        } 
	catch (EvaluationException ee) {
	    Throwable cause = this.getExpectedCause(ValidatorException.class,
						    ee);
	    if (cause instanceof ValidatorException) {
		throw ((ValidatorException) cause);
	    }
	    if (cause instanceof RuntimeException) {
		throw ((RuntimeException) cause);
	    }
	    throw new IllegalStateException(ee);
        }
	
	
    }
950742
@Override
	public void visitClassContext(ClassContext classContext) {
		try {
			stack = new OpcodeStack();
			localMethodCalls = new HashMap<>();
			fieldMethodCalls = new HashMap<>();
			staticMethodCalls = new HashMap<>();
			branchTargets = new BitSet();
			super.visitClassContext(classContext);
		} finally {
			stack = null;
			localMethodCalls = null;
			fieldMethodCalls = null;
			staticMethodCalls = null;
			branchTargets = null;
		}
	}
544290
public void deactivate(ComponentContext context) {
        if (contextRef.get() == null) {
            // Components are only deactivated if they activate successfully,
            // and component instances are discarded after being deactivated.
            // This is either DS or programmer error.
            throw new IllegalStateException("not activated");
        }

        this.contextRef.set(null);
    }