| ▼Ncom | Class that provides ability for setting specific Channel/Queue security settings |
| ▼Npcbsys | |
| ▼Nnirvana | |
| ►Nclient | Documentation for the Nirvana C++ Client API |
| CnAbstractChannel | This is the base class for all nirvana channel types, including queues and normal pub/sub channels and as such has no public methods |
| CnAsyncExceptionListener | This interface should be implemented by classes wishing to register to receive asynchronous errors from the nirvana server |
| CnBaseClientException | This exception forms the base for all client exceptions |
| CnChannel | This class is a Nirvana channel, offering the Nirvana channel related services |
| CnChannelAlreadyExistsException | This exception is thrown if a user tries to make a channel that already exists |
| CnChannelAlreadySubscribedException | The user has tried to subscribe to the channel more than once |
| CnChannelAttributes | This class is a container for the attributes necessary to create or locate a Nirvana channel or queue |
| CnChannelConnectionListener | This interface should be implemented by classes wishing to register to receive callbacks when connections are added or removed to a nirvana channel |
| CnChannelIterator | This class iterates synchronously over a Nirvana Realm channel |
| CnChannelNotFoundException | The specified channel could not be located on the server |
| CnChannelPublishKeys | This class contains the information about a single channel key |
| CnChannelWatcher | This interface extends the nEventListener interface and also provides the ability to receive callbacks for purged events as well as events published on a specific channel or queue |
| CnConnectionQueueListener | This interface should be implemented by classes wishing to register to receive asynchronous notifications from the internal connection queue |
| CnConstants | This class is a container for the various constants that affect the behaviour of various Nirvana Client API calls |
| CnConsumeEvent | This class represents a Nirvana event, which consists of either a tag and some data or an event dictionary and some data |
| CnConsumeEventFactory | This class is used to facilitate creation of nConsumeEvent objects |
| CnCreateResult | This class represents the results of the nSession.create(nChannelAttributes[]) call |
| CnDeleteResult | This class represents the results of the nSession.create(nChannelAttributes[]) call |
| CnDuplicateJoinException | The user has requested a join be created but the server already has this join configured in the database |
| CnEventAttributes | Used by the nConsumeEvent object in order to store standard header values associated with nirvana client, p2p and JMS events |
| CnEventListener | This interface should be implemented by any object that wishes to register itself as an asynchronous subscriber to a nirvana channel or queue |
| CnEventProperties | This class contains a collection of key-value pairs, defining event meta data which can be used to create filter rules |
| CnEventPropertiesIterator | This class enables you to iterate through the event properties keys and values |
| CnExceededLimitException | The number of events in the current transaction has exceeded the server configuration |
| CnFindResult | This class represents the results of the nSession.find(nChannelAttributes[]) call |
| CnIllegalArgumentException | This class defines the error that can be thrown by passing an illegal argument to any method of any class in the nirvana client API |
| CnIllegalChannelModeException | This exception is thrown if a user tries calls queue specific functionality on a channel object or channel specific functionality on a queue object |
| CnIllegalStateException | This exception is thrown if a Channel or Queue is in an illegal state for specific functionality to be offered |
| CnJoinInformation | This class is a container for all the information that defines a channel join |
| CnNameAlreadyBoundException | This exception is thrown if a user attempts to create a named client context on a channel or queue that is already in use |
| CnNamedObject | This class represents a client context on a RealmServer |
| CnNameDoesNotExistException | This exception is thrown if a user attempts to delete a named client context on a channel or queue that does not exist |
| CnNameSpaceConflictException | There is a conflict in the name space and the attempted operation failed |
| CnObject | This class is a holder for different types of object |
| CnProtobufEvent | This class represents a Google Protocol Buffer Event |
| CnProtobufEventFactory | This class is used to facilitate creation of nConsumeEvent objects |
| CnPublishPausedException | The currently connected server has been paused, and is not accepting publish requests |
| CnQueue | This class provides a Queue mechanism |
| CnQueueAsyncReader | This Reader enables the client to receive all events asynchronously |
| CnQueueAsyncTransactionReader | This Reader enables the client to receive all events asynchronously |
| CnQueueDetails | Container class, containing statistics on the queue |
| CnQueuePeekContext | Provides a context when peeking on the queue |
| CnQueueReader | This class is the base class for all Queue Readers and provides a generic reader interface |
| CnQueueReaderContext | This class is used to construct a Queue Reader |
| CnQueueSyncReader | This class provides the client with a synchronous interface into a Nirvana Queue |
| CnQueueSyncTransactionReader | This reader provides a synchronous queue reader model |
| CnQueueTransactionReader | Provides the basic interface for transactional queue operations, used by the synchronous and asynchronous transactional queue readers |
| CnRealm | This class represents a nirvana Realm |
| CnRealmAlreadyBoundException | You have tried to bind a realm that the server already has been bound |
| CnRealmInUseException | This exception is thrown when an attempt is made to remove a realm from another realm when the realm is part of a cluster or has channels that are joined in the requesting realm |
| CnRealmNotFoundException | The specified realm was not found on the server |
| CnRealmUnreachableException | Was unable to reach the specified realm |
| CnReconnectHandler | This interface should be implemented by classes wishing to register to receive callbacks when sessions are disconnected or to take control over the reconnect logic |
| CnRegisteredEvent | This class enables a client to maintain a copy of an event, make changes to the properties and then when commit is called only the changes are published to the server |
| CnRequestResponseContainer | This class is the container for the request responses |
| CnRequestTimedOutException | When the maximum time the client API will wait for a response to a specific request from the Nirvana realm is reached, this exception is thrown |
| CnSecurityException | This class defines the security errors that can be thrown by using the nirvana client API |
| CnSelectorParserException | The supplied message filter string failed to be parsed |
| CnSession | This class represents a Nirvana session, the logical connection between the client API and the Nirvana realm |
| CnSessionAlreadyInitialisedException | The current nSession has already been initialised |
| CnSessionAttributes | This class is a container for the attributes necessary to create a Nirvana session |
| CnSessionFactory | This class is used with a nSessionAttributes object to create a Nirvana session |
| CnSessionNotConnectedException | The current nSession is not currently connected |
| CnSessionPausedException | This exception is thrown when an attempt is made by the client to make a request to the server, while the session is paused |
| CnStoreProperties | Class that contains additional properties that can be set on the channel or queue |
| CnSubject | This class contains information about the user identification used by Nirvana |
| CnSubscriptionAttributes | This class represents the attributes used for channel subscriptions |
| CnTransaction | This class enables the client to perform transactional publishing, representing a nirvana transaction |
| CnTransactionAlreadyAbortedException | The transaction has already been aborted and as such is closed |
| CnTransactionAlreadyCommittedException | The transaction has already been committed and as such is closed and completed |
| CnTransactionAttributes | This class is a container for the attributes necessary to create a Nirvana transaction |
| CnTransactionException | This class defines the errors that can be thrown by using the nirvana transactional publish API |
| CnTransactionFactory | This class is used with a nTransactionAttributes object to create a Nirvana transaction |
| CnTransactionIncompleteException | This exception will be thrown if abort or commit is called on a transaction that has not sent any events to the server |
| CnTransactionNoEventsException | This exception is thrown if Commit is called on a transaction without any events added in its context |
| CnTransactionNoSuchTXIDException | The supplied transaction ID could not be located on server |
| CnTransactionNotCommittedException | The transaction has not been committed so the status of the event can not be returned, such as getStartEID or getEndEID |
| CnTransactionNotStartedException | The transaction has not been started as such the transaction is not yet established |
| CnUnexpectedResponseException | The server responded with an event that the client did not expect |
| CnUnknownRemoteRealmException | The server does not know of the realm that was supplied |
| CnUnknownTransactionIdException | This exception is thrown when an attempt is made to perform an operation on a transaction where the id of the transaction is not known by the server |
| CnUserNotSubscribedException | The user is not currently subscribed to the channel |
| ▼Nsoftwareag | |
| ▼Numtransport | Universal Messaging Transport API Package |
| CAcceptHandler | This interface is passed to TransportFactory.bind when you want to create an AsynchronousServerTransport. The onAccept method will be invoked whenever a client connected to the ServerTransport |
| CAsynchronousServerTransport | By establishing an AsynchronousServerTransport, new client connections will automatically be accepted and notifications of new connections will be passed to the user implementation of AcceptHandler. To create an AsynchronousServerTransport you must first create a ServerTransportContext and then pass this to the TransportFactory.bind method with the required callback objects (AcceptHandler, DataHandler, CloseHandler) |
| CAsynchronousTransport | This is a client side Transport object. It is constructed on the client side by creating a ClientTransportContext which is then passed to TransportFactory.bind with the required callback objects (DataHandler, CloseHandler). On the server side, an AsynchronousServerTransport will accept connections and handle them as AsynchronousTransports |
| CClientContextBuilder | This is an abstract Builder object which is used to create client side Transports |
| ►CClientRDMATransportContext | Constructed using the ClientRDMATransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is transmitted using Remote Direct Memory Access |
| CBuilder | This Builder object is used to build a ClientRDMATransportContext. The ClientRDMATransportContext is configured using the builder so that once build() is called, the ClientRDMATransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CClientSHMTransportContext | Constructed using the ClientSHMTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is transmitted using Shared Memory |
| CBuilder | This Builder object is used to build a ClientSHMTransportContext. The ClientSHMTransportContext is configured using the builder so that once build() is called, the ClientSHMTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CClientSocketTransportContext | Constructed using the ClientSocketTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is transmitted using TCP Sockets |
| CBuilder | This Builder object is used to build a ClientSocketTransportContext. The ClientSocketTransportContext is configured using the builder so that once build() is called, the ClientSocketTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CClientSSLTransportContext | Constructed using the ClientSSLTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is encrypted using SSL and transmitted using Sockets |
| CBuilder | This Builder object is used to build a ClientSSLTransportContext. The ClientSSLTransportContext is configured using the builder so that once build() is called, the ClientSocketTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| CClientTransportContext | This represents a client side TransportContect that is used to create Transport objects using the TransportFactory |
| CClientTransportContextFactory | This factory allows you to construct ClientTransportContexts by passing a String URL. This way you can compile an application which is Transport agnostic and simply change the URL passed to the application to switch from SHM to Sockets etc. A URL is of the form protocol://host:port?Property=value&Property2=value2 The relevant ClientContextBuilder will be constructed based on the protocol and then the properties will be set internally. So on a ClientSHMTransportContext there is a property called "LowLatency" that you could set to true using a URL like this: |
| CCloseHandler | The CloseHandler interface is passed to the TransportFactory.bind method when you want to create and AsynchronousServerTransport or to the TransportFactory.connect method when you want to create client side AsynchronousTransports. The object which implements this interface will be notified when Transports are closed |
| CConnectHandler | This interface is passed to TransportFactory.connect when you want to create an AsynchronousTransport. The onConnect method will be called when the Transport connects |
| CContextBuilder | Represents a Builder object which is used to create client or server TransportContexts |
| CDataHandler | This interface is passed to the TransportFactory.connect method when you want to create an AsynchronousTransport. It is also passed to the TransportFactory.bind method when you want an AsynchronousServerTransport. The onRead method will be called when data has been read from the AsynchronousTransport |
| CLogger | The class used to log messages in UM Transport |
| CLogListener | This class provides a mechanism to override the default Logging within the umTransport code. This allows users to then log messaging using any log mechanism they want to use |
| CServerContextBuilder | This is an abstract builder object that is used to create ServerTransports |
| ►CServerRDMATransportContext | Constructed using the ServerRDMATransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.bind. Communication on the transport is transmitted using Remote Direct Memory Access |
| CBuilder | This Builder object is used to build a ServerRDMATransportContext. The ServerRDMATransportContext is configured using the builder so that once build() is called, the ServerRDMATransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CServerSHMTransportContext | Constructed using the ServerSHMTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is transmitted using Shared Memory |
| CBuilder | This Builder object is used to build a ServerSHMTransportContext. The ServerSHMTransportContext is configured using the builder so that once build() is called, the ServerSHMTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CServerSocketTransportContext | Constructed using the ServerSocketTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport is transmitted using TCP Sockets |
| CBuilder | This Builder object is used to build a ServerSocketTransportContext. The ServerSocketTransportContext is configured using the builder so that once build() is called, the ServerSocketTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| ►CServerSSLTransportContext | Constructed using the ServerSSLTransportContext.Builder. All information must be set on the Builder so that when this object is built, it is validated. It is used to create Transport objects using TransportFactory.connect. Communication on the transport SSL encrypted and transmitted using Sockets |
| CBuilder | This Builder object is used to build a ServerSSLTransportContext. The ServerSSLTransportContext is configured using the builder so that once build() is called, the ServerSSLTransportContext is only returned if it is valid. You can use the Builder to create simple readable code like this: |
| CServerTransport | Interface that defines methods common to all ServerTransports |
| CServerTransportContext | Abstract class which defines methods common to all ServerTransportContexts |
| CSynchronousServerTransport | This ServerTransport is used synchronously accept client transports. The accept() call is a blocking call which will return a SynchronousTransport as soon as it connects |
| CSynchronousTransport | This Transport represents a client connection. It is created on the client side using TransportFactory.connect and on the server side using SynchronousServerTransport.accept(). Read and write calls to this Transport are blocking calls |
| CTransport | Interface that defines methods common to all client Transports |
| CTransportContext | Abstract class that defines methods common to all TransportContexts |
| CTransportFactory | The TransportFactory is used to to create ServerTransports or client Transports. To bind a server Transport you need to first create a ServerTransportContext or to connect to an existing server you need to create a ClientTransportContext |
