* Hidden Station: The hidden station is a pre-built station with "hidden.station" name that is used to hide the station abstraction. Helper method are provided by
* {@link DefaultEventStudio} where the station name parameter is missing from the parameters list and the {@link DefaultEventStudio#HIDDEN_STATION} is used, providing a more
* traditional event bus pub/sub pattern.
*
*
* @author Andrea Vacondio
*
*/
public class DefaultEventStudio implements EventStudio {
/**
* A reserved station name that is used to hide the station abstraction. Using the provided helper methods the station concept remains totally hidden and {@link EventStudio}
* can be used as a more traditional Event Bus with pub/sub pattern.
*/
public static final String HIDDEN_STATION = "hidden.station";
private Stations stations = new Stations();
public void add(Listener listener, String station, int priority, ReferenceStrength strength) {
stations.getStation(station).add(listener, priority, strength);
}
public void add(Listener listener, String station) {
add(listener, station, 0, ReferenceStrength.STRONG);
}
public void add(Class eventClass, Listener listener, String station) {
add(eventClass, listener, station, 0, ReferenceStrength.STRONG);
}
public void add(Class eventClass, Listener listener, String station, int priority,
ReferenceStrength strength) {
stations.getStation(station).add(eventClass, listener, priority, strength);
}
public void addAnnotatedListeners(Object bean) {
try {
ReflectiveMetadata metadata = Annotations.process(bean);
for (Entry> current : metadata.getDescriptors().entrySet()) {
String station = defaultString(metadata.getStation(), HIDDEN_STATION);
stations.getStation(defaultString(current.getKey(), station)).addAll(bean, current.getValue());
}
} catch (IllegalAccessException e) {
throw new EventStudioException("An error occurred processing the input bean", e);
} catch (InvocationTargetException e) {
throw new EventStudioException("An error occurred processing the input bean", e);
}
}
/**
* Adds a {@link Listener} (with the given priority and strength ) to the hidden station listening for the given event class, hiding the station abstraction.
*
* @see EventStudio#add(Listener, String, int, ReferenceStrength)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void add(Class eventClass, Listener listener, int priority, ReferenceStrength strength) {
add(eventClass, listener, HIDDEN_STATION, priority, strength);
}
/**
* Adds a {@link Listener} (with the given priority and strength ) to the hidden station, hiding the station abstraction.
*
* @see EventStudio#add(Listener, String, int, ReferenceStrength)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void add(Listener listener, int priority, ReferenceStrength strength) {
add(listener, HIDDEN_STATION, priority, strength);
}
/**
* Adds a {@link Listener} to the hidden station, hiding the station abstraction.
*
* @see EventStudio#add(Listener, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void add(Listener listener) {
add(listener, HIDDEN_STATION);
}
/**
* Adds a {@link Listener} to the hidden station listening for the given event class, hiding the station abstraction.
*
* @see EventStudio#add(Class, Listener, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void add(Class eventClass, Listener listener) {
add(eventClass, listener, HIDDEN_STATION);
}
/**
* Adds a {@link Supervisor} to the hidden station, hiding the station abstraction.
*
* @param supervisor
* @see EventStudio#supervisor(Supervisor, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void supervisor(Supervisor supervisor) {
supervisor(supervisor, HIDDEN_STATION);
}
public void supervisor(Supervisor supervisor, String station) {
requireNotNull(supervisor);
stations.getStation(station).supervior(supervisor);
}
public boolean remove(Listener listener, String station) {
return stations.getStation(station).remove(listener);
}
public boolean remove(Class eventClass, Listener listener, String station) {
return stations.getStation(station).remove(eventClass, listener);
}
/**
* Removes the given listener from the hidden station, hiding the station abstraction.
*
* @return true if the listener was found and removed
* @see EventStudio#remove(Listener, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public boolean remove(Listener listener) {
return remove(listener, HIDDEN_STATION);
}
/**
* Removes the given listener listening on the given event, from the hidden station, hiding the station abstraction.
*
* @return true if the listener was found and removed
* @see EventStudio#remove(Listener, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public boolean remove(Class eventClass, Listener listener) {
return remove(eventClass, listener, HIDDEN_STATION);
}
public void clear(String station) {
stations.clear(station);
}
/**
* Clears the hidden station
*
* @see EventStudio#clear(String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void clear() {
stations.clear(HIDDEN_STATION);
}
public void broadcast(Object event, String station) {
stations.getStation(station).broadcast(event);
}
/**
* Boradcast the event to the hidden station
*
* @see EventStudio#broadcast(Object, String)
* @see DefaultEventStudio#HIDDEN_STATION
*/
public void broadcast(Object event) {
stations.getStation(HIDDEN_STATION).broadcast(event);
}
public void broadcastToEveryStation(Object event) {
for (Station station : stations.getStations()) {
station.broadcast(event);
}
}
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/Entity.java 0000664 0000000 0000000 00000003570 13050600746 0025416 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 12/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
import static org.sejda.eventstudio.util.RequireUtils.requireNotNull;
import java.lang.ref.Reference;
/**
* Holder for an instance.
*
* @author Andrea Vacondio
* @param
* the type of the referent
*/
interface Entity {
/**
* @return the instance or null if nothing is available
*/
T get();
/**
* Holds an entity referenced using the input {@link Reference}
*
* @author Andrea Vacondio
*
* @param
*/
static class ReferencedEntity implements Entity {
private Reference reference;
ReferencedEntity(Reference reference) {
requireNotNull(reference);
this.reference = reference;
}
public T get() {
return reference.get();
}
}
/**
* A strongly referenced entity
*
* @author Andrea Vacondio
*
* @param
*/
static class StrongEntity implements Entity {
private T referent;
StrongEntity(T referent) {
this.referent = referent;
}
public T get() {
return referent;
}
}
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/Envelope.java 0000664 0000000 0000000 00000002646 13050600746 0025722 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 12/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
import static org.sejda.eventstudio.util.RequireUtils.requireNotNull;
/**
* Hold an event and the state of its notification
*
* @author Andrea Vacondio
*
*/
class Envelope {
private boolean notified = false;
private Object event;
Envelope(Object event) {
requireNotNull(event);
this.event = event;
}
/**
* @return true if some listeners has been notified
*/
public boolean isNotified() {
return notified;
}
public Object getEvent() {
return event;
}
/**
* set this event as notified
*/
public void notified() {
if (!notified) {
this.notified = true;
}
}
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/EventStudio.java 0000664 0000000 0000000 00000012220 13050600746 0026403 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 09/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
/**
* An {@link EventStudio} is a thread-safe central place allowing broadcast of events to {@link Listener}s to registered on a Station. Stations are created internally as soon as a
* listener is added but it's up to the user to clear a station when it's not needed anymore. {@link Listener}s can be added multiple times either to different or the same station
* and they will be called as many times as they have been added.
*
* As a general rule null parameters are not allowed (either station names, listeners, supervisors.. )
*
*
* @author Andrea Vacondio
*
*/
public interface EventStudio {
String MAX_QUEUE_SIZE_PROP = "eventstudio.max.queue.size";
/**
* Adds the given {@link Listener} to the given station using default priority(0) ad default strength {@link ReferenceStrength#STRONG}.
*/
void add(Listener listener, String station);
/**
* Adds the given {@link Listener} to the given station using the given priority (low values mean higher priority) and strength.
*/
void add(Listener listener, String station, int priority, ReferenceStrength strength);
/**
* Adds the given {@link Listener}, listening for the given event class, to the given station using default priority(0) ad default strength {@link ReferenceStrength#STRONG}.
* This add method is useful when a listener can listen for a hierarchy of events.
*
* @see EventStudio#add(Class, Listener, String, int, ReferenceStrength)
*/
void add(Class eventClass, Listener listener, String station);
/**
* Adds the given {@link Listener}, listening for the given event class, to the given station using the given priority (low values mean higher priority) and strength. This add
* method is useful when a listener can listen for a hierarchy of events:
*
*
* {@code
* class BroadListener{@code implements Listener} {
* void onEvent(ParentEvent e){
* LOG.debug(e);
* }
* }
*
* class X {
* public void init() {
* EventStudio studio = ....
* studio.add(ChildEvent.class, new BroadListener{@code }(), "mystation");
* studio.add(AnotherChildEvent.class, new BroadListener{@code ()}, "mystation");
* ...
* }
* }
*
* }
*
*/
void add(Class eventClass, Listener listener, String station, int priority, ReferenceStrength strength);
/**
* Discovers annotated method on the the given bean and adds them as {@link Listener}s
*
* @param bean
* @see org.sejda.eventstudio.annotation.EventListener
* @see org.sejda.eventstudio.annotation.EventStation
*/
void addAnnotatedListeners(Object bean);
/**
* Sets a {@link Supervisor} for the given station. It will be notified of every event broadcasted to the station prior its delivery to the proper {@link Listener}s allowing
* event inspection.
*
* {@link Supervisor}s cannot be removed but they can be replaces. See {@link Supervisor#SLACKER}
*
*/
void supervisor(Supervisor supervisor, String station);
/**
* Removes the first occurrence of the given {@link Listener} from the given station.
*
* @return true if the listener was successfully removed
*/
boolean remove(Listener listener, String station);
/**
* Removes the first occurrence of the given {@link Listener} listening for the given event, from the given station
*
* @return true if the listener was successfully removed
*/
boolean remove(Class eventClass, Listener listener, String station);
/**
* Clear the given station removing the whole station from the {@link EventStudio} which means that {@link Listener}s and {@link Supervisor} will not be notified anymore. A
* station with the same name can be recreated.
*/
void clear(String station);
/**
* Broadcasts the given event to the given station. {@link Listener}s listening the given station and bound to the event class will be notified.
*/
void broadcast(Object event, String station);
/**
* Broadcasts the given event to every station. {@link Listener}s bound to the event class (no matter the station they are listening) will be notified.
*/
void broadcastToEveryStation(Object event);
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/Listener.java 0000664 0000000 0000000 00000002042 13050600746 0025720 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 09/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
/**
* Listener for events of the generic type
*
* @author Andrea Vacondio
* @param
* type of the event the listener is interested in
*/
public interface Listener {
/**
* Notify the listener of the given event
*
* @param event
*/
void onEvent(T event);
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/Listeners.java 0000664 0000000 0000000 00000020767 13050600746 0026121 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 11/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
import static org.sejda.eventstudio.util.RequireUtils.requireNotNull;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.sejda.eventstudio.Annotations.ReflectiveListenerDescriptor;
import org.sejda.eventstudio.exception.BroadcastInterruptionException;
import org.sejda.eventstudio.exception.EventStudioException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A thread-safe holder for the listeners
*
* @author Andrea Vacondio
*
*/
class Listeners {
private static final Logger LOG = LoggerFactory.getLogger(Listeners.class);
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private Map, TreeSet> listeners = new HashMap, TreeSet>();
void add(Class eventClass, Listener listener, int priority, ReferenceStrength strength) {
lock.writeLock().lock();
try {
TreeSet set = nullSafeGetListenerHolders(eventClass);
set.add(new ListenerReferenceHolder(priority, strength.getReference(new DefaultListenerWrapper(listener))));
} finally {
lock.writeLock().unlock();
}
}
public Set> addAll(Object bean, List descriptors) {
Set> updatedEventClasses = new HashSet>();
lock.writeLock().lock();
try {
for (ReflectiveListenerDescriptor current : descriptors) {
Class eventClass = current.getMethod().getParameterTypes()[0];
TreeSet set = nullSafeGetListenerHolders(eventClass);
set.add(new ListenerReferenceHolder(current.getListenerAnnotation().priority(),
current.getListenerAnnotation().strength()
.getReference(new ReflectiveListenerWrapper(bean, current.getMethod()))));
updatedEventClasses.add(eventClass);
}
} finally {
lock.writeLock().unlock();
}
return updatedEventClasses;
}
private TreeSet nullSafeGetListenerHolders(Class eventClass) {
TreeSet set = listeners.get(eventClass);
if (set == null) {
set = new TreeSet();
listeners.put(eventClass, set);
}
return set;
}
/**
* Removes the listener if present. It also removes the listeners set from
* the map if the set is empty.
*
* @param eventClass
* @param listener
* @return true if the listener was present and has been removed
*/
boolean remove(Class eventClass, Listener listener) {
lock.readLock().lock();
TreeSet set = listeners.get(eventClass);
if (set != null) {
lock.readLock().unlock();
lock.writeLock().lock();
try {
DefaultListenerWrapper wrapper = new DefaultListenerWrapper(listener);
for (ListenerReferenceHolder current : set) {
if (wrapper.equals(current.getListenerWrapper())) {
return removeListenerAndSetIfNeeded(eventClass, current, set);
}
}
return false;
} finally {
lock.writeLock().unlock();
}
}
lock.readLock().unlock();
return false;
}
/**
* Removes the listener if present. It also removes the listeners set from
* the map if the set is empty.
*
* @param eventClass
* @param listener
* @return true if the listener was present and has been removed
*/
boolean remove(Class eventClass, ListenerReferenceHolder listener) {
lock.readLock().lock();
TreeSet set = listeners.get(eventClass);
if (set != null) {
lock.readLock().unlock();
lock.writeLock().lock();
try {
return removeListenerAndSetIfNeeded(eventClass, listener, set);
} finally {
lock.writeLock().unlock();
}
}
lock.readLock().unlock();
return false;
}
private boolean removeListenerAndSetIfNeeded(Class eventClass, ListenerReferenceHolder listener,
TreeSet set) {
if (set.remove(listener)) {
if (set.isEmpty()) {
listeners.remove(eventClass);
LOG.trace("Removed empty listeners set for {}", eventClass);
}
return true;
}
return false;
}
/**
* @param eventClass
* @return A sorted set containing the listeners queue for the given class.
*/
List nullSafeGetListeners(Class eventClass) {
requireNotNull(eventClass);
lock.readLock().lock();
try {
TreeSet set = listeners.get(eventClass);
if (set == null) {
return Collections.emptyList();
}
return new ArrayList(set);
} finally {
lock.readLock().unlock();
}
}
/**
* Wraps a listener defined either explicitly or picked up by the annotation
* processor
*
* @author Andrea Vacondio
*
*/
interface ListenerWrapper {
void onEvent(Envelope event);
}
/**
* Listener wrapper around an explicitly defined {@link Listener}
*
* @author Andrea Vacondio
*
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
private static final class DefaultListenerWrapper implements ListenerWrapper {
private Listener wrapped;
private DefaultListenerWrapper(Listener wrapped) {
this.wrapped = wrapped;
}
public void onEvent(Envelope event) {
wrapped.onEvent(event.getEvent());
event.notified();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((wrapped == null) ? 0 : wrapped.hashCode());
return result;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || !(o instanceof DefaultListenerWrapper)) {
return false;
}
DefaultListenerWrapper other = (DefaultListenerWrapper) o;
return wrapped.equals(other.wrapped);
}
}
/**
* Reflective invocation of an annotated listener
*
* @author Andrea Vacondio
*
*/
private static final class ReflectiveListenerWrapper implements ListenerWrapper {
private Object bean;
private Method method;
public ReflectiveListenerWrapper(Object bean, Method method) {
this.bean = bean;
this.method = method;
this.method.setAccessible(true);
}
public void onEvent(Envelope event) {
try {
method.invoke(bean, event.getEvent());
} catch (IllegalAccessException e) {
throw new EventStudioException("Exception invoking reflective method", e);
} catch (InvocationTargetException e) {
if (e.getCause() instanceof BroadcastInterruptionException) {
throw (BroadcastInterruptionException) e.getCause();
}
throw new EventStudioException("Reflective method invocation exception", e);
}
event.notified();
}
}
/**
* Holder for a {@link ListenerWrapper}
*
* @author Andrea Vacondio
*
*/
static class ListenerReferenceHolder implements Comparable {
int priority = 0;
private Entity reference;
public ListenerReferenceHolder(int priority, Entity reference) {
requireNotNull(reference);
this.priority = priority;
this.reference = reference;
}
public int compareTo(ListenerReferenceHolder o) {
if (this.priority < o.priority) {
return -1;
}
if (this.priority > o.priority) {
return 1;
}
// same priority
int retVal = this.hashCode() - o.hashCode();
// same hashcode but not equals. This shouldn't happen but according
// to hascode documentation is not required and since we don't want
// ListenerReferenceHolder to
// disappear from the TreeSet we return an arbitrary integer != from
// 0
if (retVal == 0 && !this.equals(o)) {
retVal = -1;
}
return retVal;
}
public ListenerWrapper getListenerWrapper() {
return reference.get();
}
}
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/ReferenceStrength.java 0000664 0000000 0000000 00000003151 13050600746 0027552 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 09/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
/**
* Possible reference strengths of the listeners
*
* @author Andrea Vacondio
*
*/
public enum ReferenceStrength {
STRONG {
@Override
Entity getReference(T referent) {
return new Entity.StrongEntity(referent);
}
},
SOFT {
@Override
Entity getReference(T referent) {
return new Entity.ReferencedEntity(new SoftReference(referent));
}
},
WEAK {
@Override
Entity getReference(T referent) {
return new Entity.ReferencedEntity(new WeakReference(referent));
}
};
/**
*
* @param referent
* @return the referent wrapped with the appropriate {@link Entity} instance.
*/
abstract Entity getReference(T referent);
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/StaticStudio.java 0000664 0000000 0000000 00000002517 13050600746 0026561 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 15/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
/**
* Singleton pattern providing lazy initialization.
*
* @author Andrea Vacondio
*
*/
public final class StaticStudio {
private StaticStudio() {
// hide
}
public static DefaultEventStudio eventStudio() {
return DefaultEventStudioHolder.STUDIO;
}
/**
* Lazy initialization
*
* @author Andrea Vacondio
*
*/
private static final class DefaultEventStudioHolder {
private DefaultEventStudioHolder() {
// hide constructor
}
static final DefaultEventStudio STUDIO = new DefaultEventStudio();
}
}
event-studio-v-1.0.6/src/main/java/org/sejda/eventstudio/Station.java 0000664 0000000 0000000 00000015771 13050600746 0025571 0 ustar 00root root 0000000 0000000 /*
* This file is part of the EventStudio source code
* Created on 09/nov/2013
* Copyright 2013 by Andrea Vacondio (andrea.vacondio@gmail.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sejda.eventstudio;
import static org.sejda.eventstudio.EventStudio.MAX_QUEUE_SIZE_PROP;
import static org.sejda.eventstudio.util.ReflectionUtils.inferParameterClass;
import static org.sejda.eventstudio.util.RequireUtils.requireNotBlank;
import static org.sejda.eventstudio.util.RequireUtils.requireNotNull;
import java.util.List;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.LinkedBlockingQueue;
import org.sejda.eventstudio.Annotations.ReflectiveListenerDescriptor;
import org.sejda.eventstudio.Listeners.ListenerReferenceHolder;
import org.sejda.eventstudio.Listeners.ListenerWrapper;
import org.sejda.eventstudio.exception.BroadcastInterruptionException;
import org.sejda.eventstudio.exception.EventStudioException;
import org.sejda.eventstudio.util.ReflectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A {@link Station} is a place where broadcaster events are actually transmitted to the registered {@link Listener}s
*
* @author Andrea Vacondio
*
*/
class Station {
private static final Logger LOG = LoggerFactory.getLogger(Station.class);
private ConcurrentMap, BlockingQueue