Cache all the properties in the definition which take a bit of work to
generate (i.e. are in a different format from those in the actual definition
object).

Called when the Alias is first created and on subsequent config changes

@param definition
554031
private void processDefinition(DestinationAliasDefinition definition)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "processDefinition", definition);

        _definition = definition; // Null for BusHandler (foreign bus)

        // Null out previous cached settings first
        _forwardRoutingPath = null;
        _defaultFrp = null;
        _replyDest = null;
        _aliasDestinationAddr = null;
        _targetDestinationAddr = null;
        _hasScopedMessagePoints = false;
        _singleScopedQueuePointME = null;
        _scopedQueuePointMEs = null;

        if (_definition != null)
        {
            _aliasDestinationAddr = SIMPUtils.createJsDestinationAddress(_definition.getName(), null, getBus());
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(tc, "Alias destination address: " + _aliasDestinationAddr);

            _targetDestinationAddr = SIMPUtils.createJsDestinationAddress(getTargetName(), null, getTargetBus());
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(tc, "Target destination address: " + _targetDestinationAddr);

            // Convert array of names to list of jsDestinationAddresses for ForwardRoutingPath
            QualifiedDestinationName[] names = _definition.getForwardRoutingPath();
            if (names != null)
            {
                _forwardRoutingPath = new ArrayList<JsDestinationAddress>(names.length);
                _defaultFrp = new SIDestinationAddress[names.length];

                for (int name = 0; name < names.length; name++)
                {
                    JsDestinationAddress address =
                                    SIMPUtils.createJsDestinationAddress(names[name].getDestination(),
                                                                         null, // ME never set via config
                                                                         names[name].getBus());
                    _forwardRoutingPath.add(address);
                    _defaultFrp[name] = address;

                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(tc, "Forward routing path [" + name + "]: " + address);
                }
            }

            // Create a JsDestinationAddress from the qualifiedName of the reply destination
            QualifiedDestinationName replyName = _definition.getReplyDestination();
            if (replyName != null)
            {
                _replyDest = SIMPUtils.createJsDestinationAddress(replyName.getDestination(),
                                                                  messageProcessor.getMessagingEngineUuid(),
                                                                  replyName.getBus());
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "Reply destination: " + _replyDest);
            }

            SIBUuid8[] queuePoints = _definition.getScopedQueuePointMEs();
            if ((queuePoints != null) && (queuePoints.length > 0))
            {
                _hasScopedMessagePoints = true;

                if (queuePoints.length == 1)
                {
                    _singleScopedQueuePointME = queuePoints[0];
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(tc, "Single scoped Queue Point: " + queuePoints[0]);
                }
                else
                {
                    _scopedQueuePointMEs = new HashSet<SIBUuid8>();
                    for (int i = 0; i < queuePoints.length; i++)
                    {
                        _scopedQueuePointMEs.add(queuePoints[i]);
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                            SibTr.debug(tc, "Scoped Queue Point: " + queuePoints[i]);
                    }
                }
            }
            else if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(tc, "No scoped Queue Point");

            setReceiveAllowed(_definition);
        }
        else
            _isReceiveAllowed = true;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "processDefinition");
    }
1306143
private void addAliasDefinition(AliasDefinition aliasDef) {
        // Prerequisites:
        assert aliasDef != null;
        assert !m_aliasDefMap.containsKey(aliasDef.getName());
        assert aliasDef.getTableName().equals(this.getTableName());
        
        m_aliasDefMap.put(aliasDef.getName(), aliasDef);
    }
5525
@Override
	public void cacheResult(
		List<CPDefinitionGroupedEntry> cpDefinitionGroupedEntries) {
		for (CPDefinitionGroupedEntry cpDefinitionGroupedEntry : cpDefinitionGroupedEntries) {
			if (entityCache.getResult(
						CPDefinitionGroupedEntryModelImpl.ENTITY_CACHE_ENABLED,
						CPDefinitionGroupedEntryImpl.class,
						cpDefinitionGroupedEntry.getPrimaryKey()) == null) {
				cacheResult(cpDefinitionGroupedEntry);
			}
			else {
				cpDefinitionGroupedEntry.resetOriginalValues();
			}
		}
	}
