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 package org.apache.commons.configuration2.event;
18
19 import java.io.Serializable;
20 import java.util.HashSet;
21 import java.util.Set;
22
23 /**
24 * <p>
25 * A class representing an event type.
26 * </p>
27 * <p>
28 * The events produced by <em>Commons Configuration</em> all have a specific type. The event type can be used to
29 * determine the meaning of a specific event. It also acts as filter criterion when event listeners are registered. The
30 * listener is then called only for events of this type or derived types. The events in this library form a natural
31 * hierarchy with base types and more specialized types. By specifying an appropriate event type at listener
32 * registration time, it can be determined on a fine-granular basis which events are propagated to the listener.
33 * </p>
34 * <p>
35 * Note: Users familiar with JavaFX probably recognize this approach to event handling. It allows for generic event
36 * listener interfaces and a natural selection of events to be processed.
37 * </p>
38 *
39 * @param <T> the event associated with this type
40 * @since 2.0
41 */
42 public class EventType<T extends Event> implements Serializable {
43 /** Serial version UID. */
44 private static final long serialVersionUID = 20150416L;
45
46 /** Constant for the format used by toString(). */
47 private static final String FMT_TO_STRING = "%s [ %s ]";
48
49 /**
50 * Returns a set with all event types that are super types of the specified type. This set contains the direct and
51 * indirect super types and also includes the given type itself. The passed in type may be <strong>null</strong>, then an empty
52 * set is returned.
53 *
54 * @param eventType the event type in question
55 * @return a set with all super event types
56 */
57 public static Set<EventType<?>> fetchSuperEventTypes(final EventType<?> eventType) {
58 final Set<EventType<?>> types = new HashSet<>();
59 EventType<?> currentType = eventType;
60 while (currentType != null) {
61 types.add(currentType);
62 currentType = currentType.getSuperType();
63 }
64 return types;
65 }
66
67 /**
68 * Checks whether an event type is derived from another type. This implementation tests whether {@code baseType} is a
69 * direct or indirect super type of {@code derivedType}. If one of the types is <strong>null</strong>, result is <strong>false</strong>.
70 *
71 * @param derivedType the derived event type
72 * @param baseType the base event type
73 * @return <strong>true</strong> if the derived type is an instance of the base type, <strong>false</strong> otherwise
74 */
75 public static boolean isInstanceOf(final EventType<?> derivedType, final EventType<?> baseType) {
76 EventType<?> currentType = derivedType;
77 while (currentType != null) {
78 if (currentType == baseType) {
79 return true;
80 }
81 currentType = currentType.getSuperType();
82 }
83 return false;
84 }
85
86 /** Stores the super type of this type. */
87 private final EventType<? super T> superType;
88
89 /** A name for this event type. */
90 private final String name;
91
92 /**
93 * Creates a new instance of {@code EventType} and initializes it with the super type and a type name. If no super type
94 * is specified, this is the root event type.
95 *
96 * @param superEventType the super event type
97 * @param typeName the name of this event type
98 */
99 public EventType(final EventType<? super T> superEventType, final String typeName) {
100 superType = superEventType;
101 name = typeName;
102 }
103
104 /**
105 * Gets the name of this event type. The name has no specific semantic meaning. It is just used for debugging
106 * purposes and also part of the string representation of this event type.
107 *
108 * @return the event type name
109 */
110 public String getName() {
111 return name;
112 }
113
114 /**
115 * Gets the super event type. Result is <strong>null</strong> for the root event type.
116 *
117 * @return the super event type
118 */
119 public EventType<? super T> getSuperType() {
120 return superType;
121 }
122
123 /**
124 * Returns a string representation for this object. This method is mainly overridden for debugging purposes. The
125 * returned string contains the name of this event type.
126 *
127 * @return a string for this object
128 */
129 @Override
130 public String toString() {
131 return String.format(FMT_TO_STRING, getClass().getSimpleName(), getName());
132 }
133 }