<p>
This method is not implemented.
</p>

@ibm-api
494095
public void reinitializeClientDefaultSSLProperties() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "reinitializeClientDefaultSSLProperties");

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "reinitializeClientDefaultSSLProperties");
    }
1371796
@Override
  protected void scanForHandlesTypesClasses(com.ibm.ws.container.DeployedModule deployedModule,
                                            HashMap<ServletContainerInitializer, Class[]> handleTypesHashMap,
                                            HashMap<ServletContainerInitializer, HashSet<Class<?>>> onStartupHashMap) {

      String methodName = "scanForHandlesTypesClasses";
      
      boolean enableTrace = ( com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable (Level.FINE) );

      WebAnnotations webAppAnnotations;
      AnnotationTargets_Targets annotationTargets;
      InfoStore infoStore;
      
      try {
          com.ibm.wsspi.adaptable.module.Container moduleContainer = this.getModuleContainer();
          webAppAnnotations = moduleContainer.adapt(WebAnnotations.class);
          annotationTargets = webAppAnnotations.getAnnotationTargets();
          infoStore = webAppAnnotations.getInfoStore();

      } catch (UnableToAdaptException e) {
          logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
          return;
      }

      boolean didOpen = false;
      
      try {
          for (java.util.Map.Entry<ServletContainerInitializer, Class[]> sciEntry : handleTypesHashMap.entrySet() ) {
              ServletContainerInitializer sci = sciEntry.getKey();
              Class[] handlesTypesAnnotationClasses = sciEntry.getValue();
              
              HashSet<Class<?>> handlesTypesOnStartupSet = onStartupHashMap.get(sci);
    
              for ( Class<?> handlesTypesAnnotationClass : handlesTypesAnnotationClasses) {
                  String handlesTypesAnnotationClassName = handlesTypesAnnotationClass.getName();
                  
                  boolean isAnnotation = handlesTypesAnnotationClass.isAnnotation();
                  boolean isClassAnnotation = isAnnotation && WebAppSCIHelper.isClassTarget(handlesTypesAnnotationClass);   // 'isClassAnnotation' and 'isMethodAnnotation'
                  boolean isInherited = isClassAnnotation && handlesTypesAnnotationClass.isAnnotationPresent(java.lang.annotation.Inherited.class);
                  boolean isMethodAnnotation = isAnnotation && WebAppSCIHelper.isMethodTarget(handlesTypesAnnotationClass); // can both be true.
                  if ( enableTrace ) {
                      logger.logp(Level.FINE, CLASS_NAME, methodName, "Select on class [ {0} ]", handlesTypesAnnotationClassName);
                      logger.logp(Level.FINE, CLASS_NAME, methodName,"  isAnnotation() [ {0} ]", Boolean.valueOf(isAnnotation));
                      if (isAnnotation) {
                          logger.logp(Level.FINE, CLASS_NAME, methodName,"  isClassAnno()  [ {0} ]", Boolean.valueOf(isClassAnnotation));
                          logger.logp(Level.FINE, CLASS_NAME, methodName,"  isInherited()  [ {0} ]", Boolean.valueOf(isInherited));
                          logger.logp(Level.FINE, CLASS_NAME, methodName,"  isMethodAnno() [ {0} ]", Boolean.valueOf(isMethodAnnotation));
                      }
                  }
                  
                  if ( isAnnotation ) {
                      if (enableTrace) {
                          logger.logp(Level.FINE, CLASS_NAME, methodName, "Selection Annotation: [ {0} ]", handlesTypesAnnotationClassName);
                      }
                      if ( isClassAnnotation ) {
                          Set<String> annotatedClassNames;
                          
                          // d95160: Injection classes are obtained from metadata-complete and metadata-incomplete
                          //         regions, but not from excluded regions.
                          
                          // Note: This is different from TWAS, which also obtains injection classes from EXCLUDED regions.
                          
                          if ( isInherited ) { // If the annotation is inherited, we need all of its subclasses, too.
                              annotatedClassNames = annotationTargets.getAllInheritedAnnotatedClasses(handlesTypesAnnotationClassName,
                                                                                                      AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);

                          } else {
                              annotatedClassNames = annotationTargets.getAnnotatedClasses(handlesTypesAnnotationClassName,
                                                                                          AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);
                          }
                          
                          String classReasonText = "Selection on class annotation [ " + handlesTypesAnnotationClassName + " ]";     
                          for ( String annotatedClassName : annotatedClassNames ) {
                              addClassToHandlesTypesStartupSet(annotatedClassName, handlesTypesOnStartupSet, classReasonText);
                          }                      
                      }
                      
                      if ( isMethodAnnotation ) {
                          Set<String> testedClassNames = new HashSet<String>();
                          Set<String> foundClassNames = new HashSet<String>();
                          
                          // d95160: Injection classes are obtained from metadata-complete and metadata-incomplete
                          //         regions, but not from excluded regions.

                          // Note: This is different from TWAS, which also obtains injection classes from EXCLUDED regions.
                          
                          Set<String> selectedClassNames = annotationTargets.getClassesWithMethodAnnotation(handlesTypesAnnotationClassName,
                                                                                                            AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);
                          
                          for ( String selectedClassName : selectedClassNames ) {
                              if ( testedClassNames.contains(selectedClassName) ) {
                                  continue;
                              } else {
                                  testedClassNames.add(selectedClassName);
                              }
                              
                              foundClassNames.add(selectedClassName); // The annotation was found directly on this class.
                              
                              // d95160: An API should be added to obtain subclasses from a specified region,
                              //         as with the annotations access.
                              
                              Set<String> allSubclassNames = annotationTargets.getSubclassNames(selectedClassName);
                              
                              for ( String subclassName : allSubclassNames ) {
                                  if ( testedClassNames.contains(subclassName)) { 
                                      continue;
                                  } else {
                                      testedClassNames.add(subclassName);
                                  }
                                  
                                  if ( !didOpen ) {
                                      try {
                                          webAppAnnotations.openInfoStore();
                                      } catch (UnableToAdaptException e) {
                                          logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
                                          return;
                                      }
                                      didOpen = true;
                                  }
                                  
                                  ClassInfo subclassInfo = infoStore.getDelayableClassInfo(subclassName);                              
                                  if ( WebAppSCIHelper.anyMethodHasAnnotation(subclassInfo, handlesTypesAnnotationClassName) ) {
                                      foundClassNames.add(subclassName); // The annotation was found on an inherited method.
                                  }
                              }
                          }
                          
                          String methodReasonText = "Selection on method annotation [ " + handlesTypesAnnotationClassName + " ]";
                          for ( String foundClassName : foundClassNames ) {
                              addClassToHandlesTypesStartupSet(foundClassName, handlesTypesOnStartupSet, methodReasonText);                          
                          }                      
                      }   
                     
                  } else {
                      if (enableTrace) {
                          logger.logp(Level.FINE, CLASS_NAME, methodName, "Selection Type: [ {0} ]", handlesTypesAnnotationClass.getName() );
                      }
                      //exclude java/javax classes
                      
                      String actualClassReasonText = "Selection of handlesType class [ " + handlesTypesAnnotationClassName + " ]";
                      addClassToHandlesTypesStartupSet(handlesTypesAnnotationClassName, handlesTypesOnStartupSet, actualClassReasonText);
                      
                      String classesReasonText = "Selection on sub-classes of [ " + handlesTypesAnnotationClassName + " ]";
                      for ( String targetClassName : annotationTargets.getSubclassNames(handlesTypesAnnotationClassName)) {
                          addClassToHandlesTypesStartupSet(targetClassName, handlesTypesOnStartupSet, classesReasonText);
                      }
                      
                      String interfaceReasonText = "Selection on interface [ " + handlesTypesAnnotationClassName + " ]";
                      Set<String> implementerClassNames = annotationTargets.getAllImplementorsOf(handlesTypesAnnotationClassName);   
                      for ( String implementerClassName : implementerClassNames ) {
                          addClassToHandlesTypesStartupSet(implementerClassName, handlesTypesOnStartupSet, interfaceReasonText);
                      }                  
                  }
              }
          }
      } finally {
          if (didOpen) {
              try {
                  webAppAnnotations.closeInfoStore();
              } catch (UnableToAdaptException e) {
                  logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
              }              
          }
      }
  }
