The following table lists the types derived from IReplicable .

Derived Types

Type Description
IChoiceList Represents a choice list in an object store. Each choice list contains a list collection of Choice objects that, when associated with a property, provides a discrete set of possible values that the property can hold. By using a choice list, you can enforce restrictions on property values.

There are two types of choice lists: integer and string. A choice list's type is specified by the following TypeID constant values, which are stored in a ChoiceList object's DataType property:

  • LONG: A ChoiceList object that represents a choice list that holds integer-type Choice objects. Each Choice object in such a choice list must represent either an integer-type choice item or a group node that holds a nested collection of integer-type Choice objects. An integer-type choice list cannot contain any string-type Choice objects.
  • STRING: A ChoiceList object that represents a choice list that holds string-type Choice objects. Each Choice object in such a choice list must represent either a string-type choice item or a group node that holds a nested collection of string-type Choice objects. A string-type choice list cannot contain any integer-type Choice objects.
Note that although there are eight TypeID constants, only LONG and STRING are valid constants for a ChoiceList object's DataType property.

A ChoiceList object is independently persistable (that is, it can be saved directly using its Save method) and controls the state of any dependently persistable Choice objects that belong to it. You can access each Choice object that belong to a ChoiceList object in the com.filenet.api.collection.ChoiceList collection that is specified by its ChoiceValues property. Each Choice object in this collection represents either an individual choice item or a group node for a nested collection of Choice objects.

A choice list's display name is stored in its DisplayName property and must be unique within an object store. Unlike a Choice object, a ChoiceList object does not have a mechanism for localizing its display name.

Choice list hierarchy is specified by its HasHierarchy property. This read-only property indicates whether a given choice list has a hierarchical structure or not. If the choice list contains at least one Choice object that represents a group node, the server automatically sets this property to true.

For a choice list to be useful, it must be associated with a property. You can either associate a choice list with a property template, therefore causing it to be automatically associated with every property definition created from that property template, or you can associate a choice list with an individual property definition. To associate a choice list with a property template or a property definition, set its ChoiceList property to the com.filenet.api.admin.ChoiceList object representing the choice list.

To create a new ChoiceList object, call the Factory.ChoiceList.CreateInstance method. Set the appropriate properties and add any Choice objects to the com.filenet.api.collection.ChoiceList collection specified by its ChoiceValues property. Call the Save method to save the new object to the persistent store. For the save to be successful you must, at a minimum, set the new ChoiceList object's DisplayName and DataType properties.

IClassDefinition Represents the class definition (mutable class metadata) of non-versionable, non-subscribable classes. Subclasses of the Subscribable class are defined in SubscribableClassDefinition objects, except for the Document class and its subclasses, which are defined in DocumentClassDefinition objects, and the Event class and its subclasses, which are defined in EventClassDefinition objects. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
ICodeModule Represents a user-implemented Java event handler that's executed when a IAction-based object's events are raised. The event handler can be a Java class or JAR file, and must reside on the Content Engine.

To create a ICodeModule object, call the CreateInstance method on the Factory.CodeModule class, and then set the content elements of the Java module with the ContentElements property. Each content element must have the correct mime type property. For content elements containing a Java class, acceptable mime types are "application/java", "application/java-byte-code", and "application/x-java-class". For content elements containing a JAR, acceptable mime types are "application/java-archive", "application/x-compressed", "application/x-zip-compressed", "application/zip", and "multipart/x-zip".

Note:

      The content elements that you set on a ICodeModule object must be of type IContentTransfer, not IContentReference. If you attempt to save a ICodeModule object with a IContentReference type in the content element list, the object will throw an EVENT_CM_CONTENTREFERENCE_NOT_ALLOWED exception.
      If you create a new version of a ICodeModule, such as by updating the event handler content, then you must set the new version to the CodeModule property of any IAction-based object for which the new ICodeModule version is intended.

To instantiate a ICodeModule object, call the GetInstance or FetchInstance method on the Factory.CodeModule class.

