Initialize non-persistent fields and objects. These are common to both
warm and cold start. This function should only be called after persistent
values have either been recovered or initially created.
<p>
Feature 174199.2.8
169264
private void initializeNonPersistent() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "initializeNonPersistent");

        // Initialise MatchSpace
        _messageProcessorMatching = new MessageProcessorMatching(this);

        // Create the access checker for discriminator authorization
        _topicAuthorization = new TopicAuthorization(this);

        _searchResultsPool.setTopicAuthorization(_topicAuthorization);

        // set the authorizer into the general MP Access Checker
        _accessChecker.setTopicAuthorization(_topicAuthorization);

        // Create the administrator
        // Needs to be done before D3 initialise as it is used by D3.
        // Needs to be done after a DestinationManager has been recovered/setup
        _administrator = new AdministratorImpl(this);

        // Venu Liberty change
        //making all TRM related objects to NULL
        // These objects all togehter can have been removed, however as the decission had been take to 
        // keep ME-ME communication, retaining them so that ME-ME related artifacts would get built
        /*
         * // 175358 Locate TRM class using JsConstants
         * TrmMeMain trm = (TrmMeMain) _engine
         * .getEngineComponent(JsConstants.SIB_CLASS_TO_ENGINE);
         * 
         * if (trm == null) {
         * if (TraceComponent.isAnyTracingEnabled()
         * && tc.isEntryEnabled())
         * SibTr.exit(tc, "initializeNonPersistent", "WsRuntimeException");
         * 
         * // Log error to console
         * SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001", new Object[] {
         * "com.ibm.ws.sib.processor.impl.MessageProcessor",
         * "1:2117:1.445" });
         * 
         * throw new SIErrorException(nls.getFormattedMessage(
         * "INTERNAL_MESSAGING_ERROR_CWSIP0001", new Object[] {
         * "com.ibm.ws.sib.processor.impl.MessageProcessor",
         * "1:2122:1.445" }, null));
         * }
         * 
         * _destinationLocationManager = trm.getDestinationLocationManager();
         * _linkManager = trm.getLinkManager();
         * _mqLinkManager = trm.getMQLinkManager();
         * RoutingManager routingManager = trm.getRoutingManager();
         * CommsErrorListener errorListener = trm.getCommsErrorListener();
         */
        _destinationLocationManager = null;
        _linkManager = null;
        _mqLinkManager = null;
        RoutingManager routingManager = null;
        CommsErrorListener errorListener = null;

        _mpio.init(errorListener, routingManager);

        try {
            // Venu Liberty change:
            //commenting below line to avoid PMI
            //_rmImpl = SIBPmiRm.getInstance();
        } catch (Exception e) {
            FFDCFilter
                            .processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.MessageProcessor.initializeNonPersistent",
                                              "1:2142:1.445", this);

            SIErrorException e2 = new SIErrorException(nls.getFormattedMessage(
                                                                               "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                                                               new Object[] {
                                                                                             "com.ibm.ws.sib.processor.impl.MessageProcessor",
                                                                                             "1:2150:1.445", e }, null), e);

            SibTr.exception(tc, e2);

            if (TraceComponent.isAnyTracingEnabled()
                && tc.isEntryEnabled())
                SibTr.exit(tc, "initializeNonPersistent", e2);

            throw e2;
        }

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "initializeNonPersistent");
    }
191245
private void initialize() {
        if(this.initialized) {
            return;
        }
        if (LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.INFO)) {
            if (this.sessionStoreService==null) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, "initialize", "SessionMgrComponentImpl.noPersistence");
            } else {
                String modeName = "sessionPersistenceMode";
                Object modeValue = this.mergedConfiguration.get(modeName);
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, "initialize", "SessionMgrComponentImpl.persistenceMode", new Object[] { modeValue });
            }
        }
        SessionProperties.setPropertiesInSMC(this.serverLevelSessionManagerConfig, this.mergedConfiguration);
        String cloneId = SessionManagerConfig.getCloneId();
        if (cloneId == null) {
            if (this.sessionStoreService==null && SessionManagerConfig.isTurnOffCloneId()) {
                /*-
                 * In tWAS, WsSessionAffinityManager sets the CloneID to -1 when two conditions are both met:
                 * A) Running in a standalone server (com.ibm.ws.runtime.service.WLM#getMemberUID()==null)
                 * B) The HttpSessionCloneId custom property is not explicitly set
                 * 
                 * In addition, tWAS will set the CloneID to "" (the empty String) if a third condition is also met:
                 * C) The NoAdditionalSessionInfo custom property is set to "true"
                 * 
                 * In lWAS, there's no notion of a "standalone" server, because potentially any lWAS server 
                 * could require a CloneID for session affinity. As a result, our logic for using an
                 * empty Clone ID on lWAS needs to be different than our logic on tWAS.
                 * 
                 * Since most customers who specify a session store will be interested in session affinity,
                 * we'll assume that these customers are always interested in a non-empty Clone ID.
                 * 
                 * We'll also assume that customers who do not specify a session store who also explicitly
                 * set the noAdditionalInfo property to "true" would prefer an empty Clone ID.
                 * 
                 * All customers can always explicitly set the cloneId property to override these assumptions.
                 */
                cloneId = "";
            } else {
                String serverId = getServerId(); // never returns null
                if (TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "initialize", "serverId=" + serverId);
                }
                SessionManagerConfig.setServerId(serverId);
                cloneId = EncodeCloneID.encodeString(serverId); // never returns null
            }
            SessionManagerConfig.setCloneId(cloneId);
        }
        this.initialized=true;
    }
