| Home >> All >> com >> presumo >> [ jms Javadoc ] |
• com.presumo.jms: Javadoc index of package com.presumo.jms.
Package Samples:
• com.presumo.jms.client
• com.presumo.jms.message
• com.presumo.jms.persistence
• com.presumo.jms.plugin.implementation.transport.tcp
• com.presumo.jms.plugin.implementation
• com.presumo.jms.plugin
• com.presumo.jms.plugin.transport
• com.presumo.jms.qmgr
• com.presumo.jms.resources
• com.presumo.jms.router
• com.presumo.jms.selector
• com.presumo.jms.test
Classes:
• JmsServer: Encapsulation of a Presumo JMS server. Any application may start a JMS server within their application with the following steps. Instantiate the server with the constructor that is appropriate to your application's needs. Start the server with startup() Start every type of server listener that is needed. To start a tcp socket listener on 127.0.0.1:2323 call: startServerTransport("tcp://127.0.0.1:2323") . Connect the server to other servers if needed. To connect to a server at 192.168.1.1 running a TCP listener on port 2323 you would call: startClientTransport("tcp://192.168.1.1:2323") You may connect ...
• SelectorFalseException: JMS defines some conditions that will always render a selector false. One example is trying to add two strings. While the parser can detect errors in literals at parse time, it can not tell what type an identifier is until evaluation time. If an identifier type is incorrectly used JMS says that the selector is invalid. Another example would be referencing an object property from anywhere in the sql expression. The evaluate methods will throw this exception if they encounter a situation like the ones above. This will effectively short-circuit the evaluation. If you call evaluate on the node in the ...
• PrimitiveMap: Implements a map like structure for primitive values with a String key. This data structure is used to implement javax.jms.Message header properties and the javax.jms.MapMessage. While a Map data structure that allows storage of primitive values might seem attractive as a generic data structure, this implementation does not really optimize memory usage (i.e. primitive's are still represented by their cooresponding Object types in memory), but rather is only optimized for converting to byte streams. Consequently, don't pull this class into a generic data structure in the future. It is really only ...
• Parser: Access point to the filter functionality for the rest of the JMS implementation. This class (along with every other class in this package) is on the critical path for message throughput performance. Thus it is, and must remain optimized. Parser is a singleton instead of a series of static methods because I read somewhere that instance methods are faster than static methods (never personally verified this). The class is thread safe, but to prevent the routing thread from having to obtain a lock for every evaluation, a thread can obtain the lock once and call several evaluations before releasing ...
• MemoryMessageQueue: Implementation of the MessageQueue interface in which all messages reside in memory. Used by RemoteSession and JmsSession due to some nasty design shortcuts. Currently also used by Router, but that will eventually be replaced by an implementation that transactionally writes persistent messages to disk and leaves non-persistent messages in memory.
• Router: The main routing functionality. The Router maintains a list of RoutingTarget 's, and for every message it is asked to route, it simply hands it to each routing target asking. The RoutingTarget itself determines if it needs the message and keeps it if so. The Router is also responsible for maintaining the filters.
• JmsMessageProducer: Implementation of the interface javax.jms.MessageProducer . TopicPublisher s and QueueSender s have pratically identical functionality in this implementation (actually the differences are just differred to the routing logic elsewhere). Consequently, almost all logic is in this base class.
• RouterAdapter: Class to represent the functionality of starting stoping and closing a thread that is doing routing. This handles all of the multithreading logic for the router, and was pulled out to an abstract base class to simplify the actual Router implementation. WARNING: If you change ANYTHING in this class unit test!!!!!
• SelectorTests: Unit test used to exercise the sql-jms filter; This class was generated during initial development. It should be maintained along with the rest of the code in this package. The class is meant to test package protected functionality and thus should remain in this package.
• RemoteSession: Class that sits between the Router and the Transport layer in terms of message flow. Essentially encapsulates the remote connection from the router, as well as handling the persistent message acknowledgment scheme.
• RoutingTarget: Only interface the Router knows about in terms of sending messages. Classes wishing to receive messages (i.e. RemoteSession and JmsSession) Implement this interface and register themselves with the Router.
• JmsGreater: Expression node for the SQL greater than expression. There is no implementation for greater than equals ">=" because the parser represents such statements as a less than with the operands switched.
• JmsLess: Expression node for the SQL less than expression. There is no implementation for less than equals "<=" because the parser represents such statements as a greater than with the operands switched.
• ClientTests: Unit tests for the client. Should test IntraJVM traffic, so consequently the Router will get instantiate to route the messages between the publisher and subscriber in the same JVM.
• JmsOperand: Base class for all nodes in the JMS parse tree. All functionality is package protected, and calling code should use the access point represented by Parser .
• JmsMessageConsumer: Implementation of the interface javax.jms.MessageConsumer . All code common to TopicSubscribers and QueueReceivers is contained within this class.
• JmsSession: Implementation of javax.jms.Session . Also contains plenty of routing logic since the session talks to the Router.
• Transport: Interface which all transport types must implement. Represents a duplex connection with a remote host.
• MessageEncoder: Interface to the rest of the JMS service for encoding and decoding messages to and from a byte stream.
• Demo: Thrown together to test/demonstrate the performance that can be expected from presumo once completed.
• JmsNumericLiteral: Class whose methods allow for comparison and math operations to be performed on doubles and longs.
• ServerTransport: Defines the interface that must be implemented to provide a new server side transport mechanism.
• RegExp: Trailing class to implement NFA for the Like clause. Many thanks to Rob Cauble who wrote this.
• LogFileEntry: Abstract base class for all possible entries that might go into a log file.
| Home | Contact Us | Privacy Policy | Terms of Service |