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 }
|