public interface EventService
EventSubscriber
s subscribe to a type on an EventService
, such
as the EventBus
, by providing a class, interface or generic type. The EventService
notifies subscribers when objects are published on the EventService with a matching type. Full class semantics are
respected. That is, if a subscriber subscribes to a class, the subscriber is notified if an object of
that class is publish or if an object of a subclass of that class is published. Likewise if a subscriber subscribes
to an interface, it will be notified if any object that implements that interface is published. Subscribers can
subscribe "exactly" using subscribeExactly(Class, EventSubscriber)
so that they are notified only if an
object of the exact class is published (and will not be notified if subclasses are published, since this would not
be "exact")
In topic-based pub/sub, an object "payload" is published on a topic name (String). EventTopicSubscriber
s subscribe
to either the exact name of the topic or they may subscribe using a Regular Expression that is used to match topic
names.
See the overview for an general introduction
and package documentation for usage details and examples.
A single subscriber cannot subscribe more than once to an event or topic name. EventService implementations should
handle double-subscription requests by returning false on subscribe(). A single EventSubscriber can subscribe to more
than one event class, and a single EventTopicSubscriber can subscribe to more than one topic name or pattern. A
single object may implement both EventSubscriber and EventTopicSubscriber interfaces. Subscribers are guaranteed to
only be called for the classes and/or topic names they subscribe to. If a subscriber subscribes to a topic and to a
regular expression that matches the topic name, this is considered two different subscriptions and the subscriber
will be called twice for the publication on the topic. Similarly, if a subscriber subscribes to a class and its
subclasses using subscribe() and again to a class of the same type using subscribeExactly(), this is considered two
different subscriptions and the subscriber will be called twice for the publication for a single event of the exact
type.
By default the EventService only holds WeakReferences to subscribers. If a subscriber has no references to it, then
it can be garbage collected. This avoids memory leaks in exchange for the risk of accidentally adding a listener and
have it disappear unexpectedly. If you want to subscribe a subscriber that will have no other reference to it, then
use one of the subscribeStrongly() methods, which will prevent garbage collection.
Unless garbage collected, EventSubscribers will remain subscribed until they are passed to one of the unsubscribe()
methods with the event class or topic name to which there are subscribed.
Subscribers are called in the order in which they are subscribed by default (FIFO), unless subscribers implement
Prioritized
. Those subscribers that implement Prioritized and return a negative priority are moved to the
front of the list (the more negative, the more to the front). Those subscribers that implement Prioritized and return
a positive priority are moved to the end of the list (the more positive, the more to the back). The FIFO guarantee
is only valid for the same subscribe() call. That is, the order of two subscribers, one to List.class and the other
to ArrayList.class is not guaranteed to be in the order of subscription when an ArrayList is published. The same is
true for topic subscribers when using RegEx expressions - when "Foo" is published, the order of subscribers that are
subscribed to "Foo", "Fo*" and "F*" are not guaranteed, though the second "Fo*" subscriber will never be called
before the first "Fo*" subscriber (ditto List and ArrayList). Prioritized subscribers are always guaranteed to be in
the order of priority, no matter the call or the resulting mix of subscribers. All ordering rules apply to all
types subscribers: class, topic, pattern, veto, etc. For Swing users, note that FIFO is
the opposite of Swing, where event listeners are called in the reverse order of when they were subscribed (FILO).
Publication on a class or topic name can be vetoed by a VetoEventListener
. All VetoEventListeners are checked
before any EventSubscribers or EventTopicSubscribers are called. This is unlike the JavaBean's
VetoPropertyEventListener which can leave side effects and half-propogated events. VetoEventListeners are subscribed
in the same manner as EventSubscribers and EventTopicSubscribers.
The state of a published event can be tracked if an event or a topic's payload object implements the
PublicationStatus
interface. EventServices are required to set such objects'
PublicationStatus
at the appropriate times during publication.
This simple example prints "Hello World"
EventService eventService = new ThreadSafeEventService(); //Create a subscriber EventTopicSubscriber subscriber = new EventTopicSubscriber() { public void onEvent(String topic, Object event) { System.out.println(topic+" "+event); } }); eventService.subscribe("Hello", subscriber); eventService.publish("Hello", "World"); System.out.println(subscriber + " Since the reference is used after it is subscribed, it doesn't get garbage collected, this is not necessary if you use subscribeStrongly()");Events and/or topic data can be cached, but are not by default. To cache events or topic data, call
setDefaultCacheSizePerClassOrTopic(int)
, setCacheSizeForEventClass(Class, int)
, or
setCacheSizeForTopic(String, int)
, setCacheSizeForTopic(Pattern, int)
. Retrieve cached values
with getLastEvent(Class)
, getLastTopicData(String)
, getCachedEvents(Class)
, or
getCachedTopicData(String)
. Using caching while subscribing is most likely to make sense only if you
subscribe and publish on the same thread (so caching is very useful for Swing applications since both happen on
the EDT in a single-threaded manner). In multithreaded applications, you never know if your subscriber has handled
an event while it was being subscribed (before the subscribe() method returned) that is newer or older than the
retrieved cached value (taken before or after subscribe() respectively).
There is nothing special about the term "Event," this could just as easily be called a "Message" Service, this term
is already taken by the JMS, which is similar, but is used across processes and networks.ThreadSafeEventService} for the default implementation
,
SwingEventService} for the Swing-safe implementation
,
EventBus} for simple access to the Swing-safe implementation
,
org.bushe.swing.event.annotation.EventSubscriber} for subscription annotations
,
org.bushe.swing.event.annotation.EventTopicSubscriber} for subscription annotations
Modifier and Type | Method and Description |
---|---|
void |
clearAllSubscribers()
Clears all current subscribers and veto subscribers
|
void |
clearCache()
Clear all event caches for all topics and event.
|
void |
clearCache(Class eventClass)
Clears the event cache for a specific event class or interface and it's any of it's subclasses or implementing
classes.
|
void |
clearCache(Pattern pattern)
Clears the topic data cache for all topics that match a particular pattern.
|
void |
clearCache(String topic)
Clears the topic data cache for a specific topic name.
|
<T> List<T> |
getCachedEvents(Class<T> eventClass)
When caching, returns the last set of event published for the type supplied.
|
List |
getCachedTopicData(String topic)
When caching, returns the last set of payload objects published on the topic name supplied.
|
int |
getCacheSizeForEventClass(Class eventClass)
Returns the number of events cached for a particular class of event.
|
int |
getCacheSizeForTopic(String topic)
Returns the number of cached data objects published on a particular topic.
|
int |
getDefaultCacheSizePerClassOrTopic()
The default number of events or payloads kept per event class or topic
|
<T> T |
getLastEvent(Class<T> eventClass)
When caching, returns the last event publish for the type supplied.
|
Object |
getLastTopicData(String topic)
When caching, returns the last payload published on the topic name supplied.
|
<T> List<T> |
getSubscribers(Class<T> eventClass)
Union of getSubscribersToClass(Class) and getSubscribersToExactClass(Class)
|
<T> List<T> |
getSubscribers(Pattern pattern)
Gets the subscribers that subscribed to a regular expression.
|
<T> List<T> |
getSubscribers(String topic)
Union of getSubscribersByPattern(String) and geSubscribersToTopic(String)
|
<T> List<T> |
getSubscribers(Type type)
Gets the subscribers that subscribed to a generic type.
|
<T> List<T> |
getSubscribersByPattern(String topic)
Gets the subscribers that subscribed with a Pattern that matches the given topic.
|
<T> List<T> |
getSubscribersToClass(Class<T> eventClass)
Gets subscribers that subscribed with the given a class, but not those subscribed exactly to the class.
|
<T> List<T> |
getSubscribersToExactClass(Class<T> eventClass)
Gets subscribers that are subscribed exactly to a class, but not those subscribed non-exactly to a class.
|
<T> List<T> |
getSubscribersToTopic(String topic)
Get the subscribers that subscribed to a topic.
|
<T> List<T> |
getVetoEventListeners(String topicOrPattern)
Union of
getVetoSubscribersToTopic(String) and getVetoSubscribersByPattern(String)
Misnamed method, should be called getVetoSubscribers(String) . |
<T> List<T> |
getVetoSubscribers(Class<T> eventClass)
Gets veto subscribers that subscribed to a given class.
|
<T> List<T> |
getVetoSubscribers(Pattern pattern)
Gets the veto subscribers that subscribed to a regular expression.
|
<T> List<T> |
getVetoSubscribers(String topic)
Deprecated.
use getVetoSubscribersToTopic instead for direct replacement,
or use getVetoEventListeners to get topic and pattern matchers.
In EventBus 2.0 this name will replace getVetoEventListeners()
and have it's union functionality
|
<T> List<T> |
getVetoSubscribersByPattern(String topic)
Gets the veto subscribers that are subscribed by pattern that match the topic.
|
<T> List<T> |
getVetoSubscribersToClass(Class<T> eventClass)
Gets the veto subscribers that subscribed to a class.
|
<T> List<T> |
getVetoSubscribersToExactClass(Class<T> eventClass)
Get veto subscribers that subscribed to a given class exactly.
|
<T> List<T> |
getVetoSubscribersToTopic(String topic)
Gets the veto subscribers that subscribed to a topic.
|
void |
publish(Object event)
Publishes an object so that subscribers will be notified if they subscribed to the object's class, one of its
subclasses, or to one of the interfaces it implements.
|
void |
publish(String topic,
Object o)
Publishes an object on a topic name so that all subscribers to that name or a Regular Expression that matches
the topic name will be notified.
|
void |
publish(Type genericType,
Object event)
Use this method to publish generified objects to subscribers of Types, i.e.
|
void |
setCacheSizeForEventClass(Class eventClass,
int cacheSize)
Set the number of events cached for a particular class of event.
|
void |
setCacheSizeForTopic(Pattern pattern,
int cacheSize)
Set the number of published data objects cached for a topics matching a pattern.
|
void |
setCacheSizeForTopic(String topicName,
int cacheSize)
Set the number of published data objects cached for a particular event topic.
|
void |
setDefaultCacheSizePerClassOrTopic(int defaultCacheSizePerClassOrTopic)
Sets the default cache size for each kind of event, default is 0 (no caching).
|
boolean |
subscribe(Class eventClass,
EventSubscriber subscriber)
Subscribes an EventSubscriber to the publication of objects matching a type.
|
boolean |
subscribe(Pattern topicPattern,
EventTopicSubscriber subscriber)
Subscribes an EventSubscriber to the publication of all the topic names that match a RegEx Pattern.
|
boolean |
subscribe(String topic,
EventTopicSubscriber subscriber)
Subscribes an EventTopicSubscriber to the publication of a topic name.
|
boolean |
subscribe(Type type,
EventSubscriber subscriber)
Subscribe an EventSubscriber to publication of generic Types.
|
boolean |
subscribeExactly(Class eventClass,
EventSubscriber subscriber)
Subscribes an EventSubscriber to the publication of objects exactly matching a type.
|
boolean |
subscribeExactlyStrongly(Class eventClass,
EventSubscriber subscriber)
Subscribes an EventSubscriber to the publication of objects matching a type exactly.
|
boolean |
subscribeStrongly(Class eventClass,
EventSubscriber subscriber)
Subscribes an EventSubscriber to the publication of objects matching a type.
|
boolean |
subscribeStrongly(Pattern topicPattern,
EventTopicSubscriber subscriber)
Subscribes a subscriber to all the event topic names that match a RegEx expression.
|
boolean |
subscribeStrongly(String topic,
EventTopicSubscriber subscriber)
Subscribes a subscriber to an event topic name.
|
boolean |
subscribeVetoListener(Class eventClass,
VetoEventListener vetoListener)
Subscribes a VetoEventListener to publication of event matching a class.
|
boolean |
subscribeVetoListener(Pattern topicPattern,
VetoTopicEventListener vetoListener)
Subscribes an VetoTopicEventListener to all the topic names that match the RegEx Pattern.
|
boolean |
subscribeVetoListener(String topic,
VetoTopicEventListener vetoListener)
Subscribes a VetoTopicEventListener to a topic name.
|
boolean |
subscribeVetoListenerExactly(Class eventClass,
VetoEventListener vetoListener)
Subscribes a VetoEventListener to publication of an exact event class.
|
boolean |
subscribeVetoListenerExactlyStrongly(Class eventClass,
VetoEventListener vetoListener)
Subscribes a VetoEventListener for an event class (but not its subclasses).
|
boolean |
subscribeVetoListenerStrongly(Class eventClass,
VetoEventListener vetoListener)
Subscribes a VetoEventListener for an event class and its subclasses.
|
boolean |
subscribeVetoListenerStrongly(Pattern topicPattern,
VetoTopicEventListener vetoListener)
Subscribes a VetoTopicEventListener to a set of topics that match a RegEx expression.
|
boolean |
subscribeVetoListenerStrongly(String topic,
VetoTopicEventListener vetoListener)
Subscribes a VetoEventListener to a topic name.
|
boolean |
unsubscribe(Class eventClass,
EventSubscriber subscriber)
Stop the subscription for a subscriber that is subscribed to a class.
|
boolean |
unsubscribe(Class eventClass,
Object subscribedByProxy)
Stop a subscription for an object that is subscribed with a ProxySubscriber.
|
boolean |
unsubscribe(Pattern topicPattern,
EventTopicSubscriber subscriber)
Stop the subscription for a subscriber that is subscribed to event topics via a Pattern.
|
boolean |
unsubscribe(Pattern pattern,
Object subscribedByProxy)
When using annotations, an object may be subscribed by proxy.
|
boolean |
unsubscribe(String topic,
EventTopicSubscriber subscriber)
Stop the subscription for a subscriber that is subscribed to an event topic.
|
boolean |
unsubscribe(String topic,
Object subscribedByProxy)
Stop a subscription for an object that is subscribed to a topic with a ProxySubscriber.
|
boolean |
unsubscribeExactly(Class eventClass,
EventSubscriber subscriber)
Stop the subscription for a subscriber that is subscribed to an exact class.
|
boolean |
unsubscribeExactly(Class eventClass,
Object subscribedByProxy)
Stop a subscription for an object that is subscribed exactly with a ProxySubscriber.
|
boolean |
unsubscribeVeto(Class eventClass,
Object subscribedByProxy)
Stop a veto subscription for an object that is subscribed with a ProxySubscriber.
|
boolean |
unsubscribeVeto(Pattern pattern,
Object subscribedByProxy)
When using annotations, an object may be subscribed by proxy.
|
boolean |
unsubscribeVeto(String topic,
Object subscribedByProxy)
Stop a veto subscription for an object that is subscribed to a topic with a ProxySubscriber.
|
boolean |
unsubscribeVetoExactly(Class eventClass,
Object subscribedByProxy)
Stop a veto subscription for an object that is subscribed exactly with a ProxySubscriber.
|
boolean |
unsubscribeVetoListener(Class eventClass,
VetoEventListener vetoListener)
Stop the subscription for a vetoListener that is subscribed to an event class and its subclasses.
|
boolean |
unsubscribeVetoListener(Pattern topicPattern,
VetoTopicEventListener vetoListener)
Stop the subscription for a VetoTopicEventListener that is subscribed to an event topic RegEx pattern.
|
boolean |
unsubscribeVetoListener(String topic,
VetoTopicEventListener vetoListener)
Stop the subscription for a VetoTopicEventListener that is subscribed to an event topic name.
|
boolean |
unsubscribeVetoListenerExactly(Class eventClass,
VetoEventListener vetoListener)
Stop the subscription for a vetoListener that is subscribed to an event class (but not its subclasses).
|
void publish(Object event)
event
- the object to publishvoid publish(Type genericType, Object event)
subscribe(Type, EventSubscriber)
, and to publish to subscribers of the non-generic type.
Due to generic type erasure, the type must be supplied by the caller. You can get a declared object's
type by using the TypeReference
class. For Example:
TypeReference<List<Trade>> subscribingTypeReference = new TypeReference<List<Trade>>(){}; EventBus.subscribe(subscribingTypeReference.getType(), mySubscriber); EventBus.subscribe(List.class, thisSubscriberWillGetCalledToo); ... //Likely in some other class TypeReference<List<Trade>> publishingTypeReference = new TypeReference<List<Trade>>(){}; List<Trade> trades = new ArrayList<Trade>(); EventBus.publish(publishingTypeReference.getType(), trades); trades.add(trade); EventBus.publish(publishingTypeReference.getType(), trades);
genericType
- the generified type of the published object.event
- The event that occurredvoid publish(String topic, Object o)
topic
- The name of the topic subscribed too
- the object to publishboolean subscribe(Class eventClass, EventSubscriber subscriber)
eventClass
- the class of published objects to subscriber listen tosubscriber
- The subscriber that will accept the events of the event class when published.boolean subscribe(Type type, EventSubscriber subscriber)
publish(java.lang.reflect.Type, Object)
.
Due to generic type erasure, the type must be supplied by the publisher. You can get a declared object's
type by using the TypeReference
class. For Example:
TypeReference<List<Trade>> subscribingTypeReference = new TypeReference<List<Trade>>(){}; EventBus.subscribe(subscribingTypeReference.getType(), mySubscriber); EventBus.subscribe(List.class, thisSubscriberWillGetCalledToo); ... //Likely in some other class TypeReference<List<Trade>> publishingTypeReference = new TypeReference<List<Trade>>(){}; List<Trade> trades = new ArrayList<Trade>(); EventBus.publish(publishingTypeReference.getType(), trades); trades.add(trade); EventBus.publish(publishingTypeReference.getType(), trades);
type
- the generic type to subscribe tosubscriber
- the subscriber to the typeboolean subscribeExactly(Class eventClass, EventSubscriber subscriber)
eventClass
- the class of published objects to listen tosubscriber
- The subscriber that will accept the events when published.boolean subscribe(String topic, EventTopicSubscriber subscriber)
topic
- the name of the topic listened tosubscriber
- The topic subscriber that will accept the events when published.boolean subscribe(Pattern topicPattern, EventTopicSubscriber subscriber)
topicPattern
- pattern that matches to the name of the topic published tosubscriber
- The topic subscriber that will accept the events when published.boolean subscribeStrongly(Class eventClass, EventSubscriber subscriber)
subscribe(Class, EventSubscriber)
, except that the EventService holds
a regularly reference, not a WeakReference.
The subscriber will remain subscribed until unsubscribe(Class,EventSubscriber)
is called.eventClass
- the class of published objects to listen tosubscriber
- The subscriber that will accept the events when published.boolean subscribeExactlyStrongly(Class eventClass, EventSubscriber subscriber)
subscribeExactly(Class, EventSubscriber)
, except that the EventService
holds a regularly reference, not a WeakReference.
The subscriber will remain subscribed until unsubscribe(Class,EventSubscriber)
is called.eventClass
- the class of published objects to listen tosubscriber
- The subscriber that will accept the events when published.boolean subscribeStrongly(String topic, EventTopicSubscriber subscriber)
subscribe(String, EventTopicSubscriber)
, except that the EventService
holds a regularly reference, not a WeakReference.
The subscriber will remain subscribed until unsubscribe(String,EventTopicSubscriber)
is called.topic
- the name of the topic listened tosubscriber
- The topic subscriber that will accept the events when published.boolean subscribeStrongly(Pattern topicPattern, EventTopicSubscriber subscriber)
subscribe(java.util.regex.Pattern, EventTopicSubscriber)
, except that the
EventService holds a regularly reference, not a WeakReference.
The subscriber will remain subscribed until unsubscribe(String,EventTopicSubscriber)
is called.topicPattern
- the name of the topic listened tosubscriber
- The topic subscriber that will accept the events when published.boolean unsubscribe(Class eventClass, EventSubscriber subscriber)
eventClass
- the class of published objects to listen tosubscriber
- The subscriber that is subscribed to the event. The same reference as the one subscribed.boolean unsubscribeExactly(Class eventClass, EventSubscriber subscriber)
eventClass
- the class of published objects to listen tosubscriber
- The subscriber that is subscribed to the event. The same reference as the one subscribed.boolean unsubscribe(String topic, EventTopicSubscriber subscriber)
topic
- the topic listened tosubscriber
- The subscriber that is subscribed to the topic. The same reference as the one subscribed.boolean unsubscribe(Pattern topicPattern, EventTopicSubscriber subscriber)
topicPattern
- the regex expression matching topics listened tosubscriber
- The subscriber that is subscribed to the topic. The same reference as the one subscribed.boolean subscribeVetoListener(Class eventClass, VetoEventListener vetoListener)
eventClass
- the class of published objects that can be vetoedvetoListener
- The VetoEventListener that can determine whether an event is published.boolean subscribeVetoListenerExactly(Class eventClass, VetoEventListener vetoListener)
eventClass
- the class of published objects that can be vetoedvetoListener
- The vetoListener that can determine whether an event is published.boolean subscribeVetoListener(String topic, VetoTopicEventListener vetoListener)
topic
- the name of the topic listened tovetoListener
- The vetoListener that can determine whether an event is published.boolean subscribeVetoListener(Pattern topicPattern, VetoTopicEventListener vetoListener)
topicPattern
- the RegEx pattern to match topics withvetoListener
- The vetoListener that can determine whether an event is published.boolean subscribeVetoListenerStrongly(Class eventClass, VetoEventListener vetoListener)
unsubscribeVetoListener(Class,VetoEventListener)
is
called.eventClass
- the class of published objects to listen tovetoListener
- The vetoListener that will accept the events when published.boolean subscribeVetoListenerExactlyStrongly(Class eventClass, VetoEventListener vetoListener)
unsubscribeVetoListener(Class,VetoEventListener)
is
called.eventClass
- the class of published objects to listen tovetoListener
- The vetoListener that will accept the events when published.boolean subscribeVetoListenerStrongly(String topic, VetoTopicEventListener vetoListener)
unsubscribeVetoListener(String,VetoTopicEventListener)
is
called.topic
- the name of the topic listened tovetoListener
- The topic vetoListener that will accept or reject publication.subscribeVetoListenerStrongly(Class,VetoEventListener)
boolean subscribeVetoListenerStrongly(Pattern topicPattern, VetoTopicEventListener vetoListener)
unsubscribeVetoListener(Pattern,VetoTopicEventListener)
is
called.topicPattern
- the RegEx pattern that matches the name of the topics listened tovetoListener
- The topic vetoListener that will accept or reject publication.subscribeVetoListenerStrongly(Pattern,VetoTopicEventListener)
boolean unsubscribeVetoListener(Class eventClass, VetoEventListener vetoListener)
eventClass
- the class of published objects that can be vetoedvetoListener
- The vetoListener that will accept or reject publication of an event.boolean unsubscribeVetoListenerExactly(Class eventClass, VetoEventListener vetoListener)
eventClass
- the class of published objects that can be vetoedvetoListener
- The vetoListener that will accept or reject publication of an event.boolean unsubscribeVetoListener(String topic, VetoTopicEventListener vetoListener)
topic
- the name of the topic that is listened tovetoListener
- The vetoListener that can determine whether an event is published on that topicboolean unsubscribeVetoListener(Pattern topicPattern, VetoTopicEventListener vetoListener)
topicPattern
- the RegEx pattern matching the name of the topics listened tovetoListener
- The vetoListener that can determine whether an event is published on that topic<T> List<T> getSubscribers(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getSubscribersToClass(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getSubscribersToExactClass(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getSubscribers(Type type)
type
- the type of interest<T> List<T> getSubscribers(String topic)
topic
- the topic of interest<T> List<T> getSubscribersToTopic(String topic)
topic
- the topic of interest<T> List<T> getSubscribers(Pattern pattern)
pattern
- the RegEx pattern that was subscribed to<T> List<T> getSubscribersByPattern(String topic)
topic
- a topic to match Patterns against<T> List<T> getVetoSubscribers(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getVetoSubscribersToExactClass(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getVetoSubscribersToClass(Class<T> eventClass)
eventClass
- the eventClass of interest<T> List<T> getVetoEventListeners(String topicOrPattern)
getVetoSubscribersToTopic(String)
and getVetoSubscribersByPattern(String)
Misnamed method, should be called getVetoSubscribers(String)
. Will be deprecated in 1.5.topicOrPattern
- the topic or pattern of interest<T> List<T> getVetoSubscribersToTopic(String topic)
topic
- the topic of interest<T> List<T> getVetoSubscribers(Pattern pattern)
pattern
- the RegEx pattern for the topic of interest<T> List<T> getVetoSubscribersByPattern(String topic)
topic
- the topic to match the pattern string subscribed to<T> List<T> getVetoSubscribers(String topic)
getVetoSubscribersToTopic(String)
.
Out of sync with getSubscribers(String)
.topic
- the topic exactly subscribed tovoid clearAllSubscribers()
void setDefaultCacheSizePerClassOrTopic(int defaultCacheSizePerClassOrTopic)
defaultCacheSizePerClassOrTopic
- the cache size per eventint getDefaultCacheSizePerClassOrTopic()
void setCacheSizeForEventClass(Class eventClass, int cacheSize)
eventClass
- the class of eventcacheSize
- the number of published events to cache for this eventint getCacheSizeForEventClass(Class eventClass)
eventClass
- the class of eventsetCacheSizeForEventClass(Class,int)
void setCacheSizeForTopic(String topicName, int cacheSize)
topicName
- the topic namecacheSize
- the number of published data Objects to cache for this topicvoid setCacheSizeForTopic(Pattern pattern, int cacheSize)
pattern
- the pattern matching topic namescacheSize
- the number of data Objects to cache for this topicint getCacheSizeForTopic(String topic)
topic
- the topic namesetCacheSizeForTopic(String,int)
,
setCacheSizeForTopic(java.util.regex.Pattern,int)
<T> T getLastEvent(Class<T> eventClass)
eventClass
- an index into the cache<T> List<T> getCachedEvents(Class<T> eventClass)
eventClass
- an index into the cacheObject getLastTopicData(String topic)
topic
- an index into the cacheList getCachedTopicData(String topic)
topic
- an index into the cachevoid clearCache(Class eventClass)
eventClass
- the event class to clear the cache forvoid clearCache(String topic)
topic
- the topic name to clear the cache forvoid clearCache(Pattern pattern)
pattern
- the pattern to match topic caches tovoid clearCache()
boolean unsubscribe(Class eventClass, Object subscribedByProxy)
eventClass
- class this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribeExactly(Class eventClass, Object subscribedByProxy)
eventClass
- class this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribe(String topic, Object subscribedByProxy)
topic
- the topic this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribe(Pattern pattern, Object subscribedByProxy)
pattern
- the RegEx expression this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribeVeto(Class eventClass, Object subscribedByProxy)
eventClass
- class this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribeVetoExactly(Class eventClass, Object subscribedByProxy)
eventClass
- class this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribeVeto(String topic, Object subscribedByProxy)
topic
- the topic this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyboolean unsubscribeVeto(Pattern pattern, Object subscribedByProxy)
pattern
- the RegEx expression this object is subscribed to by proxysubscribedByProxy
- object subscribed by proxyCopyright © 2013 Bushe Enterprises, Inc.. All Rights Reserved.