2017 June Release

Customization pointsPermanent link for this heading

Customization points are defined within a customization model block. To declare a customization point, use the optional keyword customizationpoint, followed by the reference of the customization point and by parentheses holding the list of parameters. The declaration is finished with a semicolon.

Example

customizationpoint GetObjHint (
  key ObjectClass objclass,
  string suffix,
  retval string hint
);

customizationpoint GetAllowedAttrDef (
  key ObjectClass objclass,
  key AttributeObjectDef attrdef,
  out direct AttributeObjectDef outattrdef
);

customizationpoint GetAllowedExpression (
  key ObjectClass objclass,
  key AttributeObjectDef attrdef,
  out direct cfggetallowedextensions
);

customizationpoint GetTransferedAttribute(

  key ObjectClass objclass,
  key AttributeObjectDef attrdef,
  out direct boolean transferred
) {

  typecpaction = GetMergedPropertyValue;

}

Parameters denoted with the keyword key are used in customizations to define key values use dto specify the customization entries. If a key parameter can be left empty, it has to be marked as optional (optional key).

All input parameters are available in expression blocks (local scope) of customizations.

Output parameters (out, retval) normally are calculated by an expression. Using the keyword direct for output parameters gives the possibility to return the value directly without evaluating an expression.

It is also possible to specify a parameter by using a property definition.

By default the action FSCCONFIG@1.1001:GetMergedPropertyValueEx is used for resolving the customization point, resulting in a single line result.

If there are only direct parameters, the resolving action is FSCCONFIG@1.1001:GetMergedPropertyEx, resulting in a sorted list of configuration lines. To return only one line, specifiy the action to be used.

It is possible to define a customization point without key parameters. This results in a single line customization point for the specified output parameter.

Defining domain typesPermanent link for this heading

With help of Domain Types (COOSYSTEM@1.1:DomainType) it is possible to define configurations and ACLs abstractly for domain types instead of concrete domains. This can be achieved by using the keyword instance followed by the object class DomainType and the name of the instance reference.

Syntax

objmodel APPDUCXSAMPLE@200.200
{
  // Import declarations
  import softwarecomponent;

  ...
  // Creates an instance of a domain type
  instance DomainType DomainTypeReference {
    configurationreference = configurationobjectreference
    ...
  }
  ...
}

All configurations that are defined in the domain type instance can be used for customization points in foreign software components.

To reuse a defined configuration in your own software component, the configuration object instance has to be created manually. The reference of the configuration object instance has to comply with the following rule: reference of the domain type followed by the software component of the configuration followed by “Config” (e.g. DomainTypeAppducxSampleFSCCONFIGConfig).

Example

objmodel APPDUCXSAMPLE@200.200
{
  import COOSYSTEM@1.1;
  import FSCSMTP@1.1001;
  import FSCCONFIG@1.1001;


  instance AdministrationConfiguration DomainTypeAppducxSampleFSCCONFIGConfig {}

  instance DomainType DomainTypeAppducxSample {
    clientsmtpconfig = DefaultConfiguration;
    clientconfiguration = DomainTypeAppducxSampleFSCCONFIGConfig;
  }
}

Generic method implementation for customization pointsPermanent link for this heading

If a customization point needs additionally an implementation of a specified action with a specified method implementation for the object class defined in a customize statement, this can be defined in the customization point to reduce the effort in the customizing statements.

Example

objmodel APPDUCXSAMPLE@200.200
{
  import COOSYSTEM@1.1;

  extend instance NameBuild {
    typecpmethods<cpaction,cpmethdefinition> = {
      {
        EvaluateGenericNameBuild,
        MethodGenericNameBuild
      }
    }
  }
}

If this customization point is used for an object class in a customizing statement, the mapping is now created implicitly.