581590
private void initializeSFSBInitMethodMap(BeanMetaData bmd, Method[] methods) throws EJBConfigurationException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        String ejbName = bmd.enterpriseBeanName;

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

        // Get the init-method from ejb-jar.xml if there is an ejb-jar.xml file.
        // Note, eb is set to null if there is no ejb-jar.xml file.
        List<InitMethod> initList = null;
        EnterpriseBean eb = bmd.wccm.enterpriseBean;
        if (eb != null) {
            // Get init-method list for this Session bean from WCCM and process.
            Session sb = (Session) eb;
            List<InitMethod> imList = sb.getInitMethod();
            initList = imList;
        }

        // Populate HashMap of all of the Init methods for SFSB.
        HashMap<String, String> map = new HashMap<String, String>();
        boolean isSessionBean = (SessionBean.class).isAssignableFrom(bmd.enterpriseBeanClass);
        if (isSessionBean) {
            // The bean is written to EJB 2.1 API or earlier, so the ejbCreate<METHOD> are the
            // only methods that can be annotated as a Init method, but is not required
            // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
            // in the EJB 3 core specifications.
            String ejbCreate = "ejbCreate";
            int ejbCreateLength = ejbCreate.length();

            // Process any init-method from ejb-jar.xml file and verify an init-method
            // provided only specifies a ejbCreate method name.
            if (initList != null) {
                if (isTraceOn && tc.isDebugEnabled()) {
                    Tr.debug(tc, "verify init-method is for ejbCreate of bean written to EJB 2.1 API");
                }

                // Verify an init-method provided only specifies a ejbCreate method name.
                for (InitMethod im : initList) {
                    // Get SFSB method name and verify it is ejbCreate. Don't bother with
                    // verifying whether method exists by signature specified. The code
                    // below automatically treats all ejbCreate methods as an init method.
                    // The JITDeploy code has to match up method signature of the init-method
                    // with the create method on the home.  It will provide an error message if
                    // signature does not match.
                    String method = im.getBeanMethod().getMethodName();
                    if (!ejbCreate.equals(method)) {
                        // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                        // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                        // cannot be applied to the {0} method of the {1} enterprise bean.
                        Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                        Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                        throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                            "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it " +
                                                            "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                    }
                }
            }

            // For each public method of the bean.
            if (isTraceOn && tc.isDebugEnabled()) {
                Tr.debug(tc, "processing public ejbCreate methods written to EJB 2.1 API");
            }

            for (Method m : methods) {
                // Is the method a ejbCreate<METHOD>?
                String methodName = m.getName();
                if (methodName.startsWith(ejbCreate)) {
                    // It is a ejbCreate<METHOD>, so insert a map entry using
                    // create<METHOD> + JDIMethodSignature as the key and
                    // METHOD as the value.
                    String key;
                    if (methodName.length() <= ejbCreateLength) {
                        key = "create" + MethodAttribUtils.jdiMethodSignature(m);
                    } else {
                        String suffix = methodName.substring(ejbCreateLength);
                        key = "create" + suffix + MethodAttribUtils.jdiMethodSignature(m);
                    }

                    map.put(key, m.getName());
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "added key: " + key
                                     + ", for method name = " + m.getName());
                    }
                } else {
                    // Don't bother to look for annotations if all config data
                    // came from xml.
                    if (!bmd.metadataComplete) {
                        // The bean is written to EJB 3 API,  or earlier, so the ejbCreate<METHOD> are the
                        // only methods that can be annotated as a Init method, but is not required
                        // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
                        // in the EJB 3 core specifications.
                        // Not a ejbCreate<METHOD>.  Verify it is not annotated as a Init method.
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {

                            // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                            // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                            // cannot be applied to the {0} method of the {1} enterprise bean.
                            String method = m.toGenericString();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                            throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                                "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it "
                                                                +
                                                                "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                        }
                    } else {
                        if (isTraceOn && tc.isDebugEnabled()) {
                            Tr.debug(tc, "metadata complete, skipping Init annotations");
                        }
                    }
                }
            }
        } else {
            // The bean is written to EJB 3 API, so any method can be annotated as an Init method.
            // We only need to populate the HashMap if the EJB 3 bean has either a remote or
            // local home interface. If it has neither,  Init method will never be called,
            // so do not bother populating the map in that case.
            if (bmd.homeInterfaceClass != null || bmd.localHomeInterfaceClass != null) {
                // We have a remote or local home interface, so we need process init methods.
                // Always process any init-method from ejb-jar.xml file.
                if (initList != null) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing init-method from ejb-jar.xml for bean written to EJB 3.0 API");
                    }
                    for (InitMethod im : initList) {
                        // Attempt to find Method object for the InitMethod.
                        NamedMethod namedMethod = im.getBeanMethod();
                        Method m = DDUtil.findMethod(namedMethod, methods);

                        // Method found for InitMethod?
                        if (m == null) {
                            // CNTR0236E: The {1} enterprise bean has an init-method element, which specifies
                            //  the {0} method. This method is not a public method of this bean.
                            String method = namedMethod.getMethodName();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INIT_METHOD_NOT_FOUND_CNTR0236E", data);
                            throw new EJBConfigurationException("CNTR0236E: The " + bmd.enterpriseBeanName + " enterprise bean has an init-method element, which " +
                                                                "specifies the " + method + " method. This method is not a public method of this bean.");
                        } else {
                            // Method found. Create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = im.getCreateMethod().getMethodName();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                }

                // Don't bother to look for annotations if all config data
                // came from xml.
                if (!bmd.metadataComplete) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing Init annotations for bean written to EJB 3.0 API");
                    }

                    // Not metadata-complete, so we need to process all public methods
                    // to look for Init annotation.
                    for (Method m : methods) {
                        // Is this method annotated as an Init method?
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {
                            // Yes it is, so create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = initMethod.value();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                } else {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "metadata complete, skipping Init annotations for bean written to EJB 3.0 API");
                    }
                }
            }
        }

        // Put map in BeanMetaData if map is not empty. Otherwise, leave BMD
        // set to null.
        if (!map.isEmpty()) {
            bmd.ivInitMethodMap = map;
        }

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

    }
