Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Create Annotation instance with defaults, in Java
How can I create an instance of the following annotation (with all fields set to their default value). @Retention( RetentionPolicy.RUNTIME ) public @interface Settings { String a() default "AAA"; String b() default "BBB"; String c() default "CCC"; } I tried new Settings(), but that does not seem to work...
2. Standalone version of class AnnotationLiteral?
The CDI (Context Dependency Injection) Framework contains the awesome class javax.enterprise.util.AnnotationLiteral that makes it very easy to create an instance of an Annotation (especaly useful for tests). I want to use that util class in my own library. But because my library has noting to do with CDI, I do not want to have all the other CDI stuff. Fortunately AnnotationLiteral does not use... 
1
  /*
2
  * JBoss, Home of Professional Open Source
3
  * Copyright 2008, Red Hat Middleware LLC, 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
         if (value instanceof boolean[]) 
136
         {
137
            appendInBraces(string, Arrays.toString((boolean[])value));
138
         }
139
         else if (value instanceof byte[]) 
140
         {
141
            appendInBraces(string, Arrays.toString((byte[])value));
142
         }
143
         else if (value instanceof short[]) 
144
         {
145
            appendInBraces(string, Arrays.toString((short[])value));
146
         }
147
         else if (value instanceof int[]) 
148
         {
149
            appendInBraces(string, Arrays.toString((int[])value));
150
         }
151
         else if (value instanceof long[]) 
152
         {
153
            appendInBraces(string, Arrays.toString((long[])value));
154
         }
155
         else if (value instanceof float[]) 
156
         {
157
            appendInBraces(string, Arrays.toString((float[])value));
158
         }
159
         else if (value instanceof double[]) 
160
         {
161
            appendInBraces(string, Arrays.toString((double[])value));
162
         }
163
         else if (value instanceof char[]) 
164
         {
165
            appendInBraces(string, Arrays.toString((char[])value));
166
         }
167
         else if (value instanceof String[]) 
168
         {
169
            String[] strings = (String[]) value;
170
            String[] quoted = new String[strings.length];
171
            for(int j=0; j<strings.length; j++) 
172
            {
173
               quoted[j] = "\"" + strings[j] + "\"";
174
            }
175
            appendInBraces(string, Arrays.toString(quoted));
176
         }
177
         else if (value instanceof Class<?>[]) 
178
         {
179
            Class<?>[] classes = (Class<?>[]) value;
180
            String[] names = new String[classes.length];
181
            for(int j=0; j<classes.length; j++) 
182
            {
183
               names[j] = classes[j].getName() + ".class";
184
            }
185
            appendInBraces(string, Arrays.toString(names));
186
         }
187
         else if (value instanceof Object[]) 
188
         {
189
            appendInBraces(string, Arrays.toString((Object[])value));
190
         }
191
         else if (value instanceof String) 
192
         {
193
            string.append('"').append(value).append('"');
194
         }
195
         else if (value instanceof Class<?>) 
196
         {
197
            string.append(((Class<?>)value).getName()).append(".class");
198
         }
199
         else 
200
         {
201
            string.append(value);
202
         }
203
         if (i < getMembers().length - 1)
204
         {
205
            string.append(", ");
206
         }
207
      }
208
      return string.append(')').toString();
209
   }
210
   
211
   private void appendInBraces(StringBuilder buf, String s) {
212
      buf.append('{').append(s.substring(1,s.length()-1)).append('}');
213
   }
214
   
216
   public boolean equals(Object other)
217
   {
218
      if (other instanceof Annotation)
219
      {
220
         Annotation that = (Annotation) other;
221
         if (this.annotationType().equals(that.annotationType()))
222
         {
223
            for (Method member : getMembers())
224
            {
225
               Object thisValue = invoke(member, this);
226
               Object thatValue = invoke(member, that);
227
               if (thisValue instanceof byte[] && thatValue instanceof byte[])
228
               {
229
                  if ( !Arrays.equals((byte[])thisValue, (byte[])thatValue) ) return false;
230
               }
231
               else if (thisValue instanceof short[] && thatValue instanceof short[])
232
               {
233
                  if ( !Arrays.equals((short[])thisValue, (short[])thatValue) ) return false;
234
               }
235
               else if (thisValue instanceof int[] && thatValue instanceof int[])
236
               {
237
                  if ( !Arrays.equals((int[])thisValue, (int[])thatValue) ) return false;
238
               }
239
               else if (thisValue instanceof long[] && thatValue instanceof long[])
240
               {
241
                  if ( !Arrays.equals((long[])thisValue, (long[])thatValue) ) return false;
242
               }
243
               else if (thisValue instanceof float[] && thatValue instanceof float[])
244
               {
245
                  if ( !Arrays.equals((float[])thisValue, (float[])thatValue) ) return false;
246
               }
247
               else if (thisValue instanceof double[] && thatValue instanceof double[])
248
               {
249
                  if ( !Arrays.equals((double[])thisValue, (double[])thatValue) ) return false;
250
               }
251
               else if (thisValue instanceof char[] && thatValue instanceof char[])
252
               {
253
                  if ( !Arrays.equals((char[])thisValue, (char[])thatValue) ) return false;
254
               }
255
               else if (thisValue instanceof boolean[] && thatValue instanceof boolean[])
256
               {
257
                  if ( !Arrays.equals((boolean[])thisValue, (boolean[])thatValue) ) return false;
258
               }
259
               else if (thisValue instanceof Object[] && thatValue instanceof Object[])
260
               {
261
                  if ( !Arrays.equals((Object[])thisValue, (Object[])thatValue) ) return false;
262
               }
263
               else 
264
               {
265
            	   if (!thisValue.equals(thatValue)) return false;
266
               }
267
            }
268
            return true;
269
         }
270
      }
271
      return false;
272
   }
273
   
275
   public int hashCode()
276
   {
277
      int hashCode = 0;
278
      for (Method member: getMembers())
279
      {
280
         int memberNameHashCode = 127 * member.getName().hashCode();
281
         Object value = invoke(member, this);
282
         int memberValueHashCode;
283
         if (value instanceof boolean[])
284
         {
285
            memberValueHashCode = Arrays.hashCode((boolean[]) value);
286
         }
287
         else if (value instanceof short[])
288
         {
289
            memberValueHashCode = Arrays.hashCode((short[]) value);
290
         }
291
         else if (value instanceof int[])
292
         {
293
            memberValueHashCode = Arrays.hashCode((int[]) value);
294
         }
295
         else if (value instanceof long[])
296
         {
297
            memberValueHashCode = Arrays.hashCode((long[]) value);
298
         }
299
         else if (value instanceof float[])
300
         {
301
            memberValueHashCode = Arrays.hashCode((float[]) value);
302
         }
303
         else if (value instanceof double[])
304
         {
305
            memberValueHashCode = Arrays.hashCode((double[]) value);
306
         }
307
         else if (value instanceof byte[])
308
         {
309
            memberValueHashCode = Arrays.hashCode((byte[]) value);
310
         }
311
         else if (value instanceof char[])
312
         {
313
            memberValueHashCode = Arrays.hashCode((char[]) value);
314
         }
315
         else if (value instanceof Object[])
316
         {
317
            memberValueHashCode = Arrays.hashCode((Object[]) value);
318
         }
319
         else 
320
         {
321
            memberValueHashCode = value.hashCode();
322
         }
323
         hashCode += memberNameHashCode ^ memberValueHashCode;
324
      }       
325
      return hashCode;
326
   }
327
   
328
   private static Object invoke(Method method, Object instance)
329
   {
330
      try
331
      {
332
         if (!method.isAccessible()) method.setAccessible(true);
333
         return method.invoke(instance);
334
      }
335
      catch (IllegalArgumentException e)
336
      {
337
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
338
      }
339
      catch (IllegalAccessException e)
340
      {
341
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
342
      }
343
      catch (InvocationTargetException e)
344
      {
345
         throw new RuntimeException("Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
346
      }
347
   }
New to GrepCode? Check out our FAQ X