938384
public void setAlias(String alias) {
        this.alias = (alias != null && alias.isEmpty() == false ? alias : null);
    }
567994
public function initialise(cache_definition $definition) {
        if ($this->is_initialised()) {
            throw new coding_exception('This mongodb instance has already been initialised.');
        }
        $this->database = $this->connection->selectDatabase($this->databasename);
        $this->definitionhash = 'm'.$definition->generate_definition_hash();
        $this->collection = $this->database->selectCollection($this->definitionhash);

        $options = array('name' => 'idx_key');

        $w = $this->usesafe ? 1 : 0;
        $wc = new MongoDB\Driver\WriteConcern($w);

        $options['writeConcern'] = $wc;

        $this->collection->createIndex(array('key' => 1), $options);
    }
147209
@Override
	public void clearCache(CPDefinition cpDefinition) {
		entityCache.removeResult(CPDefinitionModelImpl.ENTITY_CACHE_ENABLED,
			CPDefinitionImpl.class, cpDefinition.getPrimaryKey());

		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

		clearUniqueFindersCache((CPDefinitionModelImpl)cpDefinition, true);
	}
1005426
public void initProcessDefinitionCache() {
    if (processDefinitionCache == null) {
      if (processDefinitionCacheLimit <= 0) {
        processDefinitionCache = new DefaultDeploymentCache<ProcessDefinitionCacheEntry>();
      } else {
        processDefinitionCache = new DefaultDeploymentCache<ProcessDefinitionCacheEntry>(processDefinitionCacheLimit);
      }
    }
  }
589197
private void addAliasDeclarationNodes() {
    for (Entry<String, StringInfo> entry : stringInfoMap.entrySet()) {
      StringInfo info = entry.getValue();
      if (!info.isAliased) {
        continue;
      }
      String alias = info.getVariableName(entry.getKey());
      Node var = IR.var(IR.name(alias), IR.string(entry.getKey()));
      var.useSourceInfoFromForTree(info.parentForNewVarDecl);
      if (info.siblingToInsertVarDeclBefore == null) {
        info.parentForNewVarDecl.addChildToFront(var);
      } else {
        info.parentForNewVarDecl.addChildBefore(
            var, info.siblingToInsertVarDeclBefore);
      }
      compiler.reportChangeToEnclosingScope(var);
    }
  }
178345
private static void addBasePropertyDefinitions(AbstractTypeDefinition type) {

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.BASE_TYPE_ID,
                "Base Type Id",
                "Base Type Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.OBJECT_ID,
                "Object Id",
                "Object Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.OBJECT_TYPE_ID,
                "Type Id",
                "Type Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.ONCREATE,
                false,
                true));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.NAME,
                "Name",
                "Name",
                PropertyType.STRING,
                Cardinality.SINGLE,
                Updatability.READWRITE,
                false,
                true));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.CREATED_BY,
                    "Created By",
                    "Created By",
                    PropertyType.STRING,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.CREATION_DATE,
                    "Creation Date",
                    "Creation Date",
                    PropertyType.DATETIME,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.LAST_MODIFIED_BY,
                    "Last Modified By",
                    "Last Modified By",
                    PropertyType.STRING,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.LAST_MODIFICATION_DATE,
                    "Last Modification Date",
                    "Last Modification Date",
                    PropertyType.DATETIME,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.CHANGE_TOKEN,
                "Change Token",
                "Change Token",
                PropertyType.STRING,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

    }
30682
@Override
	protected void resetCache() {
		super.resetCache();
		cacheProperties.put(JawrConstant.SASS_GENERATOR_URL_MODE,
				useAbsoluteURL ? SASS_GENERATOR_ABSOLUTE_URL_MODE : SASS_GENERATOR_RELATIVE_URL_MODE);
	}
438572
protected function clearDefinitionCache()
    {
        $this->indexDefinitionCache = [];
        $this->indexListCache = [];
        $this->cache->delete(self::CID_LIST);
    }