152946
@Override
    public void execute() throws BuildException {
        try {
            ProvisioningFeatureDefinition feature = new SubsystemFeatureDefinitionImpl(null, this.featureManifestFile);
            setProperty(this.appliesToProperty, feature.getHeader("IBM-AppliesTo"));
            setProperty(this.descriptionProperty, feature.getHeader("Subsystem-Description", Locale.ENGLISH));
            String displayName = feature.getHeader("Subsystem-Name", Locale.ENGLISH);
            setProperty(this.displayNameProperty, displayName);
            setProperty(this.strippedDisplayNameProperty, getStrippedAssetName(displayName));
        } catch (IOException e) {
            throw new BuildException(e);
        }
    }
1188553
@SuppressWarnings({"WMI", "unchecked"})
    public DBObject callLifecycleMethods(final Class<? extends Annotation> event, final Object entity, final DBObject dbObj,
                                         final Mapper mapper) {
        final List<ClassMethodPair> methodPairs = getLifecycleMethods((Class<Annotation>) event);
        DBObject retDbObj = dbObj;
        try {
            Object tempObj;
            if (methodPairs != null) {
                final HashMap<Class<?>, Object> toCall = new HashMap<Class<?>, Object>((int) (methodPairs.size() * 1.3));
                for (final ClassMethodPair cm : methodPairs) {
                    toCall.put(cm.clazz, null);
                }
                for (final Class<?> c : toCall.keySet()) {
                    if (c != null) {
                        toCall.put(c, getOrCreateInstance(c, mapper));
                    }
                }

                for (final ClassMethodPair cm : methodPairs) {
                    final Method method = cm.method;
                    final Object inst = toCall.get(cm.clazz);
                    method.setAccessible(true);

                    if (LOG.isDebugEnabled()) {
                        LOG.debug(format("Calling lifecycle method(@%s %s) on %s", event.getSimpleName(), method, inst));
                    }

                    if (inst == null) {
                        if (method.getParameterTypes().length == 0) {
                            tempObj = method.invoke(entity);
                        } else {
                            tempObj = method.invoke(entity, retDbObj);
                        }
                    } else if (method.getParameterTypes().length == 0) {
                        tempObj = method.invoke(inst);
                    } else if (method.getParameterTypes().length == 1) {
                        tempObj = method.invoke(inst, entity);
                    } else {
                        tempObj = method.invoke(inst, entity, retDbObj);
                    }

                    if (tempObj != null) {
                        retDbObj = (DBObject) tempObj;
                    }
                }
            }

            callGlobalInterceptors(event, entity, dbObj, mapper);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }

        return retDbObj;
    }