As an alternative to representing a Java event handler as a ICodeModule object, you could specify the Java event handler in the classpath of your application server. However, in an enterprise environment, we recommend that you check in an event handler and any supporting libraries as a code module. Code modules are automatically available when deploying the Content Engine to multiple application server instances, or moving your content metadata from one system to another. If you reference event handlers in the classpath of an application server, you must manually distribute them to new systems.

For cache configuration considerations, see the applicable code module-related properties in IServerCacheConfiguration interface.

See also the Javadocs for the following interfaces: DocumentClassifier, DocumentLifecycleActionHandler, EventActionHandler

IDocumentClassDefinition Represents the class definition (mutable class metadata) of the Document class and its subclasses. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
IEventClassDefinition Represents the class definition (mutable class metadata) of event classes whose instances can be subscribed to or audited. To instantiate a IEventClassDefinition object, call the getInstance or fetchInstance method on the Factory.EventClassDefinition class. To use IEventClassDefinition in a subscription or for auditing, set the EventClass property on a ISubscribedEvent or IAuditDefinition object, respectively.

You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.

IPropertyTemplate Represents the base class for all property template classes. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateBinary Represents a property template for creating PropertyDefinitionBinary objects, which you can add to class definitions to create user-defined properties for holding binary values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateBoolean Represents a property template for creating PropertyDefinitionBoolean objects, which you can add to class definitions to create user-defined properties for holding Boolean values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateDateTime Represents a property template for creating PropertyDefinitionDateTime objects, which you can add to class definitions to create user-defined properties for holding DateTime values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateFloat64 Represents a property template for creating PropertyDefinitionFloat64 objects, which you can add to class definitions to create user-defined properties for holding Double (Float64) values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateId Represents a property template for creating PropertyDefinitionId objects, which you can add to class definitions to create user-defined properties for holding GUID string values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateInteger32 Represents a property template for creating PropertyDefinitionInteger32 objects, which you can add to class definitions to create user-defined properties for holding integer values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateObject Represents a property template for creating PropertyDefinitionObject objects, which you can add to class definitions to create user-defined properties for holding Content Engine object values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IPropertyTemplateString Represents a property template for creating PropertyDefinitionString objects, which you can add to class definitions to create user-defined properties for holding string values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
IReplicableClassDefinition Represents the class definition (mutable class metadata) of classes of which an object instance can be replicated.
IStoragePolicy Represents a subset of available storage areas that are deemed equivalent based on common, user-specified criteria. If a Document or Annotation object is set to use this StoragePolicy, the Content Engine will assign a storage area from this subset (pseudo-randomly, to balance load).
ISubscribableClassDefinition Represents the class definition (mutable class metadata) of classes whose instances can be the target of a subscription and can be audited. SubscribableClassDefinition objects hold the class definitions for all subclasses of the Subscribable class except for the Document class and its subclasses, whose class definitions are held by DocumentClassDefinition objects. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
IVersionableClassDefinition Represents the parent of the DocumentClassDefinition class, which holds the class definition of a Document class and its subclasses.
IXMLPropertyMappingScript Represents the definition of a Document subclass for defining XML property mapping scripts. The Content Engine XML Classifier uses XML property mapping scripts to populate document object properties with values based on data extracted from an XML document’s content. Administrators build mapping scripts that associate XML tags in the incoming document to properties, thus enabling the automatic classification of any XML document. An XMLPropertyMappingScript object, in addition to having all of the capabilities of a Document object, provides a container for user-authored XSL scripts for transforming XML documents of a specified type. The script contains instructions for extracting content from source XML documents of the type identified by the XMLDocumentType property in order to map it onto property values for the properties associated with the target document class identified by the TargetClass property.
IAnnotation Represents an annotation that can be applied to a document, folder, or custom object. An Annotation object allows you to link additional information to a containable object. You can modify and delete annotations independently of their annotated object. However, you cannot create versions of an annotation separately from the object with which it is associated. Document annotations are uniquely associated with a single document version; they are not versioned or carried forward when their document version is updated and a new version created. By design, an annotation is deleted whenever its associated parent object is deleted. Although an annotation receives its default security from both the annotation's class and parent object, you can apply security to an annotation that is different from the security applied to its parent.

