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