1111241
@Override
	public Method createJavaMethod() {
		Class<?> clazz = rtype.getClazz();
		String name = methodMember.getName();
		String methodDescriptor = methodMember.getDescriptor();

		ClassLoader classLoader = rtype.getTypeRegistry().getClassLoader();
		try {
			Class<?>[] params = Utils.toParamClasses(methodDescriptor, classLoader);
			Class<?> returnType = Utils.toClass(Type.getReturnType(methodDescriptor), classLoader);
			Class<?>[] exceptions = Utils.slashedNamesToClasses(methodMember.getExceptions(), classLoader);
			return JVM.newMethod(clazz, name, params, returnType, exceptions, methodMember.getModifiers(),
					methodMember.getGenericSignature());
		}
		catch (ClassNotFoundException e) {
			throw new IllegalStateException("Couldn't create j.l.r.Method for " + clazz.getName() + "."
					+ methodDescriptor, e);
		}
	}
840490
@Override
    public void initialize(JsMessagingEngine engine) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "initialize", engine);

        // Get the admin factory class
        try {
            jsaf = JsAdminFactory.getInstance();
        } catch (Exception e) {
            // No FFDC code needed
        }

        // Synchronize on stateChangeLock to manage the startup of the engine with
        // potential addition of new engine components via dynamic config.
