The following table lists the types derived from IIndependentObject .

Derived Types

Type Description
IAddOn Represents a product extension to the core FileNet P8 Content Engine components. These extensions consist of properties and/or classes to support a specific feature. Add-ons can be non-FileNet products that are compatible with FileNet P8, or they can be FileNet-supplied and provide additional functionality.

You can create an AddOn object by calling CreateInstance on the Factory.AddOn class. Creating an add-on automatically registers it in the FileNet P8 Global Configuration Data (GCD) database. A registered add-on can then be:

  • Installed during new object store creation.
  • Installed on an existing object store.
IAsyncUpgradeQueueItem For internal use only. Represents a pending (queued) execution of an asynchronous upgrade action.
ICenteraFixedContentDevice Represents the description of an EMC Centera fixed content device.
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.
ICMODApplicationGroup Represents an IBM Content Manager OnDemand (CMOD) application group that can be configured for content federation. An application group is a collection of one or more OnDemand applications with common indexing and storage management attributes.
ICMODFixedContentDevice Represents the description of an IBM Content Manager OnDemand (CMOD) external fixed content storage device.
ICmTivoliManagementClass A management class that represents a specific retention setting for an IBM Tivoli Storage Manager (TSM) server. A TivoliFixedContentDevice class can have one or more CmTivoliMangementClass classes associated with it (via its TSMManagementClasses property). Each management class that you create represents a retention scheme type and a retention period that you can associate with a specific TivoliFixedContentDevice class. Note that if data retention protection is turned off (controlled via the TSMArchiveProtectionFlag property of a TivoliFixedContentDevice class), any management classes that specify a chronological retention scheme will be made unavailable by the Content Engine server.

There are two types or retention schemes that a management class can represent: chronological or event. The type of retention scheme used by the management class determines how the retention period is interpreted:

  • In a chronological retention scheme, the retention period is determined by the value of the TSMRetentionPeriod property. After a document is checked in for the first time, the retention period is initiated and a hold is place on the document to prevent deletion in the TSM archive until after the retention period has expired.
  • In an event retention scheme, the retention period is determined by the value of the TSMMinimumRetention property. In this type of retention scheme, you must set the TSMRetentionPeriod property to 0. The retention period is initiated after an object has been deleted from an object store.
ICodeModule Represents a user-implemented Java event handler that executes when an 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 an 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 MimeType property value. 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 file, 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 an ICodeModule object must be of type IContentTransfer, not IContentReference. If you attempt to save an ICodeModule object with an 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 anICodeModule, 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 an ICodeModule object, call the GetInstance or FetchInstance method on the Factory.CodeModule class.

As an alternative to representing a Java event handler as an 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 the IServerCacheConfiguration interface.

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

IContentCacheArea Represents a file storage area that stores duplicates of the document content most frequently requested, and permits those duplicates to be accessed in lieu of the originals in order to enhance the document retrieval performance of local servers. For example, a content cache area can be shared by several servers on a LAN to minimize the number of times they need to access a main storage area on the WAN. For information on configuring a content cache for a server or group of servers, see the IContentCacheConfiguration interface.

Document content consists of the content elements associated with documents (as specified by the ContentElements property on the Document object). The cache receives new content in the following circumstances:

  • Cache miss: When the cache receives a request for a file not currently residing in the cache, the cache receives a duplicate of that file as part of the document retrieval process.
  • Content preloading: When content preloading has been enabled (via the PreloadOnCreate property), the cache receives duplicates of any new content added to the main storage area.

In both circumstances, new content can be added to the cache only when its storage capacity (as defined by the MaximumContentElements and MaximumSizeKBytes properties) exceeds the current amount of content (as indicated by the ContentElementCount and ContentElementKBytes properties). Cache content, however, can end up slightly exceeding the designated storage capacity, as statistics are managed on a delayed basis, and multiple servers can be adding content.

Cache pruning is the process of deleting the content least frequently requested from the cache. Pruning deletes three main categories of files: abandoned, expired, and old. An abandoned file is an incomplete file that has been not properly added to the cache as a result of a server failure of some sort (such as a power failure). An expired file is a file that has remained in an unaccessed state longer than the maximum-time-to-live (as specified by the MaximumTimeToLive property). An old file is a file that, compared to other files in the same directory, has been accessed less recently. Note that these categories are not mutually exclusive; an abandoned file might also be an expired file, and an expired file an old file.

Pruning considers the most recent access time for a file equivalent to its time-of-last-use. This time gets updated to the current time when the file first gets added to the cache, and also whenever the file gets retrieved, provided more than 10 minutes have elapsed since the previous time-of-last-use update. Consequently, the accuracy of the time-of-last-use for a file is within 10 minutes.

