TIBCO Adapter SDK C++ Reference
|
Class | Description |
MAbstractDateTime | This class serves as a superclass for MDateTime. Applications never create instances of this class, it only exists to encapsulate the shared methods of its subclass. |
MAdapterServiceInfo |
This class allows adapter writers to specify a list of services. A service is composite of an endpoint and one or more schema class(es). This class is principally used when the adapter is used with TIBCO BusinessWorks and TIBCO Administrator.
|
MAdvisory | Manage creation and destruction of advisory subscriptions. It also handles and publishes SDK and user-defined advisories. |
MAdvisoryDocument |
Allow applications to provide structured error reporting, that is, two applications can share the same error reporting format using these classes as a specification. Remarks When an application sends a message to another, it could send pure data. In many cases, however, it is useful to include context for the data, which allows the receiving and sending application to share information that is not necessarily part of the data. Typically, the application itself defines the context, however, that means that each sending and receiving application have to agree on the format for the context. The MAdvisoryDocument class encapsulates context information so that applications can predefine what context is expected, then share that context. This class is most useful for debugging and performance analysis. This class allows applications to include information about the structure and other aspects of the data that is sent. |
MAdvisoryListener | This is the SDK’s default advisory listener. You can also subclass and create a custom listener. |
MAmxEndpointSpec | |
MApp |
The purpose of this class is to:
|
MAppProperties |
Encapsulates properties associated with an MApp application manager. Before creating the MApp application manager, applications create an instance of MAppProperties and set the application name, version, banner information, and adapter instance description object. Applications can then call the constructor for MApp using the specified MAppProperties instance. |
MAssociationDescription |
The MAssociationDescription interface describes a particular association between two classes, called class A and class B. Because an association is between two classes, there is not a specific sense of a “to Class” and a “from Class.” The API is organized around two half-specifications called association endpoint descriptions (see MAssociationEndpointDescription). This class is only instantiated by the adapter class library itself. |
MAssociationEndpointDescription | Each instance of the MAssociationEndpointDescription class describes one endpoint of an association. The instance holds the information about the endpoint, such as the role name, multiplicity, and navigability information. |
MAssocList |
An MAssocList object can be used in a similar fashion to a map or a hash table. It holds key-value pairs. Values can be either MData objects such as MInstance, MSequence, MAssocList or a basic type such as MInteger or MStringData. An MAssocList consists of ordered key/value (attribute/value) pairs; the same key may be repeated multiple time. You can form nested trees by making an MAssocList the value of an MAssocList attribute. The interface supports accessing key-value pairs either by key and key index or by global position inside the association list. MAssocList behaves in a similar fashion to an MTree, but the major difference between these two classes is that MAssocList is part of the MData class hierarchy and therefore can also be used in conjunction with other metadata driven objects. For example, an MAssocList object may be used as an attribute of an MInstance or as a member of a MSequence. One usage of MAssocList is when highly dynamic data structure needs to be shipped and no class description can be available or only partial class description is available. |
MAttributeDescription | Encapsulates a particular attribute or property of an MClassDescription. |
MBaseClassDescription |
MBaseClassDescription encapsulates the attributes and structure of a class that is stored in the class registry or used by the metadata component of the SDK in some other way. This class is an abstract class with the following subclasses defined by the SDK.
|
MBinary | Class for encapsulating binary data. |
MBool | Class for encapsulating boolean data. |
MBusinessDocument | Allow applications to describe a business event using a standard format. |
MChar | Class for encapsulating data of type char. |
MClassRegistry | An MClassRegistry is a repository of class descriptions that serves as the entry-point to the classes created using the metadata information. Custom adapters can use the registry to retrieve the class descriptions. |
MComponent | Components allow applications to create named instances associated with their MApp application manager. Applications create a subclass of MComponent and add some desired behavior to that class. All component instances (or instances of subclasses) have a name and a method that accesses that name. |
MComponentEnumerator |
This class allows you to iterate through the components of a specific component type. Component types can be any subclass of MComponent. It can be MPublisher, MSubscriber, Msink, and so on. Components are iterated by calling the next() method. |
MComponentRegistry | MComponentRegistry is a repository where the SDK stores all MComponent objects. |
MConfigurationUtilities | Allow specialized applications direct control over the creation of components and metadata from configuration information. |
MData | Base class for classes that are used to encapsulate attribute types used for SDK metadata management. |
MDataEvent | Encapsulate a data event. |
MDataFactory | Class that encapsulates functionality for creating instances of MInstance, MUnion, MSequence, or any MData instances from an already existing MTree. |
MDate | Class for encapsulating date information. |
MDateTime | Class for encapsulating date and time or interval data. |
MDispatcher |
This class allows applications to create a platform independent event dispatcher for a specified MApp instance and session. Programs can dispatch events explicitly by calling nextEvent() for a session or an MApp instance. They can also allow the SDK event handler to dispatch all events. This class allows for a third alternative: applications can create a dispatcher for a specified MApp and MSession and stop the dispatcher as needed. This is particularly useful for multithreading applications. See "Multithreaded Adapters" in TIBCO Adapter SDK Programmer's Guide. |
MEndpointSpec | This class encapsulates the specification of an endpoint (for example, subscriber, publisher). |
MEnumerator |
This class allows you to iterate through the elements of an object for which it was created. You specify the key and value. Applications should not call the constructor for this class. Instead, they should call the appropriate newEnumerator() method. |
MEvent | Base event class. |
MEventListener |
Event listeners are callback classes that register interest in an event and are notified when the event occurs. MEventListener is an abstract class. Applications create subclasses for different types of event sources; typically one subclass for each type of event. Applications can then specify the onEvent() methods in each subclass, and associate the listener with an event source by calling the MEventSource::addListener() method. |
MEventSource |
The SDK event model uses three classes:
|
MException | The TIBCO Adapter SDK does not use an exception hierarchy. Instead, information on the type of exception is in the fields of MException. |
MExceptionEvent |
A special MEvent subclass that is dispatched during exception conditions when an exception cannot be thrown. Currently, the SDK dispatches this event when it receives messages that do not conform to the message format the event source is expecting. |
MFileSink | An MFileSink is a file with an associated filename, sink name, and role that can receive messages from a trace. |
MFixed | Class for encapsulating data of type fixed. |
MGUID |
Encapsulate the GUID. A GUID is a string that is universally unique. It is generated from a set of variables including the IP address, hostname and a random number generator. This class does not have a public constructor. Use the MGUIDGenerator class instead, which serves as a factory for the MGUID class. |
MGUIDGenerator | Factory class that generates MGUID instances. A GUID is a string that is universally unique. The SDK itself generates this unique ID from a set of variables including the IP address, hostname and a random number generator. |
MHawkMethod |
Encapsulates a TIBCO Hawk AMI method. For each method, an application must:
|
MHawkMicroAgent | Encapsulate a TIBCO Hawk microagent. The microagent is created automatically during initialization by MApp based on information in the adapter instance description object. The microagent is deleted by MApp during shutdown. MHawkMicroagent keeps track of all registered methods and allows applications to access these methods. |
MHawkSink | MHawkSink allows applications to send trace messages directly to TIBCO Hawk. |
MHostInfo | This class is used with the TIBCO Service Wrapper. The class notifies the Win32 Service Control Manager (SCM) of an application's state. It is also used by TIBCO BusinessWorks and TIBCO Administrator to monitor an adapter's status. |
MInstance |
The MInstance class allows hierarchical data representation. In contrast to MTree, however, MInstance depends on a predefined class description (metadata information). This metadata information is provided in the repository and then encapsulated in a number of classes by the MApp application manager. In effect, MInstance is an MTree constrained by a class description that is stored in TIBCO Repository. MInstance keeps a copy of all MData items that are set. |
MInteger | The SDK supports a number of integer data types encapsulated as data members of the MPrimitiveClassDescription class. This class is governed by those integer data members. |
MInterval | Class for encapsulating a time period. MInterval may include days, hours, minutes, and seconds (with optional microseconds). It cannot include month information. |
MIODescriptorSource |
The MIODescriptorSource class allows applications to generate event objects associated with I/O events arriving through descriptors, typically file descriptors, socket descriptors, or pipe descriptors. Currently, three I/O event types are supported: read, write, and exception. An MIODescriptorSource listens for changes in an IO descriptor, such as a file, socket, or pipe. If an event occurs in the descriptor, the descriptor source generates the appropriate MIOEvent and notifies its event listeners. |
MIOEvent | A special MEvent subclass that is encapsulates an IO event. This event is by default generated by an MIODescriptorSource. |
MJmsConnectionSpec | The MJmsConnectionSpec encapsulates details about JMS connection. |
MJmsSession |
Applications can specify multiple sessions, including multiple sessions of any given type.
You can access an MJmsSession in two ways:
MApp::getComponentByName(sessionName) |
MList | This template class makes some of the C++ STL (Standard Template Library) list methods available. See the STL documentation for more information. |
MListEnumerator | This class allows you to iterate through the elements of a list. |
MMap | This class encapsulate STL map functionality. |
MMapEnumerator |
This class allows you to iterate through the elements of a map, specifying the key and value. Applications should not call the constructor for this class. Instead, they should call the MMap::newEnumerator() method. |
MMemberDescription | Superclass for the MAttributeDescription, MOperationExceptionDescription and MOperationParameterDescription classes. The subclasses inherit from this class the ability to retrieve information about the attribute, operation parameter, or operation exception in which the accessor is called. |
MMessageBundle | MMessageBundle is a collection of tracing messages for this program. |
MMetaDescription | Superclass for all metadata classes. Other metadata classes inherit from MMetaDescription the ability to access extended property values. Extended properties can be defined via TIBCO Designer for classes, attributes, or operations. |
MModeledClassDescription |
A subclass of MBaseClassDescription that encapsulates an actual class. Applications define the metadata for classes in the adapter instance description object. The SDK then parses that information, creating one MModeledClassDescription for each class defined in the adapter instance description object. In effect, MModeledClassDescription is used for application-specific information.
|
MNode | Deprecated as of TIBCO Adapter SDK 5.0.0. |
MOperation |
This is a superclass of all operation classes. Its main functionality is to provide the operation access methods to its subclasses. See also "Tibco ActiveEnterprise Operation Model" in TIBCO Adapter SDK Programmer's Guide. |
MOperationDescription | Encapsulates an operation description defined in the repository with an operation association list in a class object. This class is a subclass of MMetaDescription and inherits its methods. |
MOperationException | Encapsulate a remote exception raised by the server. |
MOperationExceptionDescription | Encapsulates information defined in the raises association list inside the operation association list in the class object. |
MOperationImpl | This class encapsulates server operation implementations. You must create subclasses of this class and implement the onInvoke() method for each method that you want to invoke as a remote operation. |
MOperationParameterDescription | Encapsulates an operation parameter, as defined in the parameter association list inside the operation association list in the class object. |
MOperationReply | This class and MOperationRequest are the two main classes used for operation invocation. This class encapsulates the return value. |
MOperationReplyListener | Asynchronous reply listener base class. |
MOperationRequest | This class and MOperationReply are the two main classes used for operation invocation. This class provides the argument marshalling for the remote operation request. |
MPlugin |
Class that allows plug-ins for the SDK. MPlugin allows applications to add extra functionality to an adapter at runtime without needing recompiling of an adapter. Possible uses of the MPlugin class are:
|
MPrimitiveClassDescription | MPrimitiveClassDescription describes the types that the SDK makes available for attributes in metadata defined in the adapter instance description object. |
MProperties |
This class is a facility for reading name-value pairs. It is used as an interface for accessing any TIBCO Repository subtree (which can be an individual node). Applications can use the methods in this class to add and replace attribute values and can also remove the whole subtree by calling MPropertiesRegistry::removeProperties() with the desired URL as an argument.
A special node in the TIBCO Repository tree is the adapter instance description object, which stores all configuration information in one place, pointing to other locations in the TIBCO Repository for some of the object definitions. You can access this TIBCO Repository object by calling the MAppProperties::getConfigProperties() method.
Warning Using settable MProperties incorrectly can cause serious problems that can cause adapters to stop functioning. TIBCO Software Inc. cannot guarantee that problem resulting form the incorrect use of MProperties class can be solved. MProperties allows arbitrary editing of a resource whose structure is very strictly regulated. Even the slightest mistake, such as a typographical error, can render a configuration incorrect. Using settable properties is analagous to hand-editing database files and should be approached with similar caution. Use MProperties class to create/modify repository at your own risk. |
MPropertiesEnumerator | Used to iterate over an MProperties instance. |
MPropertiesRegistry |
Applications can use more than one MProperties instance and access each instance as needed through the MPropertiesRegistry for the application. Upon startup, MApp creates one MPropertiesRegistry and associates with it the MProperties instance that encapsulates the location specified by setting the repoURL and configURL in MAppProperties (or via the corresponding command-line argument upon start-up). Applications can add other MProperties instances by calling MPropertiesRegistry::newSettableProperties() or MPropertiesRegistry::newProperties(). The MProperties instances correspond to other repository locations with additional configuration and metadata information |
MPublisher | An MPublisher is a reusable component for publishing messages to TIBCO Rendezvous using a specified subject name. |
MReal | Class to be used for data of type real. |
MRvDispatcher |
Deprecated in TIBCO Adapter SDK 5.0.0.
Use MDispatcher. |
MRvSession | Encapsulate a TIBCO Rendezvous session (transport, queue, or queue group). |
MRvSink | An MRvSink allows applications to send on trace messages as TIBCO Rendezvous messages. |
MSequence | Class for encapsulating lists of data. |
MSequenceClassDescription | A subclass of MBaseClassDescription that encapsulates a type that is a sequence. A sequence is basically a typed array which may be bounded or unbounded. Applications use this class to define a sequence, which can then be used as an attribute type in a schema definition. |
MSession | This is the base class for MJmsSession and MRvSession. |
MSink |
The MSink abstract class defines locations that can receive messages from an MTrace. These locations can be files, TIBCO Rendezvous sessions, or other user-defined location. The TIBCO Adapter SDK provides the three subclasses of MSink: MFileSink MRvSink, and MStdioSink. Applications can extend the list of available sinks by implementing, for example, a DbSink class or other subclasses. To implement tracing, an application maps a trace to a sink by calling MTrace::addMapping(). Once the mapping has been created, messages sent to the MTrace object via its trace() method are automatically logged into the specified file (MFileSink) or sent out as a TIBCO Rendezvous message (MRvSink). If you define an MSink with no roles, it is not created in memory until the role is added. |
MStdioSink | An MStdioSink allows output to a user-provided file. MStdioSink is mainly used for tracing to stdout or stderr, it can, however, also be used to trace to any FILE* that is already open. |
MString |
This class encapsulate STL-like string functionality. See the Standard Template Library documentation for additional information. |
MStringData |
Polymorphic container for strings that are meant to be sent on the wire. Contains either NULL-terminated ASCII strings (ASCIIZ) or Unicode strings depending on the constructor used. Converting extraction can be attempted. In contrast to MChar:
|
MSubscriber |
An MSubscriber subscribes to network data. Whenever new data is available, the subscriber generates an MDataEvent and calls the onEvent() method of each registered listener. The subscriber generates an MTimeoutEvent if data events has not been received within the time frame specified in the data event source. |
MTime | Class for encapsulating time information. |
MTimeoutEvent | Encapsulate a timeout event. |
MTimer |
After a specified time interval, an MTimer event source triggers the generation of an MTimerEvent. The MTimer class provides configurable repeating and non-repeating timers. To associate a listener with a timer, call its inherited addListener() method (see MEventSource::addListener()). |
MTimerEvent | Encapsulate timer events. |
MTrace | The MTrace class sets up and maintains a trace mapping table, the data structure that holds the mapping between a message and the corresponding list of message destinations (sinks). Messages are defined by role. |
MTrackingInfo |
The purpose of MTrackingInfo is to provide support for end to end tracability of documents or messages throughout the system. It encapsulates information which is initiated by the first component to send a message (for example, a publishing adapter) and enriched by intermediate components (for example, TIBCO MessageBrokers or receiving adapters). Tracking information allows first to track a message back to its source when an error occured in any given component, and second to provide status information about the progress of a business process distributed among multiple components. The tracking information includes :
|
MTransformationPlugin |
This class provides a means for adapter developers to setup their own low-level plugins to operate against inbound or outbound messages. Developers implement a subclass of MTransformationPlugin and implement the required methods. The low-level callout provided by MTransformationPlugin is primarily intended to allow developers to create custom low-level plugins that can be used against any adapter built with the Adapter SDK. Performing localized transformations using XSLT and encryption/decryption are only two of the possible uses of this feature. Developers can write and deploy their low-level callout plugin such that arbitrary operations can be performed against data in order. Any desired plugin chaining will have to be handled by the plugin writer. This means someone wanting to chain two existing plugins must write their own, third plugin to chain them together (loading the library themselves, forcing processing order, and so forth). |
MTree |
Applications are responsible for converting data from source application format to MTree format and from MTree format to target application format. The MTree class provides two types of structures for data representation.
|
MTreeEnumerator |
Each instance of the MTreeEnumerator class iterates over the elements of an MTree instance. Each call to the next() method produces the next element of the tree. The iteration only looks at nodes at the current level, it is not recursive. Applications create new enumerators by calling MTree::newEnumerator(). Each MTreeEnumerator is associated with the MTree that created it. |
MUnion | Class for encapsulating data specified in the repository as a union. |
MUnionDescription |
A subclass of MBaseClassDescription that encapsulates a type that is a union. A union joins several union members that can then be accessed through the union. Like classes, unions are containers of data items, but the contents of a union are alternatives, and only one alternative is present in the union instance. |
MWString |
This class encapsulate STL-like string functionality for Unicode characters, which are currently always of type M_UTF16BE. See the Standard Template Library documentation for more details. |