001    /**
002     * Copyright (c) 2000-2011 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            public void addDestinationEventListener(
031                    DestinationEventListener destinationEventListener) {
032    
033                    _destinationEventListeners.add(destinationEventListener);
034            }
035    
036            public void afterPropertiesSet() {
037                    if (Validator.isNull(name)) {
038                            throw new IllegalArgumentException("Name is null");
039                    }
040    
041                    open();
042            }
043    
044            public void close() {
045                    close(false);
046            }
047    
048            public void close(boolean force) {
049            }
050    
051            public void copyDestinationEventListeners(Destination destination) {
052                    for (DestinationEventListener destinationEventListener :
053                                    _destinationEventListeners) {
054    
055                            destination.addDestinationEventListener(
056                                    destinationEventListener);
057                    }
058            }
059    
060            public void copyMessageListeners(Destination destination) {
061                    for (MessageListener messageListener : messageListeners) {
062                            InvokerMessageListener invokerMessageListener =
063                                    (InvokerMessageListener)messageListener;
064    
065                            destination.register(
066                                    invokerMessageListener.getMessageListener(),
067                                    invokerMessageListener.getClassLoader());
068                    }
069            }
070    
071            public int getMessageListenerCount() {
072                    return messageListeners.size();
073            }
074    
075            public Set<MessageListener> getMessageListeners() {
076                    return Collections.unmodifiableSet(messageListeners);
077            }
078    
079            public String getName() {
080                    return name;
081            }
082    
083            public boolean isRegistered() {
084                    if (getMessageListenerCount() > 0) {
085                            return true;
086                    }
087                    else {
088                            return false;
089                    }
090            }
091    
092            public void open() {
093            }
094    
095            public boolean register(MessageListener messageListener) {
096                    InvokerMessageListener invokerMessageListener =
097                            new InvokerMessageListener(messageListener);
098    
099                    return registerMessageListener(invokerMessageListener);
100            }
101    
102            public boolean register(
103                    MessageListener messageListener, ClassLoader classloader) {
104    
105                    InvokerMessageListener invokerMessageListener =
106                            new InvokerMessageListener(messageListener, classloader);
107    
108                    return registerMessageListener(invokerMessageListener);
109            }
110    
111            public void removeDestinationEventListener(
112                    DestinationEventListener destinationEventListener) {
113    
114                    _destinationEventListeners.remove(destinationEventListener);
115            }
116    
117            public void removeDestinationEventListeners() {
118                    _destinationEventListeners.clear();
119            }
120    
121            public void setName(String name) {
122                    this.name = name;
123            }
124    
125            public boolean unregister(MessageListener messageListener) {
126                    InvokerMessageListener invokerMessageListener =
127                            new InvokerMessageListener(messageListener);
128    
129                    return unregisterMessageListener(invokerMessageListener);
130            }
131    
132            public boolean unregister(
133                    MessageListener messageListener, ClassLoader classloader) {
134    
135                    InvokerMessageListener invokerMessageListener =
136                            new InvokerMessageListener(messageListener, classloader);
137    
138                    return unregisterMessageListener(invokerMessageListener);
139            }
140    
141            public void unregisterMessageListeners() {
142                    for (MessageListener messageListener : messageListeners) {
143                            unregisterMessageListener((InvokerMessageListener)messageListener);
144                    }
145            }
146    
147            protected void fireMessageListenerRegisteredEvent(
148                    MessageListener messageListener) {
149    
150                    for (DestinationEventListener destinationEventListener :
151                                    _destinationEventListeners) {
152    
153                            destinationEventListener.messageListenerRegistered(
154                                    getName(), messageListener);
155                    }
156            }
157    
158            protected void fireMessageListenerUnregisteredEvent(
159                    MessageListener messageListener) {
160    
161                    for (DestinationEventListener listener : _destinationEventListeners) {
162                            listener.messageListenerUnregistered(getName(), messageListener);
163                    }
164            }
165    
166            protected boolean registerMessageListener(
167                    InvokerMessageListener invokerMessageListener) {
168    
169                    boolean registered = messageListeners.add(invokerMessageListener);
170    
171                    if (registered) {
172                            fireMessageListenerRegisteredEvent(
173                                    invokerMessageListener.getMessageListener());
174                    }
175    
176                    return registered;
177            }
178    
179            protected boolean unregisterMessageListener(
180                    InvokerMessageListener invokerMessageListener) {
181    
182                    boolean unregistered = messageListeners.remove(invokerMessageListener);
183    
184                    if (unregistered) {
185                            fireMessageListenerUnregisteredEvent(
186                                    invokerMessageListener.getMessageListener());
187                    }
188    
189                    return unregistered;
190            }
191    
192            protected Set<MessageListener> messageListeners =
193                    new ConcurrentHashSet<MessageListener>();
194            protected String name = StringPool.BLANK;
195    
196            private Set<DestinationEventListener> _destinationEventListeners =
197                    new ConcurrentHashSet<DestinationEventListener>();
198    
199    }