AbstractEventPublisher.java
001 /*
002  * Copyright 2008-2016 the original author or authors.
003  *
004  * Licensed under the Apache License, Version 2.0 (the "License");
005  * you may not use this file except in compliance with the License.
006  * You may obtain a copy of the License at
007  *
008  *     http://www.apache.org/licenses/LICENSE-2.0
009  *
010  * Unless required by applicable law or agreed to in writing, software
011  * distributed under the License is distributed on an "AS IS" BASIS,
012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013  * See the License for the specific language governing permissions and
014  * limitations under the License.
015  */
016 package org.codehaus.griffon.runtime.core.event;
017 
018 import griffon.core.CallableWithArgs;
019 import griffon.core.RunnableWithArgs;
020 import griffon.core.event.Event;
021 import griffon.core.event.EventPublisher;
022 import griffon.core.event.EventRouter;
023 
024 import javax.annotation.Nonnull;
025 import javax.annotation.Nullable;
026 import javax.inject.Inject;
027 import java.util.Collection;
028 import java.util.List;
029 import java.util.Map;
030 
031 import static griffon.util.GriffonNameUtils.requireNonBlank;
032 import static java.util.Objects.requireNonNull;
033 
034 /**
035  @author Andres Almiray
036  @since 2.0.0
037  */
038 public abstract class AbstractEventPublisher implements EventPublisher {
039     private static final String ERROR_EVENT_NAME_BLANK = "Argument 'eventName' must not be blank";
040     private static final String ERROR_LISTENER_NULL = "Argument 'listener' must not be null";
041     private static final String ERROR_EVENT_CLASS_NULL = "Argument 'eventClass' must not be null";
042     private static final String ERROR_EVENT_NULL = "Argument 'event' must not be null";
043 
044     private EventRouter eventRouter;
045 
046     @Inject
047     public void setEventRouter(@Nonnull EventRouter eventRouter) {
048         this.eventRouter = requireNonNull(eventRouter, "Argument 'eventRouter' must not be null");
049     }
050 
051     @Override
052     public boolean isEventPublishingEnabled() {
053         return eventRouter.isEventPublishingEnabled();
054     }
055 
056     @Override
057     public void setEventPublishingEnabled(boolean enabled) {
058         eventRouter.setEventPublishingEnabled(enabled);
059     }
060 
061     @Override
062     public <E extends Event> void removeEventListener(@Nonnull Class<E> eventClass, @Nonnull CallableWithArgs<?> listener) {
063         requireNonNull(eventClass, ERROR_EVENT_CLASS_NULL);
064         requireNonNull(listener, ERROR_LISTENER_NULL);
065         eventRouter.removeEventListener(eventClass, listener);
066     }
067 
068     @Override
069     public <E extends Event> void removeEventListener(@Nonnull Class<E> eventClass, @Nonnull RunnableWithArgs listener) {
070         requireNonNull(eventClass, ERROR_EVENT_CLASS_NULL);
071         requireNonNull(listener, ERROR_LISTENER_NULL);
072         eventRouter.removeEventListener(eventClass, listener);
073     }
074 
075     @Override
076     public void addEventListener(@Nonnull Object listener) {
077         requireNonNull(listener, ERROR_LISTENER_NULL);
078         eventRouter.addEventListener(listener);
079     }
080 
081     @Override
082     public void addEventListener(@Nonnull String eventName, @Nonnull CallableWithArgs<?> listener) {
083         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
084         requireNonNull(listener, ERROR_LISTENER_NULL);
085         eventRouter.addEventListener(eventName, listener);
086     }
087 
088     @Override
089     public void addEventListener(@Nonnull String eventName, @Nonnull RunnableWithArgs listener) {
090         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
091         requireNonNull(listener, ERROR_LISTENER_NULL);
092         eventRouter.addEventListener(eventName, listener);
093     }
094 
095     @Override
096     public void publishEvent(@Nonnull String eventName) {
097         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
098         eventRouter.publishEvent(eventName);
099     }
100 
101     @Override
102     public void publishEventOutsideUI(@Nonnull Event event) {
103         requireNonNull(event, ERROR_EVENT_NULL);
104         eventRouter.publishEventOutsideUI(event);
105     }
106 
107     @Override
108     public void removeEventListener(@Nonnull Map<String, Object> listener) {
109         requireNonNull(listener, ERROR_LISTENER_NULL);
110         eventRouter.removeEventListener(listener);
111     }
112 
113     @Override
114     public <E extends Event> void addEventListener(@Nonnull Class<E> eventClass, @Nonnull CallableWithArgs<?> listener) {
115         requireNonNull(eventClass, ERROR_EVENT_CLASS_NULL);
116         requireNonNull(listener, ERROR_LISTENER_NULL);
117         eventRouter.addEventListener(eventClass, listener);
118     }
119 
120     @Override
121     public <E extends Event> void addEventListener(@Nonnull Class<E> eventClass, @Nonnull RunnableWithArgs listener) {
122         requireNonNull(eventClass, ERROR_EVENT_CLASS_NULL);
123         requireNonNull(listener, ERROR_LISTENER_NULL);
124         eventRouter.addEventListener(eventClass, listener);
125     }
126 
127     @Override
128     public void publishEventOutsideUI(@Nonnull String eventName) {
129         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
130         eventRouter.publishEventOutsideUI(eventName);
131     }
132 
133     @Override
134     public void publishEventOutsideUI(@Nonnull String eventName, @Nullable List<?> params) {
135         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
136         eventRouter.publishEventOutsideUI(eventName, params);
137     }
138 
139     @Override
140     public void publishEvent(@Nonnull String eventName, @Nullable List<?> params) {
141         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
142         eventRouter.publishEvent(eventName, params);
143     }
144 
145     @Override
146     public void publishEventAsync(@Nonnull String eventName, @Nullable List<?> params) {
147         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
148         eventRouter.publishEventAsync(eventName, params);
149     }
150 
151     @Override
152     public void removeEventListener(@Nonnull String eventName, @Nonnull CallableWithArgs<?> listener) {
153         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
154         requireNonNull(listener, ERROR_LISTENER_NULL);
155         eventRouter.removeEventListener(eventName, listener);
156     }
157 
158     @Override
159     public void removeEventListener(@Nonnull String eventName, @Nonnull RunnableWithArgs listener) {
160         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
161         requireNonNull(listener, ERROR_LISTENER_NULL);
162         eventRouter.removeEventListener(eventName, listener);
163     }
164 
165     @Override
166     public void removeEventListener(@Nonnull Object listener) {
167         requireNonNull(listener, ERROR_LISTENER_NULL);
168         eventRouter.removeEventListener(listener);
169     }
170 
171     @Override
172     public void addEventListener(@Nonnull Map<String, Object> listener) {
173         requireNonNull(listener, ERROR_LISTENER_NULL);
174         eventRouter.addEventListener(listener);
175     }
176 
177     @Override
178     public void publishEvent(@Nonnull Event event) {
179         requireNonNull(event, ERROR_EVENT_NULL);
180         eventRouter.publishEvent(event);
181     }
182 
183     @Override
184     public void publishEventAsync(@Nonnull String eventName) {
185         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
186         eventRouter.publishEventAsync(eventName);
187     }
188 
189     @Override
190     public void publishEventAsync(@Nonnull Event event) {
191         requireNonNull(event, ERROR_EVENT_NULL);
192         eventRouter.publishEventAsync(event);
193     }
194 
195     @Nonnull
196     @Override
197     public Collection<Object> getEventListeners() {
198         return eventRouter.getEventListeners();
199     }
200 
201     @Nonnull
202     @Override
203     public Collection<Object> getEventListeners(@Nonnull String eventName) {
204         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
205         requireNonBlank(eventName, ERROR_EVENT_NAME_BLANK);
206         return eventRouter.getEventListeners(eventName);
207     }
208 }