  com | |
  pcbsys | |
 nirvana | |
 base | Documentation for the Java Base classes |
  nChannelAttributes | This class is a container for the attributes necessary to create/find a Nirvana channel |
| nConstants | A collection of Constants |
| nConsumeEvent | This class defines the nirvana event that publishers publish and subscribers receive |
| nDataGroup | This class represents a Data Group offering the related services |
| nDataStream | This class represents a Data Stream offering the related services |
| nException | This class defines the errors that can be thrown by using the nirvana client API |
| nExceptionFactory | Exception factory for the Universal Messaging exception |
| nHeader | This class represents a message Header |
| nIllegalArgumentException | A Universal Messaging Illegal Argument Exception |
| nRealm | This class represents a nirvana Realm |
| nSecurityException | This class defines the security errors that can be thrown by using the nirvana client API |
 nStorePermission | Base implementation of a permission entry that provides ability for setting specific Channel/Queue security settings |
| client | Documentation for the Java Client API |
| nAbstractChannel | This is the base class for all nirvana channel types, including queues and normal pub/sub channels and as such has no public methods |
| nAsyncExceptionListener | This interface should be implemented by classes wishing to register to receive asynchronous errors from the nirvana server |
| nBaseClientException | This exception forms the base for all client exceptions |
| nCertificateSigner | This class signs nConsumeEvents as they are published to the Realm Server |
| nCertificateValidator | This class validates signatures signed by the nCertificateSigner class |
| nChannel | This class represents the standard Channel or Topic access to the UM server |
| nChannelAlreadyExistsException | This exception is thrown if a user tries to make a channel that already exsists |
| nChannelAlreadySubscribedException | The user has tried to subscribe to the channel more than once |
| nChannelAttributes | This class is a container for the attributes necessary to create or locate a Nirvana channel or queue |
| nChannelConnectionListener | This interface should be implemented by classes wishing to register to receive callbacks when connections are added or removed to a nirvana channel |
| nChannelIterator | This class iterates synchronously over a Nirvana Realm channel |
| nChannelNotFoundException | The specified channel could not be located on the server |
| nChannelPublishKeys | This class contains the information about a single channel key |
| nChannelStorePermission | Enumeration defining all permissions applicable for a Channel |
| nChannelWatcher | 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 |
| nConflationAttributes | This class represents the conflation attributes that can be used when creating resources which allow conflation |
| nConnectionQueueListener | This interface should be implemented by classes wishing to register to receive asynchronous notifications from the internal connection queue |
| nConstants | This class is a container for the various constants that affect the behaviour of various Nirvana Client API calls |
| nConsumeEvent | This class represents a Nirvana event, which consists of either a tag and some data or an event dictionary and some data |
| nConsumeEventCompressReader | This is a helper class and enables clients to uncompress events being received from a server |
| nConsumeEventCompressWriter | This is a helper class and enables clients to compress events simply prior to them being published to the actual store |
| nConsumeEventFactory | This class is used to facilitate creation of nConsumeEvent objects |
| nConsumeEventFragmentReader | Reconstructs fragmented events back into one nConsumeEvent |
| nConsumeEventFragmentWriter | This class will break up events when the data portion of the event is greater then the threshold specified |
| nCreateResult | This class represents the results of the nSession.create(nChannelAttributes[]) call |
| nDataGroup | This class represents a individual data group object |
| nDataGroupDeletedException | Class representing an exception generated when an operation is performed on an nDataGroup that has been deleted |
| nDataGroupIsReadOnlyException | Class representing an exception generated when an operation is performed on an nDataGroup that is read only |
| nDataGroupIterator | Used to iterate through the nDataStreams contained within an nDataGroup |
| nDataGroupListener | Listener interface used to manage changes to membership of data groups |
| nDataStream | Represents the stream used to deliver data |
| nDataStreamListener | Interface used to receive events asynchronously from a data group |
| nDeleteResult | This class represents the results of the nSession.deleteResources(nChannelAttributes[]) call |
| nDuplicateJoinException | The user has requested a join be created but the server already has this join configured in the database |
| nDurable | Base class for all nDurable types |
| nEventAttributes | The nEventAttributes class is used by the nConsumeEvent object in order to store standard header values associated with nirvana client and JMS events |
| nEventListener | This interface should be implemented by any object that wishes to register itself as an asynchronous subscriber to a nirvana channel or queue |
| nEventProperties | This class contains a collection of key-value pairs, defining event meta data which can be used to create filter rules |
| nEventPropertiesHelper | This class is a helper class for the nEventProperties key,value pairs |
| nEventPropertiesIterator< T > | This class allows you to iterate through the nEventProperties to examine the key,value pairs |
| nEventPublisher | The nEventPublisher is an interface that is used by the compression writer and the fragment writer |
| nExceededLimitException | The number of events in the current transaction has exceeded the server configuration |
| nExclusiveDurable | The Exclusive Durable Implementation of nDurable |
| nFindResult | This class represents the results of the nSession.find(nChannelAttributes[]) call |
| nIllegalArgumentException | 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 |
| nIllegalChannelMode | This exception is thrown if a user tries calls queue specific functionality on a channel object or channel specific functionality on a queue object |
| nIllegalStateException | This exception is thrown if a Channel or Queue is in an illegal state for specific functionality to be offered |
| nJoinInformation | This class is a container for all the information that defines a channel join |
| nMessageSigner | This interface contains the generic functionaility that all message signers need to implement |
| nMessageValidator | This interface defines the generic functionaility that all Message Validators need to implement |
| nNameAlreadyBoundException | This exception is thrown if a user attempts to create a named client context on a channel or queue that is already in use |
| nNamedObject | This class represents a client context on a RealmServer |
| nNameDoesNotExistException | This exception is thrown if a user attempts to delete a named client context on a channel or queue that does not exist |
| nNamedPriorityListener | This interface should be implemented by any object that requires a callback when the subscription to a channel with a named object and priority enabled reaches the top |
| nNameSpaceConflictException | There is a confict in the name space and the attempted operation failed |
| nPassphraseSigner | This class signs an event with a digest of the event and the passphrase |
| nPassphraseValidator | This class implements a message digest Validator |
| nPriorityDurable | This class represent a Priority Durable implementation of nDurable |
| nProtobufEvent | This class represents a Google Protocol Buffer Event |
| nProtobufEventFactory | This class is used to facilitate creation of nProtobufEvent objects |
| nQueue | This class provides a Queue mechanism |
| nQueueAsyncReader | This Reader enables the client to receive all events asynchronous |
| nQueueAsyncTransactionReader | This class extends the asynchronous queue model by adding the transactional ability to the reader |
| nQueueDetails | Container class, containing statistics on the queue |
| nQueuePeekContext | Provides a context when peeking on the queue |
| nQueueReader | This class is the base class for all Queue Readers and provides a generic reader interface |
| nQueueReaderContext | This class is used to construct a Queue Reader |
| nQueueStorePermission | Enumeration defining all permissions applicable for a Queue |
| nQueueSyncFragmentReader | This class provides the client with an synchronous interface into a Nirvana Queue |
| nQueueSyncReader | This class provides the client with an synchronous interface into a Nirvana Queue |
| nQueueSyncTransactionFragmentReader | This reader provides a synchronous queue reader model |
| nQueueSyncTransactionReader | This reader provides a synchronous queue reader model |
| nQueueTransactionReader | Provides the basic interface for transactional queue operations, used by the synchronous and asynchronous transactional queue readers |
| nRealm | This class represents a nirvana Realm |
| nRealmAlreadyBoundException | You have tried to bind a realm that the server already has been bound |
| nRealmInUseException | 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 |
| nRealmNotFoundException | The specified realm was not found on the server |
| nRealmUnreachableException | Was unable to reach the specified realm |
| nReconnectHandler | 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 |
| nRegisteredEvent | 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 |
| nRegisteredEventListener | This interface should be implemented by any object that wishes to register itself as an asynchronous subscriber and receive update events and complete merged events from a registered event |
| nRegisteredEventUpdateListener | This interface should be implemented by any object that wishes to register itself as an asynchronous subscriber and only receive update events only from a registered event |
| nRequestTimedOutException | When the maximum time the client API will wait for a response to a specific request from the Nirvana realm, this exception is thrown |
| nResult | This class is the base class that represents the results of a batched find, create or delete call for channels or queues |
| nSecurityException | This class defines the security errors that can be thrown by using the nirvana client API |
| nSelectorParserException | The supplied message filter string failed to be parsed |
| nSession | This class represents a Nirvana session, the logical connection between the client API and the Nirvana realm |
| nSessionAlreadyInitialisedException | The current nSession is not currently connected |
| nSessionAttributes | This class is a container for the attributes necessary to create a Nirvana session |
| nSessionConnectionWriteException | The current nSession connection queue is having trouble sending events |
| nSessionFactory | This class is used with a nSessionAttributes object to create a Nirvana session |
| nSessionNotConnectedException | The current nSession is not currently connected |
| nSessionPausedException | This exception is thrown when an attempt is made by the client to make a request to the server, while the session is paused |
| nSharedDurable | The shared durable implementation of nDurable |
| nSharedDurableQueued | The Queue shared durable implementation of nSharedDurable |
| nSignedEventListener | This interface should be implemented by any object that wishes to register itself as a subscriber to a nirvana channel or queue, using the nMessageValidator class to receive signed events |
| nStorePermission | Class that provides ability for setting specific Channel/Queue security settings |
| nStorePermissionGenerator | Class responsible for generating the permission mask to be applied to a Queue/Channel |
| nSubject | This class contains information about the user identification used by Nirvana |
| nSubscriptionAttributes | This class represents the attributes used for channel subscriptions |
| nTransaction | This class enables the client to perform transactional publishing, representing a nirvana transaction |
| nTransactionAlreadyAbortedException | The transaction has already been aborted and as such is closed |
| nTransactionAlreadyCommittedException | The transaction has already been committed and as such is closed and completed |
| nTransactionAttributes | This class is a container for the attributes necessary to create a Nirvana transaction |
| nTransactionException | This class defines the errors that can be thrown by using the nirvana transactional publish API |
| nTransactionFactory | This class is used with a nTransactionAttributes object to create a Nirvana transaction |
| nTransactionIncompleteException | This exception will be thrown if abort or commit is called on a transaction that has not sent any events to the server |
| nTransactionNoEventsException | This exception is thrown if Commit is called on a transaction without any events added in its context |
| nTransactionNoSuchTXIDException | The supplied transaction ID could not be located on server |
| nTransactionNotCommittedException | The transaction has not been committed so the status of the event can not be returned, such as getStartEID or getEndEID |
| nTransactionNotStartedException | The transaction has not been started as such the transaction is not yet established |
| nUnexpectedResponseException | The server responded with an event that the client did not expect |
| nUnknownRemoteRealmException | The server does not know of the realm that was supplied |
| nUnknownTransactionIdException | 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 |
| nUserAuthentication | The nUserAuthentication class provides the ability to perform basic HTTP athentication to a nirvana realm running a file plugin with authentication turned on |
| nUserNotSubscribedException | The user is not currently subscribed to the channel/ |
 nAdminAPI | Documentation for the Nirvana Java Administration API |