//        processor = _mainImpl.mpService.getService().getInstance();
        ListIterator<ComponentList> li = null;
        boolean initializationFailed = false;

        synchronized (stateChangeLock) {

            setState(STATE_INITIALIZING);
            for (int i = 0; i < NUM_STOP_PHASES; i++)
            {
                stopSequence[i] = new Vector<ComponentList>();
            }
            try
            {
                _messageStore = JsMainAdminComponentImpl.messageStoreRef.getService();

            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

            _messageProcessor = loadClass(JsConstants.SIB_CLASS_MP, STOP_PHASE_1, true);

            // Initialize any engine components
            initializationFailed = false;

        } // synchronized(stateChangeLock)
        try {
            //Initialize the message store 
            _messageStore.initialize(this);
            //Initialize the message processor 
            _messageProcessor.initialize(this);
            setState(STATE_INITIALIZED);
        } catch (Exception e) {
            com.ibm.ws.ffdc.FFDCFilter.processException(e, CLASS_NAME + ".<init>", "625", this);
            SibTr.error(tc, "ME_CANNOT_BE_INITIALIZED_SIAS0033", new Object[] { _name, "MessageProcessor.java", "initialize()" });
            SibTr.exception(tc, e);
            initializationFailed = true;

        }
        if (initializationFailed) {
            destroy();
            // Cleanup finished...
            // Change state to UNINITIALIZED
            setState(STATE_UNINITIALIZED);
        } else {
            setState(STATE_INITIALIZED);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "initialize");
    }