To create a new Annotation object and associate it with a document, use the document object's CreateAnnotation method. To create a new Annotation object and associate it with a folder or custom object, first use the Factory.Annotation.CreateInstance() method to create a new Annotation object, then set its AnnotatedObject property to reference the object to which you want it associated. An annotation's content data can be specified via its ContentElements collection.

IComponentRelationship Defines a hierarchical relationship between two documents as components in a compound document.

One document is the designated parent component (ParentComponent property) and the other is the designated child component. The child component document can be either a P8 Content Engine document (ChildComponent property) or a URI document (URIValue property). A document can be referenced by more than one instance of this class and consequently can be designated as a component in more than one relationship; this capability allows documents to be networked together to form compound documents with numerous components.

The two documents in a component relationship might be bound to each other as a result of that relationship. Document binding means the child component document exists in the child documents collection (ChildDocuments property) for the parent component, and the parent component document exists in the parent documents collection (ParentDocuments property) for the child component. This binding can be conditional; for example, it can be conditional on the value for one of the properties on the child document matching an expected value. Also, the child component can be a URI document instead of a Document object. Consequently, not every component relationship results in a document binding. For more information on component relationship types and which properties you are required to set when you create a new ComponentRelationship object, see the ComponentRelationshipType property.

The two documents in a component relationship do not have to belong to the same object store. Also, these documents can continue to be used and referenced as individual documents, just as if they had never entered into a component relationship with each other.

The parent component document determines security for each instance of this class. Users with write permission (AccessRight.WRITE) to the parent component have the same rights to that component relationship instance. Permission to delete a component relationship instance requires AccessRight.DELETE or AccessRight.UNLINK rights on the parent component document.

IContainmentRelationship Models containment relationships. These can be either ReferentialContainmentRelationship or DynamicReferentialContainmentRelationship objects.
ICustomObject Represents a general interface that can be subclassed. A CustomObject object has no inherent semantics, but is independently securable and can be persisted to an object store. A CustomObject does not carry content, is not versionable, and does not support lifecycle functionality.

The ICustomObject base interface provides a minimal set of properties (such as Creator, DateCreated, and Name). Unlike most Content Engine objects, the ICustomObject base interface does not have a specific property defined as the name property in order that subclassed objects can define it in an appropriate way. Because a CustomObject object does not have a defined name property, the value of its Name property reverts to the default value, which is the same as its ID property.

IDocument Represents a single version of a document stored in an object store. In addition to being versionable, a Document object can be subclassed and can carry content, which is stored in one or more content elements. Each content element represents content data, which can either be local to an object store (represented by a ContentTransfer object) or external to an object store and therefore outside the control of the Content Engine server (represented by a ContentReference object). In addition, a Document object can be associated with a document lifecycle policy. A document lifecycle policy defines a set of valid lifecycle states for a document, controls the transition of those states, and specifies the actions to be taken when a document's lifecycle state changes.
IDynamicReferentialContainmentRelationship Represents a dynamic relationship between two Containable subclasses: a container and the current version of a Document. The object-valued Head and Tail properties express the relationship. The tail always references a Folder (the container), while the head references the current version of a Document.
IFolder Represents a container that can hold other Containable subclasses, but cannot have content data of its own. Although Folder objects and their subclasses can be referentially contained, they are the only Containable subclass that can be directly contained (in a Folder). All other Containable subclasses are referentially contained using the ReferentialContainmentRelationship or DynamicReferentialContainmentRelationship classes.

Note: Folders that are referentially contained cannot participate in hierarchy index searches.

The container hierarchy is a one-to-many relationship: a folder can have many child folders, but a child folder can have only one parent folder. At the top of the container hierarchy is an automatically-created root folder. Use ObjectStore.RootFolder to get a reference to the root folder.

Folders are not versionable.