Prune actions--specific instances of pruning--operate on the cache directory by directory. For a general discussion on the advantages of this approach, see the DirectoryStructure property. For a detailed discussion on prune action behavior, see the PruneAmount property.

Prune actions get triggered in three different ways:

  • Mandatory Prune: Ensures that cache content remains under prune threshold levels. For more information, see the PruneThresholdContentElements property.
  • Periodic Prune: Ensures that expired files get deleted on a timely basis. For more information, see the MaximumTimeToLive property.
  • Sweeping: Ensures that the statistics concerning content element count (the ContentElementCount property) and content element size (the ContentElementKBytes property) remain reasonably accurate. A prune action occurs as part of this statistical update. For more information on the sweep action, see the ContentElementCount property.

Cache sweeping does not update the count of content element creations (the ContentElementsCreated property) or the count of content element deletions (the ContentElementsDeleted property). These statistics can become inaccurate over time, but can be optionally reset by clearing the cache. For more information on cache clearing, see the CacheStatus property.

IDatabaseStorageArea Represents a storage area for content elements stored in the database.
IDITARenditionEngineConnection Represents site-specific connection data for a DITA Rendition Engine that is referenced by a publishing configuration. (A DITA Rendition Engine is one that uses a DITA Open Toolkit deployment for publishing documents.)
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.
IDocumentClassificationQueueItem Represents a pending (queued) document auto-classification request. The QueuedObject property specifies the document that is the subject of the queued request.
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.

IEventQueueItem Represents a pending (queued) execution of an asynchronous event action, or an asynchronous event queue item that remains unprocessed because its retry count is zero. The IEventQueueItem interface includes properties for setting and retrieving the source object and event of the pending event action.

To instantiate a IEventQueueItem object, call the getInstance or fetchInstance method on the Factory.EventQueueItem class.

IFileStorageArea Represents a storage area for content elements stored in the file system.
IFixedContentDevice Represents the base, abstract class for all classes relating to fixed content devices. A fixed content device has the following characteristics:
  • Content stored on the device may be accessed via a proprietary API, instead of the file system API.
  • The repository can be write-once, not allowing content to be changed.
  • The repository can be write-once, not allowing content to be changed or deleted.
  • The repository can support a retention period for content. The content cannot be deleted until that period has expired.
  • Read/write access to the repository may be significantly slower than access to a traditional file system.
  • The fixed content device may limit the number of concurrent connections.
IFixedStorageArea Represents a storage area for content elements stored in a fixed content device.
IGenericFixedContentDevice Represents the description of a generic fixed content device. The GenericFixedContentDevice object provides an extensible mechanism for implementing interfaces to fixed content devices not currently supported by FileNet. The ConfigurationParameters property provides the set of parameters that will be passed to a custom implementation of a fixed content provider used to connect to the fixed content device. Note that there is no fixed format for the ConfigurationParameters property (other than, it must be a string that the custom implementation of the fixed content provider can understand and parse). This object is for future use only and is not currently supported by FileNet.
IIICEFixedContentDevice Represents an external fixed content device accessible via an instance of IBM Content Integrator (formerly known as Information Integrator Content Edition or IICE). This representation serves a two-fold purpose: to identify and describe the external device, and to configure the behavior of the Content Federation Service (CFS) with respect to that device. CFS uses metadata from the external device to create and update FileNet P8 federated documents. (For information on content federation, and on the CFS import process in particular, see the ICFSImportAgentConfiguration interface.)

As a content device description, this interface ties together these main entities:

  • Federator database - This database acts as a transmission medium between the CFS exporter that pulls metadata from the external device and the CFS importer that creates and updates FileNet P8 documents using the metadata. To specify the database instance to use, set these properties: FederationJNDIDataSource and FederationJNDIXADataSource.
  • External device/repository - The external device can be a Content Services repository or any other type of repository supported by CFS. To specify the external repository to use and to allow CFS to access it, set these properties: SourceRepositoryName, CFSUserName, and CFSPassword properties.

As a means for configuring the behavior of CFS with respect to the external device, this interface can affect FileNet P8 document updates. CFS periodically pulls metadata and content from the external repository to keep FileNet P8 documents in sync with any changes made to the corresponding external documents. To control how CFS performs these periodic updates, set the FederationUpdateHasPriority property.

IIMFixedContentDevice Represents the description of a FileNet Image Services fixed content device.
IIndexArea Represents the disk storage location and data necessary to perform full-text indexing for content-based retrieval.

