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