ReferentialContainmentRelationshipDynamicReferentialContainmentRelationship
ILink Represents a relationship between two objects. The object-valued Head and Tail properties express the relationship. Use a Link object for many-to-many relationships between any objects, or for referential containment relationships between objects that are not instances of Containable subclasses.

Note: This is a weak link relationship: both the Head and Tail properties have their DeletionAction metadata properties set to None. If you delete the object referenced by the head or tail, the Link object itself is not deleted.

IReferentialContainmentRelationship Represents a static relationship between two Containable subclasses: a container and a containee. The object-valued Head and Tail properties express the relationship. The tail always references a Folder (the container), while the head references the containee: another Containable subclass (such as another Folder, a CustomObject, or a Document). When the head is a Document object, it represents a specific document version.
IRelationship Represents the base class for binary relationships between independently persistable objects of an object store.
IWorkflowDefinition Represents a workflow definition, an XML document of class "WorkflowDefinition" that is stored in a Content Engine object store. A workflow definition describes the instructions, paths, and queues available to a workflow, and acts as a processing template that the Process Engine uses each time the workflow runs. Workflow definition documents are versionable, containable, and can have a lifecycle associated with them.

The IWorkflowDefinition interface extends the IDocument interface, and can, therefore, be treated as a Document object. For example, a WorkflowDefinition object can have workflows linked to it. Therefore, a user selecting a workflow definition can either launch it, or launch a linked workflow.

To create a new WorkflowDefinition object and persist it to a Content Engine object store, call the CreateInstance method on the Factory.WorkflowDefinition class.

After you create a workflow definition, you link it to an object that implements the Subscribable interface by setting the SubscriptionTarget and WorkflowDefinition properties on a workflow subscription object (InstanceWorkflowSubscription or ClassWorkflowSubscription object). Note that you cannot delete a WorkflowDefinition object if a workflow subscription object refers to it in its WorkflowDefinition property.

To return all of the workflow subscription objects associated with this WorkflowDefinition object, retrieve the WorkflowSourceSubscriptions property.

You can instantiate a WorkflowDefinition object in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.WorkflowDefinition class.
  • By retrieving the WorkflowDefinition property on a workflow subscription object.
  • By instantiating a WorkflowDefinitionSet collection, then returning a WorkflowDefinition object from the collection.
IAction Represents an extensible, user-implemented action in response to an event triggered on a source object. This interface is the base for subinterfaces representing implemented actions to be taken for specific events, such as changing a document's lifecycle or deleting an object. The Content Engine Java API provides event handling interfaces that you must implement with the actions to be taken, coded as a Java module. You link an IAction-based object to an implemented event handler by setting the ProdId property. If you check in the Java module to a Content Engine object store, you must set the CodeModule property as well (see ICodeModule). Instead of checking in the Java module, you can set its location in the class path of the application server.

See also the Javadocs for the following interfaces: DocumentClassifier, DocumentLifecycleActionHandler, EventActionHandler

IActionConsumer Represents the consumer of Action-based objects. This interface is the base for subinterfaces representing specific consumers, namely, ISubscription-based interfaces and IDocumentLifecyclePolicy. Generally speaking, IActionConsumer objects enable user-implemented actions to execute when specified events fire on a specified Content Engine object.

You can instantiate a persisted IActionConsumer object by calling the getInstance or fetchInstance method on the Factory.ActionConsumer class.

See also the help for the following interfaces: DocumentClassifier, DocumentLifecycleActionHandler, EventActionHandler.

IClassSubscription Represents a subscription for events generated by all objects of a particular class. The target for these subscriptions must be a class definition.

To create a IClassSubscription object, call the CreateInstance method on the Factory.ClassSubscription class.

You can instantiate a persisted IClassSubscription object in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.ClassSubscription class.
  • By instantiating a ISubscriptionSet collection, then returning a IClassSubscription object from the collection.
IClassWorkflowSubscription Represents a subscription that initiates a workflow in response to events generated by all objects of a particular class. A IClassWorkflowSubscription object provides object properties to link a workflow (IWorkflowDefinition), a target object, and one or more events (ISubscribedEvent) that can be triggered on the target object. These objects must exist before you can create a IClassWorkflowSubscription object and persist it.

