001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.messaging;
016    
017    import com.liferay.portal.kernel.concurrent.ConcurrentHashSet;
018    import com.liferay.portal.kernel.util.StringPool;
019    import com.liferay.portal.kernel.util.Validator;
020    
021    import java.util.Collections;
022    import java.util.Set;
023    
024    /**
025     * @author Michael C. Han
026     * @author Shuyang Zhou
027     */
028    public abstract class BaseDestination implements Destination {
029    
030            @Override
031            public void addDestinationEventListener(
032                    DestinationEventListener destinationEventListener) {
033    
034                    _destinationEventListeners.add(destinationEventListener);
035            }
036    
037            public void afterPropertiesSet() {
038                    if (Validator.isNull(name)) {
039                            throw new IllegalArgumentException("Name is null");
040                    }
041    
042                    open();
043            }
044    
045            @Override
046            public void close() {
047                    close(false);
048            }
049    
050            @Override
051            public void close(boolean force) {
052            }
053    
054            @Override
055            public void copyDestinationEventListeners(Destination destination) {
056                    for (DestinationEventListener destinationEventListener :
057                                    _destinationEventListeners) {
058    
059                            destination.addDestinationEventListener(destinationEventListener);
060                    }
061            }
062    
063            @Override
064            public void copyMessageListeners(Destination destination) {
065                    for (MessageListener messageListener : messageListeners) {
066                            InvokerMessageListener invokerMessageListener =
067                                    (InvokerMessageListener)messageListener;
068    
069                            destination.register(
070                                    invokerMessageListener.getMessageListener(),
071                                    invokerMessageListener.getClassLoader());
072                    }
073            }
074    
075            @Override
076            public int getMessageListenerCount() {
077                    return messageListeners.size();
078            }
079    
080            @Override
081            public Set<MessageListener> getMessageListeners() {
082                    return Collections.unmodifiableSet(messageListeners);
083            }
084    
085            @Override
086            public String getName() {
087                    return name;
088            }
089    
090            @Override
091            public boolean isRegistered() {
092                    if (getMessageListenerCount() > 0) {
093                            return true;
094                    }
095                    else {
096                            return false;
097                    }
098            }
099    
100            @Override
101            public void open() {
102            }
103    
104            @Override
105            public boolean register(MessageListener messageListener) {
106                    InvokerMessageListener invokerMessageListener =
107                            new InvokerMessageListener(messageListener);
108    
109                    return registerMessageListener(invokerMessageListener);
110            }
111    
112            @Override
113            public boolean register(
114                    MessageListener messageListener, ClassLoader classloader) {
115    
116                    InvokerMessageListener invokerMessageListener =
117                            new InvokerMessageListener(messageListener, classloader);
118    
119                    return registerMessageListener(invokerMessageListener);
120            }
121    
122            @Override
123            public void removeDestinationEventListener(
124                    DestinationEventListener destinationEventListener) {
125    
126                    _destinationEventListeners.remove(destinationEventListener);
127            }
128    
129            @Override
130            public void removeDestinationEventListeners() {
131                    _destinationEventListeners.clear();
132            }
133    
134            public void setName(String name) {
135                    this.name = name;
136            }
137    
138            @Override
139            public boolean unregister(MessageListener messageListener) {
140                    InvokerMessageListener invokerMessageListener =
141                            new InvokerMessageListener(messageListener);
142    
143                    return unregisterMessageListener(invokerMessageListener);
144            }
145    
146            public boolean unregister(
147                    MessageListener messageListener, ClassLoader classloader) {
148    
149                    InvokerMessageListener invokerMessageListener =
150                            new InvokerMessageListener(messageListener, classloader);
151    
152                    return unregisterMessageListener(invokerMessageListener);
153            }
154    
155            @Override
156            public void unregisterMessageListeners() {
157                    for (MessageListener messageListener : messageListeners) {
158                            unregisterMessageListener((InvokerMessageListener)messageListener);
159                    }
160            }
161    
162            protected void fireMessageListenerRegisteredEvent(
163                    MessageListener messageListener) {
164    
165                    for (DestinationEventListener destinationEventListener :
166                                    _destinationEventListeners) {
167    
168                            destinationEventListener.messageListenerRegistered(
169                                    getName(), messageListener);
170                    }
171            }
172    
173            protected void fireMessageListenerUnregisteredEvent(
174                    MessageListener messageListener) {
175    
176                    for (DestinationEventListener listener : _destinationEventListeners) {
177                            listener.messageListenerUnregistered(getName(), messageListener);
178                    }
179            }
180    
181            protected boolean registerMessageListener(
182                    InvokerMessageListener invokerMessageListener) {
183    
184                    boolean registered = messageListeners.add(invokerMessageListener);
185    
186                    if (registered) {
187                            fireMessageListenerRegisteredEvent(
188                                    invokerMessageListener.getMessageListener());
189                    }
190    
191                    return registered;
192            }
193    
194            protected boolean unregisterMessageListener(
195                    InvokerMessageListener invokerMessageListener) {
196    
197                    boolean unregistered = messageListeners.remove(invokerMessageListener);
198    
199                    if (unregistered) {
200                            fireMessageListenerUnregisteredEvent(
201                                    invokerMessageListener.getMessageListener());
202                    }
203    
204                    return unregistered;
205            }
206    
207            protected Set<MessageListener> messageListeners =
208                    new ConcurrentHashSet<MessageListener>();
209            protected String name = StringPool.BLANK;
210    
211            private Set<DestinationEventListener> _destinationEventListeners =
212                    new ConcurrentHashSet<DestinationEventListener>();
213    
214    }