1316505
protected void init() {
        if (defaults) {
            initializeDefaults();
            return;
        }
        mapfx(cfgMap, new MapFunction<String, String>() {
            @Override
            public void apply(String name, String value) {
                processSetting(name, value);
            }
        });
        readComplete();
    }
311230
protected boolean fieldIsUninitialized( Field field )
    {
        try
        {
            return field != null && field.get( this ) == null;
        }
        catch ( IllegalAccessException e )
        {
            _log.error( "Error initializing field " + field.getName() + " in " + getDisplayName(), e );
            return false;
        }
    }
1274370
def do_init_cached_fields(self):
        

        cls_name = self.__class__

        # Build the fields information
        if Packet.class_default_fields.get(cls_name, None) is None:
            self.prepare_cached_fields(self.fields_desc)

        # Use fields information from cache
        if not Packet.class_default_fields.get(cls_name, None) is None:
            self.default_fields = Packet.class_default_fields[cls_name]
            self.fieldtype = Packet.class_fieldtype[cls_name]
            self.packetfields = Packet.class_packetfields[cls_name]

            # Deepcopy default references
            for fname in Packet.class_default_fields_ref[cls_name]:
                value = copy.deepcopy(self.default_fields[fname])
                setattr(self, fname, value)
1102867
private void initializeMapper() {
    if (valueClass == null) {
      valueMapper = CatchAllMapper.getInstance();
    } else {
      try {
        valueMapper = MapperFactory.getInstance().getMapper(valueClass);
      } catch (NoSuitableMapperException exp) {
        valueMapper = CatchAllMapper.getInstance();
      }

    }
  }
23516
public void init(BaseField field, BaseField fldTarget, boolean bSetModified)
    {
        super.init(field);
        m_fldTarget = fldTarget;
        m_bSetModified = bSetModified;

        this.setRespondsToMode(DBConstants.INIT_MOVE, false);
        this.setRespondsToMode(DBConstants.READ_MOVE, false);
    }
806188
public void init(Record record, DateTimeField field, String mainFilesFieldName)
    {
        super.init(record);
        m_field = field;
        if (field != null)
            if (field.getRecord() != record)
                field.addListener(new FieldRemoveBOnCloseHandler(this));
        this.mainFilesFieldName = mainFilesFieldName;
    }
504605
public void init(BaseField field, boolean bFirstTime)
    {
        super.init(field);
        m_bScreenMove = true;
        m_bInitMove = true;     // Only respond to init
        m_bReadMove = true;
        m_bFirstTime = bFirstTime;
    }
575668
void initialized() {
    LOG.info("initialized with " + size() + " entries " + lookups + " lookups");
    this.initialized = true;
    transientMap.clear();
    transientMap = null;
  }
1107878
public void init() {
    initConfigurators();
    configuratorsBeforeInit();
    initHistoryLevel();
    initExpressionManager();

    if (usingRelationalDatabase) {
      initDataSource();
    }

    initAgendaFactory();
    initHelpers();
    initVariableTypes();
    initBeans();
    initScriptingEngines();
    initClock();
    initBusinessCalendarManager();
    initCommandContextFactory();
    initTransactionContextFactory();
    initCommandExecutors();
    initServices();
    initIdGenerator();
    initBehaviorFactory();
    initListenerFactory();
    initBpmnParser();
    initProcessDefinitionCache();
    initProcessDefinitionInfoCache();
    initKnowledgeBaseCache();
    initJobHandlers();
    initJobManager();
    initAsyncExecutor();

    initTransactionFactory();

    if (usingRelationalDatabase) {
      initSqlSessionFactory();
    }

    initSessionFactories();
    initDataManagers();
    initEntityManagers();
    initHistoryManager();
    initJpa();
    initDeployers();
    initDelegateInterceptor();
    initEventHandlers();
    initFailedJobCommandFactory();
    initEventDispatcher();
    initProcessValidator();
    initDatabaseEventLogging();
    configuratorsAfterInit();
  }
1178080
public static void initialize(String[] args, RestartInitializer initializer) {
		initialize(args, false, initializer, true);
	}