To create a IClassWorkflowSubscription object, call the createInstance method on the Factory.ClassWorkflowSubscription class.

You can instantiate a persisted IClassWorkflowSubscription object in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.ClassWorkflowSubscription class.
  • By instantiating a ISubscriptionSet collection, then returning a IClassWorkflowSubscription object from the collection.
  • By getting the WorkflowSubscriptions property on an IClassDefinition object, then iterating the IClassWorkflowSubscriptionSet collection.
IDocumentClassificationAction Defines the content type and the server-side Java implementation that automatically classifies a document of the defined content type. You must create the Java classifier by implementing the DocumentClassifier interface. To specify the content type of the documents for which a IDocumentClassificationAction object will apply, set the MimeType property. To specify the implemented Java classifier, set the ProgId property. Each IDocumentClassificationAction object that you create and save in a given object store is automatically added to the object store's collection of IDocumentClassificationAction objects.
IDocumentLifecycleAction Represents the actions to be taken when a document's lifecycle state is changed. A document's lifecycle states are defined in the DocumentStates collection of its associated DocumentLifecyclePolicy object. A document lifecycle policy defines a set of valid lifecycle states for a document, controls the transition of those states, and specifies the actions to be taken when a document's lifecycle state changes. To change the lifecycle state of a document, call its ChangeState method; you can change a document's current lifecycle state to another predefined state, set it to an exception state, or clear it from an exception state by specifying the appropriate LifecycleChangeFlags constant in the flags parameter.

To define the actions to take when a document’s lifecycle state is changed, write a Java handler class that implements the DocumentLifecycleActionHandler interface and code the actions to be taken for each type of lifecycle state change in the appropriate method. After you have finished writing the Java handler, you have two choices:

  • Check in the Java handler as a document and create a CodeModule object (using its CreateInstance factory method). Set the CodeModule property of the DocumentLifecycleAction object to the document that you checked in, and cast it as a CodeModule object.
  • Specify the Java handler in the classpath of your application server (it is not necessary to create a CodeModule object).

Lastly, set the ProgId property of the DocumentLifecycleAction object to the fully qualified package and class name of the Java handler.

IDocumentLifecyclePolicy Represents the lifecycle policy for a document. A document lifecycle policy defines a set of valid lifecycle states for a document, controls the transition of those states, and specifies the actions to be taken and which access permissions to be applied when a document's lifecycle state changes.

To define the lifecycle states in a document lifecycle policy, create a DocumentState object for each lifecycle state that you want to define and add it to the DocumentStateList collection referenced by the DocumentState property. You can set the ResetLifecycleOnCheckin property to define whether a document, when it is checked in, is reset to the initial lifecycle state in its document lifecycle policy or not. To define the actions to be taken when a document's lifecycle state changes, create a DocumentLifecycleAction object and set the DocumentLifecycleAction property to reference it. With the PreseveDirectPermissions property, you can elect to either preserve a document's direct (non-inherited) access permissions or replace them with the document lifecycle policy's access permissions.

IEventAction Represents the actions taken when a subscribed event fires. You associate an event action with a Subscription-based object by setting the object's EventAction property.

To create an EventAction object and persist it to a Content Engine object store, call the CreateInstance method on the Factory.EventAction class.

You can instantiate an EventAction object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.EventAction class.
  • Get the EventActions property on an ObjectStore, and iterate the EventActionSet collection.
  • Call the get_ReferencingActions method on a CodeModule, and iterate the ActionSet collection for instances of EventAction objects.
  • Get the EventAction property on a Subscription object or subobject.
IInstanceSubscription Represents a subscription for events generated by a single object instance of a particular class.

To create a IInstanceSubscription object, call the CreateInstance method on the Factory.InstanceSubscription class.

You can instantiate a persisted IInstanceSubscription object in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.InstanceSubscription class.
  • By instantiating a ISubscriptionSet collection, then returning a IInstanceSubscription object from the collection.