189320
@Override
  public AnnotatedType api()
  {
    ServiceRefAmp delegate = delegate();
    
    if (delegate == null) {
      System.out.println("FAILED_DELEGATE: " + this);
    }
    
    return delegate().api();
  }
1123712
public void setOjbQuery(org.apache.ojb.broker.query.Query ojbQuery)
    {
        this.ojbQuery = ojbQuery;
    }
93565
public static void initialize(ConverterProperties converterProperties, Map<String, Object> converterBeans) {
        // 不允许使用该接口手动初始化
        if (isInitialized) {
            throw new UnsupportedOperationException(
                    "It is not allowed to initialize directly with the initialize interface");
        }

        log.info("Checkout configurations");
        checkProperties(converterProperties);
        log.info("Start initialize conversion environment");
        // 开启转换上下文标志
        isDisable = false;
        if (!converterProperties.isOnlyScanNonStaticMethod()) {
            initStaticActionMap(converterProperties.getScanPackages());
        }
        if (!converterProperties.isOnlyScanStaticMethod()) {
            initNonStaticActionMap(converterBeans);
        }
        // 严格模式下，必须存在转换器
        boolean isStrictFail = converterProperties.isStrictMode() && MapUtils.isEmpty(ACTION_MAP);
        if (isStrictFail) {
            throw NoConverterException.of("There is no any converter exist");
        }

        isInitialized = true;
        log.info("Conversion environment initialization completed");
    }
741221
@Override
    public int read (byte[] b, int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c;
        if (nonBlockingEnabled)
            c = this.read(0L);
        else
            c = in.read();

        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;
        return 1;
    }
340817
final public EJBMethodInfoImpl get(String methodSignature,
                                       String methodNameOnly,
                                       EJSWrapperBase wrapper,
                                       MethodInterface methodInterface, // d164221
                                       TransactionAttribute txAttr) // 199625
    {
        EJBMethodInfoImpl retVal = null;
        BeanMetaData bmd = wrapper.bmd;
        setup(bmd);// delay initting array so we can get slot count
        //d151861
        if ((topOfStack < 0) || orig)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "EJBMethodInfoStack::get called with neg TopOfStack " +
                             "or in orig mode:" + topOfStack + " orig: " + orig);
            orig = true;
            elements = null;//d166651
            retVal = bmd.createEJBMethodInfoImpl(bmd.container.getEJBRuntime().getMetaDataSlotSize(MethodMetaData.class));

        }//d151861
        else
        {
            if (topOfStack < elements.length)
            {
                retVal = elements[topOfStack++];
            }
            else
            {
                ++topOfStack;
                retVal = bmd.createEJBMethodInfoImpl(bmd.container.getEJBRuntime().getMetaDataSlotSize(MethodMetaData.class));
            }
        }

        retVal.initializeInstanceData(null, methodNameOnly, bmd, methodInterface, txAttr, false);
        return retVal;
    }
1136616
@Override
	public <T> Optional<T> queryForObject(String collection, Query query, Class<T> clazz, RequestMethod method) {

		Assert.notNull(collection, "Collection must not be null!");
		Assert.notNull(query, "Query must not be 'null'.");
		Assert.notNull(clazz, "Target class must not be 'null'.");

		query.setPageRequest(PageRequest.of(0, 1));
		QueryResponse response = querySolr(collection, query, clazz, method);

		if (response.getResults().size() > 0) {
			if (response.getResults().size() > 1) {
				LOGGER.warn("More than 1 result found for singe result query ('{}'), returning first entry in list", query);
			}
			return Optional.ofNullable(convertSolrDocumentListToBeans(response.getResults(), clazz).get(0));
		}
		return Optional.empty();
	}
