001 package org.apache.fulcrum.yaafi.framework.role;
002
003 import java.util.ArrayList;
004 import java.util.Collection;
005 import java.util.Iterator;
006
007 import org.apache.fulcrum.yaafi.framework.util.ToStringBuilder;
008 import org.apache.fulcrum.yaafi.framework.util.Validate;
009
010 /*
011 * Licensed to the Apache Software Foundation (ASF) under one
012 * or more contributor license agreements. See the NOTICE file
013 * distributed with this work for additional information
014 * regarding copyright ownership. The ASF licenses this file
015 * to you under the Apache License, Version 2.0 (the
016 * "License"); you may not use this file except in compliance
017 * with the License. You may obtain a copy of the License at
018 *
019 * http://www.apache.org/licenses/LICENSE-2.0
020 *
021 * Unless required by applicable law or agreed to in writing,
022 * software distributed under the License is distributed on an
023 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
024 * KIND, either express or implied. See the License for the
025 * specific language governing permissions and limitations
026 * under the License.
027 */
028
029
030 /**
031 * Interface exposed by the ServiceContainerImpl
032 *
033 * @author <a href="mailto:siegfried.goeschl@it20one.at">Siegfried Goeschl</a>
034 */
035
036 public class RoleEntryImpl implements RoleEntry
037 {
038 /** the name of the service component to be used for the service lookup */
039 private String name;
040
041 /** the name of the implementation class of the service component */
042 private String implementationClazzName;
043
044 /** the short name of the service component to lookup the configuration */
045 private String shorthand;
046
047 /** do we incarnate the instance of the service component during start-up? */
048 private boolean isEarlyInit;
049
050 /** a description for the service component if any */
051 private String description;
052
053 /** the type of service component, e.g. "avalon" */
054 private String componentType;
055
056 /** the type of service component if any, e.g. "merlin", "phoenix" or "fortress*/
057 private String componentFlavour;
058
059 /** do we use a dynamic proxy when invoking the service */
060 private boolean hasDynamicProxy;
061
062 /** the list of interceptors to be invoked when using a dynamic proxy */
063 private ArrayList interceptorList;
064
065 /** the optional category for creating a logger */
066 private String logCategory;
067
068 /**
069 * YAAFI role entry
070 *
071 * @param name the name of the service component to be used for the service lookup
072 * @param defaultClass the name of the implementation class of the service component
073 * @param shorthand the short name of the service component
074 * @param earlyInit do we incarnate the instance of the service component during start-up?
075 * @param description a description for the service component if any
076 * @param componentType the type of service component
077 * @param componentFlavour the flavour of the gicen component type
078 * @param hasProxy create a dynamic proxy
079 * @param interceptorList the list of service interceptor to be invoked
080 * @param logCategory the category for creating the logger
081 */
082 public RoleEntryImpl( String name,
083 String defaultClass,
084 String shorthand,
085 boolean earlyInit,
086 String description,
087 String componentType,
088 String componentFlavour,
089 boolean hasProxy,
090 ArrayList interceptorList,
091 String logCategory
092 )
093 {
094 Validate.notEmpty(name,"name");
095 Validate.notEmpty(defaultClass,"defaultClass");
096 Validate.notEmpty(shorthand,"shorthand");
097 Validate.notEmpty(componentType,"componentType");
098 Validate.notEmpty(componentFlavour,"componentFlavour");
099 Validate.notNull(interceptorList,"interceptorList");
100 Validate.notEmpty(logCategory,"logCategory");
101
102 this.name = name;
103 this.implementationClazzName = defaultClass;
104 this.shorthand = shorthand;
105 this.isEarlyInit = earlyInit;
106 this.description = description;
107 this.componentType = componentType;
108 this.componentFlavour = componentFlavour;
109 this.hasDynamicProxy = hasProxy;
110 this.interceptorList = interceptorList;
111 this.logCategory = logCategory;
112 }
113
114 /**
115 * @return Returns the componentType.
116 */
117 public String getComponentType()
118 {
119 return componentType;
120 }
121
122 /**
123 * @return Returns the description.
124 */
125 public String getDescription()
126 {
127 return description;
128 }
129
130 /**
131 * @return Returns the implementationClazzName.
132 */
133 public String getImplementationClazzName()
134 {
135 return implementationClazzName;
136 }
137
138 /**
139 * @return Returns the isEarlyInit.
140 */
141 public boolean isEarlyInit()
142 {
143 return isEarlyInit;
144 }
145
146 /**
147 * @return Returns the name.
148 */
149 public String getName()
150 {
151 return name;
152 }
153
154 /**
155 * @return Returns the shorthand.
156 */
157 public String getShorthand()
158 {
159 return shorthand;
160 }
161
162 /**
163 * @return Returns the componentFlavour.
164 */
165 public String getComponentFlavour()
166 {
167 return componentFlavour;
168 }
169
170 /**
171 * @return Returns the hasDynamicProxy.
172 */
173 public boolean hasDynamicProxy()
174 {
175 return hasDynamicProxy;
176 }
177
178 /**
179 * @param hasProxy The hasDynamicProxy to set.
180 */
181 public void setHasDynamicProxy(boolean hasProxy)
182 {
183 this.hasDynamicProxy = hasProxy;
184 }
185
186 /**
187 * Determines if the given name of the interceptor is already defined.
188 *
189 * @param interceptorName the name of the interceptor
190 * @return true if it is already defined
191 */
192 public boolean hasInterceptor( String interceptorName )
193 {
194 String currInterceptorName = null;
195 Iterator iterator = this.interceptorList.iterator();
196
197 while( iterator.hasNext() )
198 {
199 currInterceptorName = (String) iterator.next();
200
201 if( currInterceptorName.equals(interceptorName) )
202 {
203 return true;
204 }
205 }
206
207 return false;
208 }
209
210 /**
211 * Adds all given interceptors but avoiding duplicates.
212 *
213 * @param collection the interceptors to be added
214 */
215 public void addInterceptors( Collection collection )
216 {
217 String currInterceptorName = null;
218 Iterator iterator = collection.iterator();
219
220 while( iterator.hasNext() )
221 {
222 currInterceptorName = (String) iterator.next();
223
224 if( this.hasInterceptor(currInterceptorName) == false )
225 {
226 this.interceptorList.add(currInterceptorName);
227 }
228 }
229 }
230
231 /**
232 * @return Returns the interceptorList.
233 */
234 public String[] getInterceptorList()
235 {
236 return (String[]) interceptorList.toArray(
237 new String[interceptorList.size()]
238 );
239 }
240
241 /**
242 * @return Returns the logCategory.
243 */
244 public String getLogCategory()
245 {
246 return logCategory;
247 }
248
249 /**
250 * @see java.lang.Object#toString()
251 */
252 public String toString()
253 {
254 ToStringBuilder toStringBuilder = new ToStringBuilder(this);
255 toStringBuilder.append("name",this.name);
256 toStringBuilder.append("shorthand",this.shorthand);
257 toStringBuilder.append("implementationClazzName",this.implementationClazzName);
258 toStringBuilder.append("isEarlyInit",this.isEarlyInit);
259 toStringBuilder.append("hasDynamicProxy",this.hasDynamicProxy);
260 toStringBuilder.append("componentType",this.componentType);
261 toStringBuilder.append("componentFlavour",this.componentFlavour);
262 toStringBuilder.append("interceptorList",this.interceptorList);
263 toStringBuilder.append("logCategory",this.logCategory);
264 toStringBuilder.append("description",this.description);
265 return toStringBuilder.toString();
266 }
267 }