IInstanceWorkflowSubscription Represents a subscription that initiates a workflow in response to events generated by a single object instance. A InstanceWorkflowSubscription object provides object properties to link a workflow (WorkflowDefinition), a target object, and one or more events (SubscribedEvent) that can be triggered on the target object. These objects must exist before you can create a InstanceWorkflowSubscription object and persist it.

To create a InstanceWorkflowSubscription object, call the CreateInstance method on the Factory.InstanceWorkflowSubscription class.

You can instantiate a persisted InstanceWorkflowSubscription object in the following ways:

ISubscription Represents a request to execute an event action when an event is triggered on a target Content Engine object. For example, you can have a subscription that notifies you by email when documents of a certain class are created and saved in the object store. The specified EventAction and Subscribable objects, which represent the event action and target object, must exist before you can create a Subscription object and persist it.

Subscription is the base class for subclasses defined with specialized behavior. You can create objects for the subclasses, but you cannot create a base Subscription object. You can, however, instantiate one in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.Subscription class.
  • By getting the Subscriptions property on an ObjectStore object or an EventAction object, then iterating the SubscriptionSet collection.
  • By getting the WorkflowSourceSubscriptions property on a WorkflowDefinition object, then iterating the SubscriptionSet collection.
IWorkflowEventAction Represents a definition of the actions taken when a workflow is initiated via an event that is subscribed to by a workflow subscription.

To create a WorkflowEventAction object and persist it to a Content Engine object store, call the CreateInstance method on the Factory.WorkflowEventAction class.

You can instantiate a WorkflowEventAction object in the following ways:

IPublishStyleTemplate Represents the style template that defines how a source document will be transformed. A style template serves as a template for a particular kind of transformation and is tied to a specific publishing event handler on a specific object store. (Note that a publishing event handler can have more than one style template associated with it.)

Information in the style template can be whatever is meaningful to the publishing event handler. For example, the style template might include an XML-based description of the transformation to be done for this style template, an ID of another document that contains a more detailed template, or a URL for publishing to an external location. A style template also specifies a list of input formats (MIME types) supported for the style template, the output format (MIME type) generated when the style template is applied, and, optionally, passwords used by PDF renditions.

A publish style template associated with the HTML publishing event handler does not specify any additional transformation options beyond the basic ones (title, description, input formats, output format, and provider ID). In addition to the basic transformation options (as mentioned above for the HTML publishing event handler), a publish style template associated with the PDF publishing event handler optionally specifies the user and master PDF passwords, as well as other PDF security and watermark settings (stored as XML in the TransformationOptions property).

IPublishTemplate Represents a template for publishing a document. A publish template is an XML document that contains information used to automate the selection of options for a publishing request. For example, it contains the properties and security to apply to the destination document, and instructions for republishing a document, such as whether to version the existing destination document or replace it. Also, a publish template's StyleTemplate property might reference a PublishStyleTemplate object, which describes how the document is to be transformed.

Because IPublishTemplate extends the IDocument interface, you can work with a publish template in the same way you work with a document. For example, you can version a publish template, file it into a folder, and delete it. Publish templates are usually authored in the Publishing Designer application. However, you can override certain publish options when you call the Publish or Republish method. See Publish Options XML for more information.

ISecurityPolicy Represents an independently persistable, subclassable container for a list of security templates. Through an object's SecurityPolicy property, a SecurityPolicy object is associated with a Document, CustomObject, or Folder object, and subclasses of those objects. When you create an object of one of these types, you can optionally assign a SecurityPolicy object to it. If not explicitly assigned, the object's SecurityPolicy property is assigned a value provided by the class's default.

The security policy defines the set of security templates that can be applied to the objects with which the policy is associated. The templates contained within a security policy can be one of two types: versioning or application templates. (For more information on security template types, see SecurityTemplate.)

You can create an instance of a SecurityPolicy object by calling CreateInstance methods on the Factory.SecurityPolicy class. A SecurityPolicy object can be retrieved from the object-valued SecurityPolicy property on a Containable object. (You cannot create a SecurityPolicy instance by retrieving it from the SecurityPolicy property.)

See Also