| nACL | List of nACLEntry classes used by the Nirvana Realm server to control access to secured objects such as Realms, Channels and Queues |
| nACLEntry | Contains the mapping between a subject User and the priviliges they can perform on a secured object such as a Realm, Channel or Queue |
| nACLEntryNotFoundException | Exception class that is thrown when an acl entry is not found when an operation is attempted on it |
| nAdminIllegalArgumentException | Exception class that is thrown when an illegal argument is passed into a method |
| nAdminIllegalStateException | Exception class that is thrown when attempted operations is not allowed due to an invalid admin session state |
| nAdminSecurityException | Exception class that is thrown when attempted operations are not permitted |
| nAuditEvent | This class contains information for realm auditing |
| nAuditListener | Classes that implement this interface can register with the nRealmNode.addAuditListener() to receive the realm's audit events |
| nBaseAdminException | Base class for all admin API exceptions |
| nBaseInterface | Base class for all Admin API interfaces |
| nChannelACLEntry | Extends the nACLEntry class to supply Channel/Queue specific security settings |
| nChannelConnectionDetails | This class contains additional information about a channel connection |
| nClusterConnectionListener | Any class that implements this interface can be registered against a Nirvana Cluster node to receive notification when remote connections are made or dropped on any of the cluster realm node objects |
| nClusterConversionStatus | Provides an interface which allows the status of cluster conversions to be monitored |
| nClusterEventListener | Interface allowing client applications to receive cluster specific callbacks |
| nClusterMemberConfiguration | This object is used to create/modify clusters |
| nClusterNode | Contains the status and configuration of a Nirvana cluster |
| nClusterSite | This class defines a collection of realms within a cluster into a physical site / location |
| nClusterStatus | This class contains the status of the of a realm within the cluster, What state it has, which node is the elected master etc |
| nClusterStatusEntry | This class contains online/offline status a realm within a cluster |
| nCommandStatus | Any class implementing this interface can be used to find the current status of a request, for example a copy operation of a nLeafNode |
| nConfigEntry | This class contains all the information about a configuration parameter, including the name, the current value, a description of it and a warning or constrant string |
| nConfigGroup | This class manages a group of nConfigEntry objects that are related |
| nConfigurationException | Exception thrown when configuration operations fail |
| nConnectionDetails | This class contains the details about an individual connection |
| nConnectionListener | Any class that implements this interface can be registered against a Nirvana Realm, Channel or Queue to receive notification when remote connections are made or dropped |
| nContainer | This represents a node within the Nirvana Realm namespace which contains other nodes, such as a directory or another Realm |
| nCopyable | All classes that can be copied from one part of the namespace to another implement this interface |
| nCustomHeader | This Class represent a single custom header field which will be used by javascript |
| nDataGroupNode | This class is an Admin API wrapper for a Data Group object (nDataGroup) |
| nDataGroupsContainer | This class is an Admin API wrapper for all configured Data Group objects (nDataGroup) |
| nDataStreamNode | This class is an Admin API wrapper for a Data Stream object (nDataStream) |
| nDuplicateACLEntryException | Exception class that is thrown when a duplicate acl entry is attempted to be added |
| nDuplicateChannelNameException | Exception class that is thrown when attempted operations is not allowed due to an invalid admin session state |
| nDurableNode | Represents the current nDurable status |
| nHTTPInterface | This class contains all the configuration required by the Nirvana Realm server to start and control the HTTP interface |
| nHTTPSInterface | This class contains all the configuration required by the Nirvana Realm server to start and control the HTTPS interface |
| nInsufficientPrivilegesException | Exception class that is thrown when an operation is performed and there are insufficient privillages to complete it |
| nInterface | Abstract Class nInterface |
| nInterfaceManager | This class exposes the Realm Servers interface management API so that the control and management of the interfaces can be performed by an authorised Administrator |
| nInterfacePluginConfiguration | This class contains the plugin static information used by the plugin instances |
| nInterfaceStatus | Contains the status of a Nirvana Realm server interface |
| nInterfaceViaEntry | This contains the user parameters which are bound to an Interface |
| nJoinable | All classes that can be joined from one part of the namespace to another implement this interface |
| nJoinDetails | This class contains information about a join between two channels |
| nLeafNode | This class represents the Nirvana Channel or Queue on the Nirvana Realm |
| nLinkNode | Since the Nirvana namespace can contain multiple links to Nirvan Realm servers at different parts of the namespace, including namespace loops, this node represents a RealmServer which has been mounted elseware in the namespace |
| nLogListener | Classes that implement this interface can register with the nRealmNode.addLogListener() to receive the realms log events |
| nMulticastConfiguration | Multicast Configuration class |
| nMulticastConfigurationStatus | Contains the status of a Nirvana Realm server multicast interface |
| nNode | All classes that exist in the Nirvana Realm NameSpace extend this object |
| nNodeException | Exception class that is thrown when errors occur constructing the nodes to be administered |
| nNodeUtilities | Class that provides some utility functions for nNode operations |
| nPkgDataGroupListener | Created by IntelliJ IDEA |
| nPluginConfigEntry | Contains information for a plugin configuration entry |
| nPluginConfiguration | This class contains the configuration context for a single plugin on a single HTTP type interface |
| nRDMAInterface | RDMA Interface class |
| nRealmACLEntry | Extends the nACLEntry class to expose the Realm specific permissions |
| nRealmAdmin | This class provides basic Administration functionality for security based operations |
| nRealmNode | This class represents a Realm within the Nirvana namespace |
| nRemovable | All classes that can be removed from the namespace implement this interface |
| nScheduler | This class represents a parsed instance of a Nirvana Realm scheduler |
| nSchedulerBuildHelper | This is a helper class used in the construction/parsing and validation of Nirvana Realm server Scheduler scripts |
| nSchedulerManager | Manages the scheduler entries for a realm |
| nSchedulerParseException | This exception is raised whn parsing a Nirvana Realm Scheduler script with syntax errors |
| nSecurityGroup | This class represents a "Security Group" that contains entries for nSubject objects, and other nSecurityGroup objects |
| nServiceACLEntry | Allows the ability to programmatically allow or deny access to a service |
| nSharedMemoryInterface | Created by IntelliJ IDEA |
| nSocketInterface | Socket Interface class |
| nSSLInterface | This class contains all the configuration required by the Nirvana Realm server to start and control the SSL interface |
| nSSLInterfaceAPI | This interface is used to expose the SSL attributes for all interfaces that are SSL enabled |
| nTask | Has details about individual tasks within a scheduler |
| nThreadEntry | This class is used to represent instances of tasks within a thread pool running within a Nirvana realm |
| nThreadPool | This class is used to represent an instance of a thread pool beign used within a Nirvana realm |
| nTrigger | This class is used to query a trigger generated by a Scheduler script |
| nUnsupportedCopyException | Exception class that is thrown when a copy operation is attempted but cannot be completed |
| nUnsupportedJoinException | Exception class that is thrown when a join operation is attempted but cannot be completed |
| nUnsupportedRemoveException | Exception class that is thrown when a remove operation is attempted but cannot be completed |
| nZone | Represents a Zone |
| nZoneManager | Represents a Zone manager |
| nZoneNode | Represents a Zone container node |
| nZoneUpdate | This class represents an update to the state of a Zone against a Realm server for UM |
| softwareag | |
| um | |
| modules | The modules package contains various modules like transport (formerly com.softwareag.um.modules.io package) and storage (formerly com.softwareag.um.storage package) |
| event | Event is a module that allows a generic mechanism to read and write Events from transport and storage |
| EventFactory | This class is responsible to map an int to a Event such that it can be used to deserialize Event objects from Storage |
| io | IO is a module that contains IO streams with serialisation of Primitive types |
| PrimitiveTypeInputStream | This class implements DataInput functions |
| log | Log is a module that is used by other modules in the com.softwareag.um.modules package |
| Logger | The class used to log messages in UM Transport |
| LogListener | This class provides a mechanism to override the default Logging within the umTransport code |
| storage | Storage is a module that allows the use of various store types for persisting or managing in memory events |
| Storage | Represents an Event store |
| StorageFactory | Represents a factory for creating Storage objects |
| StorageProperties | Contains the properties used to construct a Storage object |
| StorageSyncListener | Listener for sync operations in a Storage object |
| StorageType | There are 3 ways events are managed by the stores, |
| transport | Universal Messaging Transport API Package |
| AcceptHandler | This interface is passed to TransportFactory.bind when you want to create an AsynchronousServerTransport |
| AsynchronousServerTransport | 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 |
| AsynchronousTransport | This is a client side Transport object |
| ClientContextBuilder | This is an abstract Builder object which is used to create client side Transports |
| ClientContextBuilderFactory | This factory allows you to construct ClientContextBuilders and therefore ClientTransportContexts by passing a String URL |
| ClientRDMATransportContext | Constructed using the ClientRDMATransportContext.Builder |
| ClientSHMTransportContext | Constructed using the ClientSHMTransportContext.Builder |
| ClientSocketTransportContext | Constructed using the ClientSocketTransportContext.Builder |
| ClientSSLTransportContext | Constructed using the ClientSSLTransportContext.Builder |
| ClientTransportContext | This represents a client side TransportContect that is used to create Transport objects using the TransportFactory |
| CloseHandler | 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 |
| ConnectHandler | This interface is passed to TransportFactory.connect when you want to create an AsynchronousTransport |
| ContextBuilder | Represents a Builder object which is used to create client or server TransportContexts |
| DataHandler | This interface is passed to the TransportFactory.connect method when you want to create an AsynchronousTransport |
| ServerContextBuilder | This is an abstract builder object that is used to create ServerTransports |
| ServerContextBuilderFactory | This factory allows you to construct ServerContextBuilders and therefore ServerTransportContexts by passing a String URL |
| ServerRDMATransportContext | Constructed using the ServerRDMATransportContext.Builder |
| ServerSHMTransportContext | Constructed using the ServerSHMTransportContext.Builder |
| ServerSocketTransportContext | Constructed using the ServerSocketTransportContext.Builder |
| ServerSSLTransportContext | Constructed using the ServerSSLTransportContext.Builder |
| ServerTransport | Interface that defines methods common to all ServerTransports |
| ServerTransportContext | Abstract class which defines methods common to all ServerTransportContexts |
| SynchronousServerTransport | This ServerTransport is used synchronously accept client transports |
| SynchronousTransport | This Transport represents a client connection |
| Transport | Interface that defines methods common to all client Transports |
| TransportContext | Abstract class that defines methods common to all TransportContexts |
| TransportFactory | The TransportFactory is used to to create ServerTransports or client Transports |