1070519
@Override
    public String[] getjavaVMs() {
        final String methodName = "getjavaVMs";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, this);

        ArrayList<String> jvmArrayList = new ArrayList<String>();
        ObjectName obnToFind = null;//WebSphere:name=JVM,J2EEServer=com.ibm.ws.jca.jdbc.mbean.fat,j2eeType=JVM
        final String obnStr = "WebSphere:j2eeType=JVM,*";
        final MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        try {
            obnToFind = new ObjectName(obnStr);
        } catch (MalformedObjectNameException e) {
            //Should never happen because we are building the ObjectName without any user input
            if (trace && tc.isDebugEnabled())
                Tr.debug(tc, "Unable to create ObjectName with the string: " + obnStr, e);
        }
        Set<ObjectInstance> matchingMbeanList = mbs.queryMBeans(obnToFind, null);
        if (matchingMbeanList.size() == 0) {
            if (trace && tc.isDebugEnabled())
                Tr.debug(tc, methodName + ": matchingMbeanList.size(): " + matchingMbeanList.size()
                             + ", We didn't find any Mbean matching: " + obnStr);
            if (trace && tc.isEntryEnabled())
                Tr.exit(tc, methodName, this);
            return null;
        } else {
            for (ObjectInstance bean : matchingMbeanList) {
                if (trace && tc.isDebugEnabled())
                    Tr.debug(tc, "**  Found a matching MBean: " + bean.getObjectName().toString());
                jvmArrayList.add(bean.getObjectName().toString());
            }
        }

        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, this);

        return jvmArrayList.toArray(new String[jvmArrayList.size()]);
    }
1249167
@Override
    public T findUniqueUsingQueryModel(QueryModel queryModel)
            throws NoSuchItemException, TooManyItemsException, JeppettoException {
        T result;

        try {
            if (accessControlContextProvider == null
                || accessControlHelper.annotationAllowsAccess(persistentClass, queryModel.getAccessControlContext(), AccessType.Read)) {
                // noinspection unchecked
                result = (T) buildCriteria(queryModel).uniqueResult();
            } else {
                // noinspection unchecked
                result = (T) createAccessControlledQuery(queryModel).uniqueResult();
            }
        } catch (NonUniqueObjectException e) {
            throw new TooManyItemsException(e.getMessage());
        } catch (HibernateException e) {
            throw new JeppettoException(e);
        }

        if (result == null) {
            throw new NoSuchItemException(persistentClass.getSimpleName(), queryModel.toString());
        }

        return result;
    }
264662
public static void callStringBuilderLength(CodeBuilder b) {
        // Because of JDK1.5 bug which exposes AbstractStringBuilder class,
        // cannot use reflection to get method signature.
        TypeDesc stringBuilder = TypeDesc.forClass(StringBuilder.class);
        b.invokeVirtual(stringBuilder, "length", TypeDesc.INT, null);
    }
895538
@Override
  public Value<List<BigQueryLoadJobReference>> run(
      BigQueryStoreResult<GoogleCloudStorageFileSet> bigQueryStoreResult) throws Exception {
    BigQueryStoreResult<GoogleCloudStorageFileSet> outputResult = bigQueryStoreResult;
    List<GcsFilename> files = outputResult.getResult().getFiles();
    List<List<GcsFilename>> bundles =
        bundleFiles(files, BigQueryConstants.BIGQUERY_LOAD_DATA_SIZE_LIMIT);
    List<FutureValue<BigQueryLoadJobReference>> jobReferenceList = new ArrayList<>();
    for (List<GcsFilename> bundle : bundles) {
      jobReferenceList.add(futureCall(new BigQueryLoadFileSetJob(dataset, tableName, projectId,
          bundle, SerializableValue.of(Marshallers.getGenericJsonMarshaller(TableSchema.class),
              outputResult.getSchema())), immediate(Integer.valueOf(0))));
    }
    return futureList(jobReferenceList);
  }