A single index area holds data for only one object store, using one file system directory. Spreading the indexing information across multiple file systems requires the use of multiple index areas.

The ResourceStatus property is set to "full" by the server when the number of collections is equal to VerityIndexArea.MaxCollections (no more VerityCollections can be created in this IndexArea). A replacement IndexArea (having a status of "standby" will be set to "open". If the status of an IndexArea is not "open", no new Verity collections will be created in the IndexArea. However, Verity collections in the IndexArea will be searched during queries, regardless of status.

IIndexJob Initiates and tracks the status of a full text indexing operation. IndexJob is used to rebuild the full text index in the event that it becomes corrupted, or a configuration change requires that the full text index be rebuilt. The following types of indexing scenarios are supported:

All currently indexed data is available while indexing is in progress, but some queries will get duplicate matches from full text searches, due to matches in both the old and the new index data. When the IndexJob operation completes, old copies of the data are removed (duplicate matches will no longer occur).

Most index jobs require sweeping the database looking for collections or classes to be indexed. This sweep requires a table scan on the database (taking a considerable length of time on a large table), even if the amount of data to be indexed is minimal. The database table scans are performed once for all classes to be indexed in a table, and once for all collections to be indexed in a table. To minimize the number of table scans required, we recommend you put all classes or collections to be indexed for the same table into a single IndexJob operation.

IIsolatedRegion Contains the connection information necessary to access the Process Engine isolated region. This information is persisted in the GCD (Global Configuration Data).

An isolated region represents a logical subdivision of the Process Engine database. Each isolated region is referenced by one or more Process Engine connection points (PEConnectionPoint instances). The set of isolated regions defined is reflected in the Domain.IsolatedRegions property.

PEConnectionPointDomain
IPEConnectionPoint Routes Process Engine requests to an isolated region (IsolatedRegion instance). This information is persisted in the GCD (Global Configuration Data). Multiple PEConnectionPoint instances can reference the same isolated region. The PEConnectionPoint allows individual applications to use an arbitrary, application-specific name to refer to an isolated region. The set of connection points defined is reflected in the Domain.PEConnectionPoints property. IsolatedRegionDomain
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.
IQueueItem Is the base class for all queue-related classes. Queue-related classes represent a pending (queued) execution of an asynchronous action on a target object. For example, a document may have a pending document classification action.

You cannot create a new instance of IQueueItem, but you can call GetInstance or FetchInstance on Factory.QueueItem to retrieve an instance of this subclassable class.

IRenditionEngineConnection Represents site-specific connection data for a Rendition Engine that is referenced by a publishing configuration.
IReplicableClassDefinition Represents the class definition (mutable class metadata) of classes of which an object instance can be replicated.
ISecurityPropagationQueueItem Represents a pending (queued) execution of an asynchronous security propagation action on a target object. Security propagation means the security assigned to a parent object will be inherited by its child objects.

You cannot create a new instance of ISecurityPropagationQueueItem, but you can retrieve a persisted object by calling FetchInstance or GetInstance on Factory.SecurityPropagationQueueItem.

IServerInstance Represents a single instance of a Java Virtual Machine (JVM) running in an application server. One or more logically connected server instances working together constitute a virtual server. One or more virtual servers make up a site within a FileNet P8 domain.

ServerInstance objects are created dynamically during system initialization and startup based on the configured topology of the application server or via specific system properties. They cannot be created via the API. You can retrieve a persisted ServerInstance object by calling GetInstance or FetchInstance on the Factory.ServerInstance class.

ISite Identifies a geographical area within a FileNet P8 domain. A domain can have one or more configured sites. Each site is identified by a unique name and has associated servers and resources (such as object stores, index areas, storage areas, and content caches). Associated resource objects in the same geographical area have the same Site property.

When a Content Engine server in a geographically distributed environment processes a user request, it determines what resources it will need to process the request, and makes use of the site information in these resources to determine how best to process the request. The site information will determine whether or not content retrievals and uploads are processed through a content cache, and whether or not the request will be forwarded to a server in another site, closer to the resources required to process the request.

When the Content Engine server is initialized and the GCD created, a factory-generated instance of the Site class, called "Initial Site," is created and referenced by the Domain.DefaultSite property. As Virtual Servers, Server Instances, and resources (object stores, storage areas, etc.) are added to the domain, they are assigned to the DefaultSite, unless a different site is explicitly specified. A user with system administrator privileges can change the Domain.DefaultSite to a different default site, if desired.

For more information about request forwarding, see "Request Forwarding Concepts" in the Content Engine Administration documentation.

To create a new instance of this class, call Factory.Site.CreateInstance.

ISnapLockFixedContentDevice Represents the description of a NetApp SnapLock fixed content device.
IStorageArea Represents the physical storage location where content will be stored. This base, abstract class has three concrete subclasses: DatabaseStorageArea, FileStorageArea, and FixedStorageArea. A FixedStorageArea object is associated with a FixedContentDevice object when it is created.

The concrete classes are customizable. This means that you can add custom properties to them (and to the base class) and create custom subclasses. By customizing the concrete classes, you can add custom criteria for selecting storage areas via a StoragePolicy.

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.
ITableDefinition Represents the description of a Content Engine database table. All the tables used by the Content Engine database have corresponding TableDefinition objects that are accessible using the TableDefinitions property of an ObjectStore object.

You can also access a TableDefinition object as follows:

  • Through the TableDefinition property of a ClassDefinition, DocumentClassDefinition, SubscribableClassDefinition, or VersionableClassDefinition object. This type of TableDefinition object maps to a database table that contains information about a specific class.
  • Through the TableDefinition property of a property definition object (such as, PropertyDefinitionBinary or PropertyDefinitionBoolean). This type of TableDefinition object maps to a Content Engine database table that contains information about a specific queryable property.
ITivoliFixedContentDevice Represents the description of an IBM Tivoli Storage Manager (TSM) fixed content device. Although TSM supports a variety of storage devices, the TivoliFixedContentDevice class currently supports only IBM System Storage DR550. IBM System Storage DR550 provides automated data protection and allows you to comply with data retention requirements.
IUpgradeAddOn Specifies how to upgrade a set of existing add-ons to a new set of add-ons. An UpgradeAddOn object has the following characteristics:
  • It has import data, a pre-import script, and a post-import script, and is installed using the same API method (ObjectStore.InstallAddOn) as a normal add-on.
  • It identifies the old add-on version(s) (FromVersions property) and the new add-on version(s) (ToVersions property).
  • When an add-on has been successfully upgraded, the older version's AddOnInstallationRecord object is replaced with an installation record for the newer version.
  • It can upgrade one or more add-ons of older versions to one or more add-ons of newer versions via a single UpgradeAddOn object. For example, when an UpgradeAddOn object with a FromVersions value of [A1, A2, A3] and a ToVersions value of [A4, A5] is installed on an object store, the AddOnInstallationRecord objects for A1, A2, and A3 are removed and replaced with AddOnInstallationRecord objects for A4 and A5.
IVerityDomainConfiguration Contains the Verity configuration properties that are common to all servers in a domain. Only one VerityDomainConfiguration object can exist per domain (attempts to create multiple instances of a VerityDomainConfiguration object will throw an exception). The Factory.VerityDomainConfiguration.FetchInstance method does not require an Id to fetch the VerityDomainConfiguration object.

The only two properties that must be set in VerityDomainConfiguration for full text indexing to be operational are the VerityAdminMasterServerPort and VerityAdminMasterServerHostname properties. The UserName, UserPassword, UserDomain, and UserGroup properties must all be set if security is to be enabled.

Note: The VerityServerConfiguration object contains Verity configuration properties that can be different for each server in the domain.

IVerityIndexArea Contains information about an index area that is specific to the Verity content-based retrieval engine. The ObjectStore.CBRLocale property must be set before creating an instance of this class.

The RootDirectoryPath property identifies the directory used to store full text indexing information.

IVersionableClassDefinition Represents the parent of the DocumentClassDefinition class, which holds the class definition of a Document class and its subclasses.
IVirtualServer Represents a logical entity for managing a group of server instances. Multiple server instances can run simultaneously on a single physical machine, or can be deployed on separate machines. A virtual server is composed of multiple server instances logically operating together to provide a service or services. Clients of the Content Engine interact with a VirtualServer, rather than interacting with a specific ServerInstance. If a VirtualServer consists of a single ServerInstance, then the two are functionally equivalent. If a VirtualServer consists of multiple server instances, then client requests are distributed between each individual ServerInstance, providing scalability and high availability. Clients are not aware of which ServerInstance actually fulfilled their request.

When multiple server instances are configured to run as a VirtualServer, a third-party (non-FileNet) load balancing mechanism must exist to distribute incoming requests to the server instances. This may be a Java 2 Platform Enterprise Edition (J2EE) application server's clustering implementation, or it could be an external hardware or software load balancing product. In either case, an administrator, using the third-party's load balancing configuration tools, is responsible for configuring the load balancing for a VirtualServer.

VirtualServer objects are created dynamically during system initialization and startup based on the configured topology of the application server or via specific system properties. They cannot be created via the API. You can retrieve a persisted VirtualServer object by calling GetInstance or FetchInstance on the Factory.VirtualServer class.

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.
IDomain Represents a collection of resources and services sharing the same Global Configuration Database (GCD). The GCD defines a common set of attributes that control functional characteristics of the collection of resources and services for this domain. The GCD defines domain resources, such as sites (and their related virtual servers and server instances), object store databases, full-text index areas, file storage areas, content cache areas, add-ons, marking sets, and so on. The FileNet P8 domain is also associated with one or more security realms for authenticating users.

Although you can programmatically create a domain, it is not typical to do so. (For a code sample, see "Getting Started Procedures" in the IBM FileNet P8 Content Engine .NET and Java API Developer’s Guide.) In a more typical scenario, you can retrieve a persisted Domain object by calling the GetInstance or FetchInstance method on the Factory.Domain class. You can also retrieve the Domain property of an ObjectStore object.

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.
IEntireNetwork Represents the highest-level object in the Content Engine API object model. Creating an instance of this object exposes all other public members of the object hierarchy. For example, from EntireNetwork, you can instantiate a Domain object. From a domain, you can navigate to an object store, then begin accessing documents, folders, etc. You can also use the EntireNetwork to retrieve all of the Realm objects for the FileNet P8 domain, then retrieve the users and groups associated with a realm.

You can create a new EntireNetwork object by calling the GetInstance or FetchInstance method on the Factory.EntireNetwork class.

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
IIndependentlyPersistableObject Represents a persistable IndependentObject that you can directly create, update, and delete.
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.

IObjectStore Represents a location in which folders, documents, and custom objects are stored, accessed, and managed on the Content Engine server.

An IObjectStore object provides access to metadata and Content Engine objects, such as class descriptions, property descriptions, security policies, and so on. Using methods on this interface, you can retrieve this information, create and store new objects in the object store, and retrieve its installed feature add-ons.

You can get a reference to an IObjectStore by iterating an IObjectStoreSet collection. You can get an instance of IObjectStore by:

  • Calling CreateInstance, GetInstance, or FetchInstance on the Factory.ObjectStore class.
  • Calling GetObjectStore on an instance of an IRepositoryObject subclass.
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.
IVersionSeries Represents the complete set of versions for a versionable object, or document (that is, an object instantiated from a subinterface of the IVersionable interface). Because a VersionSeries object is constructed by the server from versionable objects and does not have its state stored in a database, it is read-only, and thus you cannot modify any of its properties. In addition, a VersionSeries object has no security attached to it; it is secured by the current document version associated with it. You can access a specific document version by navigating through the collection returned by the Versions property. Use extreme caution when deleting a VersionSeries object; if you delete it, all of its associated document versions will also be deleted.
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.

IAuditConfigurationEvent Represents an event that occurs when the auditing configuration of an object store is changed. Auditing is either enabled or disabled by setting the AuditLevel property on IObjectStore, and the IAuditConfigurationEvent object is saved.

You can instantiate a IAuditConfigurationEvent object in the following ways:

ICancelCheckoutEvent Represents an event that occurs when a reservation on a versionable object is canceled.

You can instantiate a ICancelCheckoutEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.CancelCheckoutEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of ICancelCheckoutEvent objects.
  • Retrieve a ICancelCheckoutEvent object from a ICancelCheckoutEventSet collection.
IChangeClassEvent Represents an event that occurs when the class of an object is changed.

You can instantiate a IChangeClassEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.ChangeClassEvent class.
  • Retrieve the AuditedEvents property on a IDocument, IFolder, or ICustomObject object, and iterate the IEventSet collection for instances of IChangeClassEvent objects.
  • Retrieve a IChangeClassEvent object from a IChangeClassEventSet collection.
IChangeStateEvent Represents an event that occurs when the lifecycle state of a Document object changes.

You can instantiate a IChangeStateEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.ChangeStateEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of IChangeStateEvent objects.
  • Retrieve a IChangeStateEvent object from a IChangeStateEventSet collection.
ICheckinEvent Represents an event that occurs when a versionable object is checked in.

You can instantiate a ICheckinEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.CheckinEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of ICheckinEvent objects.
  • Retrieve a ICheckinEvent object from a ICheckinEventSet collection.
ICheckoutEvent Represents an event that occurs when a versionable object is checked out.

You can instantiate a ICheckoutEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.CheckoutEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of ICheckoutEvent objects.
  • Retrieve a ICheckoutEvent object from a ICheckoutEventSet collection.
IClassifyCompleteEvent Represents an event that occurs when a document has been auto-classified, that is, assigned a document class automatically during checkin.

You can instantiate a IClassifyCompleteEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.ClassifyCompleteEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of IClassifyCompleteEvent objects.
  • Retrieve a IClassifyCompleteEvent object from a IClassifyCompleteEventSet collection.
Concepts: automatic document classifications
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.
ICreationEvent Represents an event that occurs when an object instance of a class is created and saved.

You can instantiate a ICreationEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.CreationEvent class.
  • Retrieve the AuditedEvents property on a IDocument, IFolder, or ICustomObject object, and iterate the IEventSet collection for instances of ICreationEvent objects.
  • Retrieve a ICreationEvent object from a ICreationEventSet collection.
ICustomEvent Represents a user-defined custom event. A custom event is raised whenever an object to which it is subscribed calls its RaiseEvent method.

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

You can instantiate a CustomEvent object in the following ways:

  • By calling the GetInstance or FetchInstance method on the Factory.CustomEvent class.
  • By retrieving the AuditedEvents property on the source object of the custom event, and iterating the EventSet collection for instances of CustomEvent objects.
  • By retrieving a CustomEvent object from a CustomEventSet collection.
IDeletionEvent Represents an event that occurs when an object is deleted from the object store.

You can instantiate a IDeletionEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.DeletionEvent class.
  • Retrieve the AuditedEvents property on a IDocument, IFolder, or ICustomObject object, and iterate the IEventSet collection for instances of IDeletionEvent objects.
  • Retrieve a IDeletionEvent object from a IDeletionEventSet collection.
IDemoteVersionEvent Represents an event that occurs when a versionable object is demoted to a minor version.

You can instantiate a IDemoteVersionEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.DemoteVersionEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of IDemoteVersionEvent objects.
  • Retrieve a IDemoteVersionEvent object from a IDemoteVersionEventSet 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.

IEvent Represents a system or custom event that can be triggered on an Content Engine object or class of objects. This is the base event interface from which several subinterfaces derive, used primarily for auditing and subscriptions. You can audit all event types, and you can subscribe to all events with the exception of those that derive from the RetrievalEvent interface.

Through an event object, you can retrieve information about the object on which the event was fired, such as its permissions and the date the object was last modified. You can set some properties as well, if you have been granted privileged write access.

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.
IFileEvent Represents an event that occurs when a folder has its File method called to file a Containable object, for example, a Document or CustomObject, or when the File method is called to create a subfolder.

You can instantiate a FileEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.FileEvent class.
  • Retrieve the AuditedEvents property on a Folder object, and iterate the EventSet collection for instances of FileEvent objects.
  • Retrieve a FileEvent object from a FileEventSet collection.
IFreezeEvent Represents an event that occurs when the Freeze method of a Versionable object is successfully called.

You can instantiate a IFreezeEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.FreezeEvent class.
  • Retrieve the AuditedEvents property on a IDocument object, and iterate the IEventSet collection for instances of IFreezeEvent objects.
  • Retrieve a IFreezeEvent object from a IFreezeEventSet collection.
IGetContentEvent Represents an event that occurs when the content of a content-carrying object is retrieved. This event can only be audited; you cannot subscribe to it.

You can instantiate a GetContentEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.GetContentEvent class.
  • Retrieve the AuditedEvents property on a Document object, and iterate the EventSet collection for instances of GetContentEvent objects.
  • Retrieve a GetContentEvent object from a GetContentEventSet collection.
IGetObjectEvent Represents an event that occurs when an object is retrieved from the object store. This event can only be audited; you cannot subscribe to it.

You can instantiate a GetObjectEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.GetObjectEvent class.
  • Retrieve the AuditedEvents property on a RepositoryObject subclass, and iterate the EventSet collection for instances of GetObjectEvent objects.
  • Retrieve a GetObjectEvent object from a GetObjectEventSet collection.
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:

ILockEvent Represents an event that occurs when the Lock method is called to lock or update an existing lock on a Document, CustomObject, or Folder object.

You can instantiate a LockEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.LockEvent class.
  • Retrieve the AuditedEvents property on a Document, Folder, or CustomObject object, and iterate the EventSet collection for instances of LockEvent objects.
  • Retrieve a LockEvent object from a LockEventSet collection.
IObjectChangeEvent Represents an event that occurs when the state of an object is changed. This interface is the base for several event interfaces.

You can instantiate a IObjectChangeEvent object in the following ways:

IPromoteVersionEvent Represents an event that occurs when a document is promoted or checked in as a major version.

You can instantiate a PromoteVersionEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the PromoteVersionEvent class.
  • Retrieve the AuditedEvents property on a Document object, and iterate the EventSet collection for instances of PromoteVersionEvent objects.
  • Retrieve a PromoteVersionEvent object from a PromoteVersionEventSet collection.
IPublishCompleteEvent Represents an event that occurs when a document-publishing request has completed.

You can instantiate a PublishCompleteEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.PublishCompleteEvent class.
  • Retrieve the AuditedEvents property on a Document object, and iterate the EventSet collection for instances of PublishCompleteEvent objects.
  • Retrieve a PublishCompleteEvent object from a PublishCompleteEventSet collection.
IPublishRequestEvent interface.
IPublishRequestEvent Represents an event that occurs when a request has been made to publish or republish a document. A publish request is represented by a PublishRequest object.

You can instantiate a PublishRequestEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.PublishRequestEvent class.
  • Retrieve the AuditedEvents property on a Document object, and iterate the EventSet collection for instances of PublishRequestEvent objects.
  • Retrieve a PublishRequestEvent object from a PublishRequestEventSet collection.
IQueryEvent Repesents an event that occurs whenever a database query is performed. This event can only be audited; you cannot subscribe to it.

You can instantiate a QueryEvent object in the following ways:

IRetrievalEvent Represents an event that occurs when a Content Engine object or its content is retrieved or queried. This interface is the base for other event interfaces. These events cannot be subscribed to; they can only be audited.

You can instantiate a RetrievalEvent 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.
ITakeFederatedOwnershipEvent Event reported when the TakeFederatedOwnership method is applied to a Document object.

You can instantiate a TakeFederatedOwnershipEvent object in the following ways:

IUnfileEvent Represents an event that occurs when a folder has its Unfile method called to remove (unfile) a Containable object, for example, a Document or CustomObject, or when the Unfile method is called to delete a subfolder.

You can instantiate an UnfileEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.UnfileEvent class.
  • Retrieve the AuditedEvents property on a Folder object, and iterate the EventSet collection for instances of UnfileEvent objects.
  • Retrieve an UnfileEvent object from an UnfileEventSet collection.
IUnlockEvent Represents an event that occurs when the Unlock method is called on a Document, CustomObject, or Folder object.

You can instantiate a UnlockEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.UnlockEvent class.
  • Retrieve the AuditedEvents property on a Document, Folder, or CustomObject object, and iterate the EventSet collection for instances of UnlockEvent objects.
  • Retrieve a UnlockEvent object from a UnlockEventSet collection.
IUpdateEvent Represents an event that occurs when changes are made to an object's properties.

You can instantiate a UpdateEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.UpdateEvent class.
  • Retrieve the AuditedEvents property on a Document, Folder, or CustomObject object, and iterate the EventSet collection for instances of UpdateEvent objects.
  • Retrieve an UpdateEvent object from an UpdateEventSet collection.
IUpdateSecurityEvent Represents an event that occurs when the security of an object is changed.

Note that the dynamic inheritance feature of the Content Engine security model impacts UpdateSecurityEvent as follows. First, modifying the security of a folder will not automatically propogate to the documents contained in the folder; that is, the security of the documents in the folder will not change. Therefore, the system will generate an UpdateSecurityEvent object for the folder, but it will not generate an UpdateSecurityEvent object for each contained document. Second, an update to any object-valued property designated as inheritable in the metadata will generate an UpdateSecurityEvent object .

You can instantiate a UpdateSecurityEvent object in the following ways:

  • Call the GetInstance or FetchInstance method on the Factory.UpdateSecurityEvent class.
  • Retrieve the AuditedEvents property on a Document, Folder, or CustomObject object, and iterate the EventSet collection for instances of UpdateSecurityEvent objects.
  • Retrieve a UpdateSecurityEvent object from a UpdateSecurityEventSet 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:

IClassDescription Represents the fixed description (immutable metadata) of a class. A ClassDescription object maintains a fixed snapshot, via its properties and property descriptions, of an instantiated object's property metadata throughout the object's lifetime. Because all of its properties are read-only, you cannot directly modify a ClassDescription object. If you need to update the metadata of a class, use its ClassDefinition object.
IPublishRequest Represents a queued request to publish a document using a specified PublishTemplate object. All publish requests are processed asynchronously, including copy operations, which do not transform the document. Once a PublishRequest object is saved, it is always enqueued.

A publish request can be for a publish or republish operation, as determined by the PublishTemplate and PublicationDocument properties. If the PublishTemplate property is set and the PublicationDocument property is null, the request is for a publish operation. Otherwise, if the PublicationDocument property is set, the publish request is for a republish operation.

A PublishRequest object can be created by calling the Publish or Republish methods on a Document object. Alternatively, a PublishRequest can be created by calling Factory.IPublishRequest.CreateInstance and filling in the desired properties prior to saving. In either case, when the object is saved, it goes into the publish request queue, where it will be processed asynchronously by a publishing event handler.

Once a PublishRequest object has been successfully processed, it is deleted from the server.

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.

ICMODRepository Represents an IBM Content Manager OnDemand (CMOD) external repository that is capable of federating content.
IContentFederatingRepository Represents repositories that are external to the Content Engine server and are capable of federating content. This interface is the base for subinterfaces representing specific external repository types that are capable of federating content.
IExternalClassDescription Represents the description of a class in an external repository of which an object instance can be replicated.
IExternalRepository Represents repositories that are external to the Content Engine server. This interface is the base for subinterfaces representing external repositories.
IImageServicesRepository Represents an IBM FileNet Image Services external repository that is capable of federating content.
IReplicationGroup This interface is not supported.
IReplicationJournalEntry Represents the journal record of an operation on a replicated object for outbound replication.
IRepository This interface is the base for subinterfaces representing object stores and external repositories.
IGroup Represents a group of user accounts defined by the directory service on the Content Engine server.

Access rights and permissions are assigned to a grantee, which can be a user or a group. Access rights can be assigned to a group regardless of whether the group has any members. Users can be added to the group later. When a user is added to a group, the user automatically gains the access rights assigned to the group to which it belongs. A group can also have subgroups.

Security on objects, such as folders and documents, can pertain to particular groups. These groups, and the users and subgroups that make up the group's membership, are defined and created using tools provided by your directory service product (for example, Windows Active Directory, Novell eDirectory, or Sun Java System Directory Server). Creating user accounts and the groups to which they belong are administrative tasks (typically performed by a system administrator) that are outside the scope of the Content Engine API.

You cannot create a new Group object, but you can instantiate one that has been persisted in your directory service by:

  • Calling GetInstance or FetchInstance on the Factory.Group class.
  • Retrieving an individual Group object from a GroupSet collection object.

You can call methods on the Group object to retrieve information about the group, such as its name and ID, or to get references to other objects. References to other objects may include the users who are members of the group and the subgroups or parent groups of the group.

IMarkingSet Represents a container for the set of markings for a given object property.

The MarkingSet collection contains Marking objects. Each Marking object represents a possible value that can be applied to an object property. Each marking value contains a set of access permissions that define who can assign that specific value to an object property, who can modify or remove that specific value, and, once it is assigned, who will have access to the object it is assigned to.

The marking set is assigned to a property definition on a class such that the value of that property on instances of the class must be one of the markings defined by the marking set. Values can only be assigned by users authorized by the associated marking, and, after the marking is applied, access to the object is restricted based on the marking.

You can create a new MarkingSet collection by calling Factory.MarkingSet.CreateInstance, or retrieve an existing instance by calling GetInstance or FetchInstance.

IRealm Consists of a set of related groups and users. A realm is normally mapped to a directory partition (that is, a namingContext) in a directory server. The primary use of a Realm object is to retrieve lists of the groups and users in the realm.

You can instantiate a Realm object by:

  • Calling methods on the Factory.Realm class. (See the note below.)
  • Calling IEntireNetwork.Get_MyRealm(), which returns a Realm object representing the realm in which the caller resides.
  • Enumerating a RealmSet collection.
Note
When instantiating via the static factory methods, calling GetInstance with a Null realm name returns the current realm; the behavior is the same as calling Factory.Realm.FetchCurrent().
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.)

ISecurityPrincipal Provides the base class for security principals (Group and User objects).
IUser Represents a particular user who has access to Content Engine resources.

Access rights and permissions are assigned to a grantee, which can be a user or a group. A user's access to resources can be defined in terms of its membership in a group, but need not be. Permission objects have an associated User or Group object. Group and Realm objects have associated User objects, and can also have associated Group objects.

User accounts and the groups and subgroups to which they belong are defined and created using tools provided by your directory service product (for example, Windows Active Directory, Novell eDirectory, or Sun Java System Directory Server). Creating and modifying user accounts and groups are administrative tasks (typically performed by a system administrator) that are outside the scope of the Content Engine API.

You cannot create a new User object, but you can instantiate one that has been persisted in your directory service by:

  • Calling Factory.User.FetchCurrent, which returns the current user.
  • Calling GetInstance or FetchInstance on the Factory.User class.
  • Retrieving an individual User object from a UserSet collection object.

You can call methods on the User object to retrieve information about the user, such as the user's name and ID and to which groups the user belongs.

See Also