812046
public void define() {
		staticInitializer = null;
		haveLookedForStaticInitializer = false;
		// DEFAULT METHODS - remove the if
		if (!typeDescriptor.isInterface()) {
			try {
				dispatcherClass = reloadableType.typeRegistry.defineClass(dispatcherName, dispatcher, false);
			}
			catch (RuntimeException t) {
				// TODO check for something strange.  something to do with the file detection misbehaving, see the same file attempted to be reloaded twice...
				if (t.getMessage().indexOf("duplicate class definition") == -1) {
					throw t;
				}
				else {
					t.printStackTrace();
				}
			}
		}
		try {
			executorClass = reloadableType.typeRegistry.defineClass(executorName, executor, false);
		}
		catch (RuntimeException t) {
			// TODO check for something strange.  something to do with the file detection misbehaving, see the same file attempted to be reloaded twice...
			if (t.getMessage().indexOf("duplicate class definition") == -1) {
				throw t;
			}
			else {
				t.printStackTrace();
			}
		}
		// DEFAULT METHODS - remove the if
		if (!typeDescriptor.isInterface()) {
			try {
				dispatcherInstance = dispatcherClass.newInstance();
			}
			catch (InstantiationException e) {
				throw new RuntimeException("Unable to build dispatcher class instance", e);
			}
			catch (IllegalAccessException e) {
				throw new RuntimeException("Unable to build dispatcher class instance", e);
			}
		}
	}
61487
public function initialise(cache_definition $definition) {
        // If the definition isn't using static acceleration then we need to be store data here.
        // The reasoning behind this is that:
        //   - If the definition is using static acceleration then the cache loader is going to
        //     store things in its static array.
        //   - If the definition is not using static acceleration then the cache loader won't try to store anything
        //     and we will need to store it here in order to make sure it is accessible.
        if ($definition->get_mode() !== self::MODE_APPLICATION) {
            // Neither the request cache nor the session cache provide static acceleration.
            $this->persist = true;
        } else {
            $this->persist = !$definition->use_static_acceleration();
        }
    }
1076321
public void registerContentDefinition(CmsContentDefinition definition) {

        getWidgetService().addConfigurations(definition.getConfigurations());
        CmsType baseType = definition.getTypes().get(definition.getEntityTypeName());
        m_entityBackend.registerTypes(baseType, definition.getTypes());
        for (CmsEntity entity : definition.getEntities().values()) {
            CmsEntity previousValue = m_entityBackend.getEntity(entity.getId());
            if (previousValue != null) {
                m_entityBackend.changeEntityContentValues(previousValue, entity);
            } else {
                m_entityBackend.registerEntity(entity);
                m_registeredEntities.add(entity.getId());
            }
        }
        for (Map.Entry<String, CmsComplexWidgetData> entry : definition.getComplexWidgetData().entrySet()) {
            String attrName = entry.getKey();
            CmsComplexWidgetData widgetData = entry.getValue();
            getWidgetService().registerComplexWidgetAttribute(
                attrName,
                widgetData.getRendererName(),
                widgetData.getConfiguration());
        }
    }
297973
@Override
	public void cacheResult(
		List<CPDefinitionVirtualSetting> cpDefinitionVirtualSettings) {
		for (CPDefinitionVirtualSetting cpDefinitionVirtualSetting : cpDefinitionVirtualSettings) {
			if (entityCache.getResult(
						CPDefinitionVirtualSettingModelImpl.ENTITY_CACHE_ENABLED,
						CPDefinitionVirtualSettingImpl.class,
						cpDefinitionVirtualSetting.getPrimaryKey()) == null) {
				cacheResult(cpDefinitionVirtualSetting);
			}
			else {
				cpDefinitionVirtualSetting.resetOriginalValues();
			}
		}
	}
758288
@Override
    public void updateStoreDefinition(StoreDefinition storeDef) {
        this.storeDef = storeDef;
        if(storeDef.hasRetentionPeriod())
            this.retentionTimeMs = storeDef.getRetentionDays() * Time.MS_PER_DAY;
    }
721879
@Override
	public void clearCache() {
		entityCache.clearCache(CPDefinitionSpecificationOptionValueImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}