727140
public void initAtStartup() {
        //final String appsToInit = ConfigurationManager.getConfigInstance().getString("evcache.appsToInit");
        final String appsToInit = EVCacheConfig.getInstance().getDynamicStringProperty("evcache.appsToInit", "").get();
        if (appsToInit != null && appsToInit.length() > 0) {
            final StringTokenizer apps = new StringTokenizer(appsToInit, ",");
            while (apps.hasMoreTokens()) {
                final String app = getAppName(apps.nextToken());
                if (log.isDebugEnabled()) log.debug("Initializing EVCache - " + app);
                initEVCache(app);
            }
        }
    }
847161
protected void initUserObject() {

        if (m_fieldconfiguration == null) {
            try {
                m_fieldconfiguration = m_searchManager.getFieldConfiguration(getParamFieldconfiguration());
                if (m_fieldconfiguration == null) {
                    m_fieldconfiguration = new CmsLuceneFieldConfiguration();
                }
            } catch (Exception e) {
                m_fieldconfiguration = new CmsLuceneFieldConfiguration();
            }
        }

        if (m_field == null) {
            try {
                Iterator<CmsSearchField> itFields = m_fieldconfiguration.getFields().iterator();
                while (itFields.hasNext()) {
                    CmsSearchField curField = itFields.next();
                    if (curField.getName().equals(getParamField())) {
                        m_field = curField;
                        break;
                    }
                }
                if (m_field == null) {
                    m_field = new CmsLuceneField();
                }
            } catch (Exception e) {
                m_field = new CmsLuceneField();
            }
        }
        if (m_mapping == null) {
            try {
                Iterator<I_CmsSearchFieldMapping> itMappings = m_field.getMappings().iterator();
                while (itMappings.hasNext()) {
                    I_CmsSearchFieldMapping curMapping = itMappings.next();
                    if (curMapping.getType().toString().equals(getParamType())
                        && (((curMapping.getParam() == null) && getParamParam().equals("-"))
                            || (curMapping.getParam().equals(getParamParam())))) {
                        m_mapping = curMapping;
                        break;
                    }
                }
                if (m_mapping == null) {
                    m_mapping = new CmsSearchFieldMapping(true);
                }
            } catch (Exception e) {
                m_mapping = new CmsSearchFieldMapping(true);
            }
        }
    }
1366813
public static void initialize()
    {
        if (AppConfigHandler.get().isQueryCacheDeactivated()) {
            QueryCache.NOOP = new NoOpQueryCache();
        } else {
            if (InfinispanCache.get().exists(QueryCache.INDEXCACHE)) {
                InfinispanCache.get().<String, QueryKey>getCache(QueryCache.INDEXCACHE).clear();
            } else {
                final Cache<String, QueryKey> cache = InfinispanCache.get().<String, QueryKey>getCache(
                                QueryCache.INDEXCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
            }
            if (InfinispanCache.get().exists(QueryCache.SQLCACHE)) {
                InfinispanCache.get().<QueryKey, Object>getCache(QueryCache.SQLCACHE).clear();
            } else {
                final Cache<QueryKey, Object> cache = InfinispanCache.get().<QueryKey, Object>getCache(
                                QueryCache.SQLCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
                cache.addListener(new SqlCacheListener());
            }
        }
    }
362141
public static void initialize() {

        if (initialized) return;

        SniffyConfiguration.INSTANCE.addTopSqlCapacityListener(new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                ConcurrentLinkedHashMap<String, Timer> oldValues = globalSqlStats;
                globalSqlStats =
                        new ConcurrentLinkedHashMap.Builder<String, Timer>().
                                maximumWeightedCapacity(SniffyConfiguration.INSTANCE.getTopSqlCapacity()).
                                build();
                globalSqlStats.putAll(oldValues);
            }

        });


        if (SniffyConfiguration.INSTANCE.isMonitorSocket()) {

            try {
                SnifferSocketImplFactory.install();
            } catch (IOException e) {
                e.printStackTrace();
            }

        } else {

            SniffyConfiguration.INSTANCE.addMonitorSocketListener(new PropertyChangeListener() {

                private boolean sniffySocketImplFactoryInstalled = false;

                @Override
                public synchronized void propertyChange(PropertyChangeEvent evt) {
                    if (sniffySocketImplFactoryInstalled) return;
                    if (Boolean.TRUE.equals(evt.getNewValue())) {
                        try {
                            SnifferSocketImplFactory.install();
                            sniffySocketImplFactoryInstalled = true;
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

            });

        }

        initialized = true;

    }
763501
public function initialize() {
        $this->keepSnapshots(true);
        $this->setup(
            array(
                'exceptionOnFailedSave' => true, //Throw an exception instead of returning false from saves
                'notNullValidations' => false //Allow empty strings instead of the wtf new \Phalcon\Db\RawValue('""');
            )
        );
        //Sets to only update the fields that are changed
        $this->useDynamicUpdate(true);
    }