Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * JBoss, Home of Professional Open Source
3
   * Copyright 2010, Red Hat, Inc., and individual contributors
4
   * by the @authors tag. See the copyright.txt in the distribution for a
5
   * full listing of individual contributors.
6
   *
7
   * Licensed under the Apache License, Version 2.0 (the "License");
8
   * you may not use this file except in compliance with the License.
9
   * You may obtain a copy of the License at
10
  * http://www.apache.org/licenses/LICENSE-2.0
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 javax.enterprise.util;
19
 

Supports inline instantiation of annotation type instances.

An instance of an annotation type may be obtained by subclassing AnnotationLiteral.

 public abstract class PayByQualifier 
       extends AnnotationLiteral<PayBy>
       implements PayBy {}
 
 PayBy paybyCheque = new PayByQualifier() { public PaymentMethod value() { return CHEQUE; } };

Parameters:
<T> the annotation type
Author(s):
Pete Muir
Gavin King
See also:
javax.enterprise.inject.Instance.select(java.lang.annotation.Annotation[])
javax.enterprise.event.Event.select(java.lang.annotation.Annotation[])
53
 
54
 public abstract class AnnotationLiteral<T extends Annotation> 
55
       implements Annotation, Serializable
56
 {
57
    
58
    private transient Class<T> annotationType;
59
    private transient Method[] members;
60
 
61
    protected AnnotationLiteral() {}
62
    
63
    private Method[] getMembers() 
64
    {
65
       if (==null) {
66
           = annotationType().getDeclaredMethods();
67
          if ( .>0 && !annotationType().isAssignableFrom(this.getClass()) )
68
          {
69
             throw new RuntimeException(getClass() + " does not implement the annotation type with members " + annotationType().getName());
70
          }
71
       }
72
       return ;
73
    }
74
 	   
75
    private static Class<?> getAnnotationLiteralSubclass(Class<?> clazz)
76
    {
77
       Class<?> superclass = clazz.getSuperclass();
78
       if (superclass.equals(AnnotationLiteral.class))
79
       {
80
          return clazz;
81
       }
82
       else if (superclass.equals(Object.class))
83
       {
84
          return null;
85
       }
86
       else
87
       {
88
          return (getAnnotationLiteralSubclass(superclass));
89
       }
90
    }
91
    
92
    @SuppressWarnings("unchecked")
93
    private static <T> Class<T> getTypeParameter(Class<?> annotationLiteralSuperclass)
94
    {
95
       Type type = annotationLiteralSuperclass.getGenericSuperclass();
96
       if (type instanceof ParameterizedType)
97
       {
98
          ParameterizedType parameterizedType = (ParameterizedType) type;
99
          if (parameterizedType.getActualTypeArguments().length == 1)
100
         {
101
            return (Class<T>) parameterizedType
102
                  .getActualTypeArguments()[0];
103
         }
104
      }
105
      return null;
106
   }
108
   public Class<? extends Annotation> annotationType()
109
   {
110
      if (==null) 
111
      {
112
         Class<?> annotationLiteralSubclass = getAnnotationLiteralSubclass(this.getClass());
113
         if (annotationLiteralSubclass == null)
114
         {
115
            throw new RuntimeException(getClass() + "is not a subclass of AnnotationLiteral");
116
         }
117
          = getTypeParameter(annotationLiteralSubclass);
118
         if ( == null)
119
         {
120
            throw new RuntimeException(getClass() + " does not specify the type parameter T of AnnotationLiteral<T>");
121
         }
122
      }
123
      return ;
124
   }
127
   public String toString()
128
   {
129
      StringBuilder string = new StringBuilder();
130
      string.append('@').append(annotationType().getName()).append('(');
131
      for (int i = 0; i < getMembers().length; i++)
132
      {
133
         string.append(getMembers()[i].getName()).append('=');
134
         Object value = invoke(getMembers()[i], this);
135
         assertMemberValueNotNull(getMembers()[i], this, value);
136
         if (value instanceof boolean[]) 
137
         {
138
            appendInBraces(string, Arrays.toString((boolean[])value));
139
         }
140
         else if (value instanceof byte[]) 
141
         {
142
            appendInBraces(string, Arrays.toString((byte[])value));
143
         }
144
         else if (value instanceof short[]) 
145
         {
146
            appendInBraces(string, Arrays.toString((short[])value));
147
         }
148
         else if (value instanceof int[]) 
149
         {
150
            appendInBraces(string, Arrays.toString((int[])value));
151
         }
152
         else if (value instanceof long[]) 
153
         {
154
            appendInBraces(string, Arrays.toString((long[])value));
155
         }
156
         else if (value instanceof float[]) 
157
         {
158
            appendInBraces(string, Arrays.toString((float[])value));
159
         }
160
         else if (value instanceof double[]) 
161
         {
162
            appendInBraces(string, Arrays.toString((double[])value));
163
         }
164
         else if (value instanceof char[]) 
165
         {
166
            appendInBraces(string, Arrays.toString((char[])value));
167
         }
168
         else if (value instanceof String[]) 
169
         {
170
            String[] strings = (String[]) value;
171
            String[] quoted = new String[strings.length];
172
            for(int j=0; j<strings.length; j++) 
173
            {
174
               quoted[j] = "\"" + strings[j] + "\"";
175
            }
176
            appendInBraces(string, Arrays.toString(quoted));
177
         }
178
         else if (value instanceof Class<?>[]) 
179
         {
180
            Class<?>[] classes = (Class<?>[]) value;
181
            String[] names = new String[classes.length];
182
            for(int j=0; j<classes.length; j++) 
183
            {
184
               names[j] = classes[j].getName() + ".class";
185
            }
186
            appendInBraces(string, Arrays.toString(names));
187
         }
188
         else if (value instanceof Object[]) 
189
         {
190
            appendInBraces(string, Arrays.toString((Object[])value));
191
         }
192
         else if (value instanceof String) 
193
         {
194
            string.append('"').append(value).append('"');
195
         }
196
         else if (value instanceof Class<?>) 
197
         {
198
            string.append(((Class<?>)value).getName()).append(".class");
199
         }
200
         else 
201
         {
202
            string.append(value);
203
         }
204
         if (i < getMembers().length - 1)
205
         {
206
            string.append(", ");
207
         }
208
      }
209
      return string.append(')').toString();
210
   }
211
   
212
   private void appendInBraces(StringBuilder buf, String s) {
213
      buf.append('{').append(s.substring(1,s.length()-1)).append('}');
214
   }
215
   
217
   public boolean equals(Object other)
218
   {
219
      if (other instanceof Annotation)
220
      {
221
         Annotation that = (Annotation) other;
222
         if (this.annotationType().equals(that.annotationType()))
223
         {
224
            for (Method member : getMembers())
225
            {
226
               Object thisValue = invoke(member, this);
227
               assertMemberValueNotNull(member, this, thisValue);
228
               Object thatValue = invoke(member, that);
229
               assertMemberValueNotNull(member, this, thatValue);
230
               if (thisValue instanceof byte[] && thatValue instanceof byte[])
231
               {
232
                  if ( !Arrays.equals((byte[])thisValue, (byte[])thatValue) ) return false;
233
               }
234
               else if (thisValue instanceof short[] && thatValue instanceof short[])
235
               {
236
                  if ( !Arrays.equals((short[])thisValue, (short[])thatValue) ) return false;
237
               }
238
               else if (thisValue instanceof int[] && thatValue instanceof int[])
239
               {
240
                  if ( !Arrays.equals((int[])thisValue, (int[])thatValue) ) return false;
241
               }
242
               else if (thisValue instanceof long[] && thatValue instanceof long[])
243
               {
244
                  if ( !Arrays.equals((long[])thisValue, (long[])thatValue) ) return false;
245
               }
246
               else if (thisValue instanceof float[] && thatValue instanceof float[])
247
               {
248
                  if ( !Arrays.equals((float[])thisValue, (float[])thatValue) ) return false;
249
               }
250
               else if (thisValue instanceof double[] && thatValue instanceof double[])
251
               {
252
                  if ( !Arrays.equals((double[])thisValue, (double[])thatValue) ) return false;
253
               }
254
               else if (thisValue instanceof char[] && thatValue instanceof char[])
255
               {
256
                  if ( !Arrays.equals((char[])thisValue, (char[])thatValue) ) return false;
257
               }
258
               else if (thisValue instanceof boolean[] && thatValue instanceof boolean[])
259
               {
260
                  if ( !Arrays.equals((boolean[])thisValue, (boolean[])thatValue) ) return false;
261
               }
262
               else if (thisValue instanceof Object[] && thatValue instanceof Object[])
263
               {
264
                  if ( !Arrays.equals((Object[])thisValue, (Object[])thatValue) ) return false;
265
               }
266
               else 
267
               {
268
            	   if (!thisValue.equals(thatValue)) return false;
269
               }
270
            }
271
            return true;
272
         }
273
      }
274
      return false;
275
   }
276
   
278
   public int hashCode()
279
   {
280
      int hashCode = 0;
281
      for (Method member: getMembers())
282
      {
283
         int memberNameHashCode = 127 * member.getName().hashCode();
284
         Object value = invoke(member, this);
285
         assertMemberValueNotNull(member, this, value);
286
         int memberValueHashCode;
287
         if (value instanceof boolean[])
288
         {
289
            memberValueHashCode = Arrays.hashCode((boolean[]) value);
290
         }
291
         else if (value instanceof short[])
292
         {
293
            memberValueHashCode = Arrays.hashCode((short[]) value);
294
         }
295
         else if (value instanceof int[])
296
         {
297
            memberValueHashCode = Arrays.hashCode((int[]) value);
298
         }
299
         else if (value instanceof long[])
300
         {
301
            memberValueHashCode = Arrays.hashCode((long[]) value);
302
         }
303
         else if (value instanceof float[])
304
         {
305
            memberValueHashCode = Arrays.hashCode((float[]) value);
306
         }
307
         else if (value instanceof double[])
308
         {
309
            memberValueHashCode = Arrays.hashCode((double[]) value);
310
         }
311
         else if (value instanceof byte[])
312
         {
313
            memberValueHashCode = Arrays.hashCode((byte[]) value);
314
         }
315
         else if (value instanceof char[])
316
         {
317
            memberValueHashCode = Arrays.hashCode((char[]) value);
318
         }
319
         else if (value instanceof Object[])
320
         {
321
            memberValueHashCode = Arrays.hashCode((Object[]) value);
322
         }
323
         else 
324
         {
325
            memberValueHashCode = value.hashCode();
326
         }
327
         hashCode += memberNameHashCode ^ memberValueHashCode;
328
      }       
329
      return hashCode;
330
   }
331
   
332
   private static Object invoke(Method method, Object instance)
333
   {
334
      try
335
      {
336
         if (!method.isAccessible()) method.setAccessible(true);
337
         return method.invoke(instance);
338
      }
339
      catch (IllegalArgumentException e)
340
      {
341
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
342
      }
343
      catch (IllegalAccessException e)
344
      {
345
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
346
      }
347
      catch (InvocationTargetException e)
348
      {
349
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
350
      }
351
   }
352
   
353
   private static void assertMemberValueNotNull(Method member, Annotation instance, Object value)
354
   {
355
      if (value == null)
356
      {
357
         throw new IllegalArgumentException("Annotation member " + instance.getClass().getName() + "." + member.getName() + " must not be null");
358
      }
359
   }
New to GrepCode? Check out our FAQ X