View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.log4j.plugins;
19  
20  import org.apache.log4j.spi.ComponentBase;
21  import org.apache.log4j.spi.LoggerRepository;
22  
23  import java.beans.PropertyChangeEvent;
24  import java.beans.PropertyChangeListener;
25  import java.beans.PropertyChangeSupport;
26  
27  
28  /**
29   * A convienent abstract class for plugin subclasses that implements
30   * the basic methods of the Plugin interface. Subclasses are required
31   * to implement the isActive(), activateOptions(), and shutdown()
32   * methods.
33   * <p></p>
34   * <p>Developers are not required to subclass PluginSkeleton to
35   * develop their own plugins (they are only required to implement the
36   * Plugin interface), but it provides a convenient base class to start
37   * from.
38   * <p></p>
39   * Contributors: Nicko Cadell
40   *
41   * @author Mark Womack (mwomack@apache.org)
42   * @author Paul Smith (psmith@apache.org)
43   */
44  public abstract class PluginSkeleton extends ComponentBase implements Plugin {
45      /**
46       * Name of this plugin.
47       */
48      protected String name = "plugin";
49  
50      /**
51       * Active state of plugin.
52       */
53      protected boolean active;
54  
55      /**
56       * This is a delegate that does all the PropertyChangeListener
57       * support.
58       */
59      private PropertyChangeSupport propertySupport =
60          new PropertyChangeSupport(this);
61  
62      /**
63       * Construct new instance.
64       */
65      protected PluginSkeleton() {
66          super();
67      }
68  
69      /**
70       * Gets the name of the plugin.
71       *
72       * @return String the name of the plugin.
73       */
74      public String getName() {
75          return name;
76      }
77  
78      /**
79       * Sets the name of the plugin and notifies
80       * PropertyChangeListeners of the change.
81       *
82       * @param newName the name of the plugin to set.
83       */
84      public void setName(final String newName) {
85          String oldName = this.name;
86          this.name = newName;
87          propertySupport.firePropertyChange("name", oldName, this.name);
88      }
89  
90      /**
91       * Gets the logger repository for this plugin.
92       *
93       * @return LoggerRepository the logger repository this plugin will affect.
94       */
95      public LoggerRepository getLoggerRepository() {
96          return repository;
97      }
98  
99      /**
100      * Sets the logger repository used by this plugin and notifies a
101      * relevant PropertyChangeListeners registered. This
102      * repository will be used by the plugin functionality.
103      *
104      * @param repository the logger repository that this plugin should affect.
105      */
106     public void setLoggerRepository(final LoggerRepository repository) {
107         Object oldValue = this.repository;
108         this.repository = repository;
109         firePropertyChange("loggerRepository", oldValue, this.repository);
110     }
111 
112     /**
113      * Returns whether this plugin is Active or not.
114      *
115      * @return true/false
116      */
117     public synchronized boolean isActive() {
118         return active;
119     }
120 
121     /**
122      * Returns true if the plugin has the same name and logger repository as the
123      * testPlugin passed in.
124      *
125      * @param testPlugin The plugin to test equivalency against.
126      * @return Returns true if testPlugin is considered to be equivalent.
127      */
128     public boolean isEquivalent(final Plugin testPlugin) {
129         return (repository == testPlugin.getLoggerRepository())
130             && ((this.name == null && testPlugin.getName() == null)
131             || (this.name != null
132             && name.equals(testPlugin.getName())))
133             && this.getClass().equals(testPlugin.getClass());
134     }
135 
136     /**
137      * Add property change listener.
138      *
139      * @param listener listener.
140      */
141     public final void addPropertyChangeListener(
142         final PropertyChangeListener listener) {
143         propertySupport.addPropertyChangeListener(listener);
144     }
145 
146     /**
147      * Add property change listener for one property only.
148      *
149      * @param propertyName property name.
150      * @param listener     listener.
151      */
152     public final void addPropertyChangeListener(
153         final String propertyName,
154         final PropertyChangeListener listener) {
155         propertySupport.addPropertyChangeListener(propertyName, listener);
156     }
157 
158     /**
159      * Remove property change listener.
160      *
161      * @param listener listener.
162      */
163     public final void removePropertyChangeListener(
164         final PropertyChangeListener listener) {
165         propertySupport.removePropertyChangeListener(listener);
166     }
167 
168     /**
169      * Remove property change listener on a specific property.
170      *
171      * @param propertyName property name.
172      * @param listener     listener.
173      */
174     public final void removePropertyChangeListener(
175         final String propertyName,
176         final PropertyChangeListener listener) {
177         propertySupport.removePropertyChangeListener(propertyName, listener);
178     }
179 
180     /**
181      * Fire a property change event to appropriate listeners.
182      *
183      * @param evt change event.
184      */
185     protected final void firePropertyChange(
186         final PropertyChangeEvent evt) {
187         propertySupport.firePropertyChange(evt);
188     }
189 
190     /**
191      * Fire property change event to appropriate listeners.
192      *
193      * @param propertyName property name.
194      * @param oldValue     old value.
195      * @param newValue     new value.
196      */
197     protected final void firePropertyChange(
198         final String propertyName,
199         final boolean oldValue,
200         final boolean newValue) {
201         propertySupport.firePropertyChange(propertyName, oldValue, newValue);
202     }
203 
204     /**
205      * Fire property change event to appropriate listeners.
206      *
207      * @param propertyName property name.
208      * @param oldValue     old value.
209      * @param newValue     new value.
210      */
211     protected final void firePropertyChange(
212         final String propertyName,
213         final int oldValue, final int newValue) {
214         propertySupport.firePropertyChange(propertyName, oldValue, newValue);
215     }
216 
217     /**
218      * Fire property change event to appropriate listeners.
219      *
220      * @param propertyName property name.
221      * @param oldValue     old value.
222      * @param newValue     new value.
223      */
224     protected final void firePropertyChange(
225         final String propertyName,
226         final Object oldValue,
227         final Object newValue) {
228         propertySupport.firePropertyChange(propertyName, oldValue, newValue);
229     }
230 }