Save This Page
Home » openjdk-7 » com.sun.tools » javac » code » [javadoc | source]
    1   /*
    2    * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   
   26   package com.sun.tools.javac.code;
   27   
   28   import java.util.LinkedHashMap;
   29   import java.util.Map;
   30   import javax.lang.model.element.AnnotationMirror;
   31   import javax.lang.model.element.AnnotationValue;
   32   import javax.lang.model.element.AnnotationValueVisitor;
   33   import javax.lang.model.type.DeclaredType;
   34   import com.sun.tools.javac.code.Symbol;
   35   import com.sun.tools.javac.util;
   36   
   37   import static com.sun.tools.javac.code.TypeTags.*;
   38   
   39   /** An annotation value.
   40    *
   41    *  <p><b>This is NOT part of any supported API.
   42    *  If you write code that depends on this, you do so at your own risk.
   43    *  This code and its internal interfaces are subject to change or
   44    *  deletion without notice.</b>
   45    */
   46   public abstract class Attribute implements AnnotationValue {
   47   
   48       /** The type of the annotation element. */
   49       public Type type;
   50   
   51       public Attribute(Type type) {
   52           this.type = type;
   53       }
   54   
   55       public abstract void accept(Visitor v);
   56   
   57       public Object getValue() {
   58           throw new UnsupportedOperationException();
   59       }
   60   
   61       public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
   62           throw new UnsupportedOperationException();
   63       }
   64   
   65   
   66       /** The value for an annotation element of primitive type or String. */
   67       public static class Constant extends Attribute {
   68           public final Object value;
   69           public void accept(Visitor v) { v.visitConstant(this); }
   70           public Constant(Type type, Object value) {
   71               super(type);
   72               this.value = value;
   73           }
   74           public String toString() {
   75               return Constants.format(value, type);
   76           }
   77           public Object getValue() {
   78               return Constants.decode(value, type);
   79           }
   80           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
   81               if (value instanceof String)
   82                   return v.visitString((String) value, p);
   83               if (value instanceof Integer) {
   84                   int i = (Integer) value;
   85                   switch (type.tag) {
   86                   case BOOLEAN:   return v.visitBoolean(i != 0, p);
   87                   case CHAR:      return v.visitChar((char) i, p);
   88                   case BYTE:      return v.visitByte((byte) i, p);
   89                   case SHORT:     return v.visitShort((short) i, p);
   90                   case INT:       return v.visitInt(i, p);
   91                   }
   92               }
   93               switch (type.tag) {
   94               case LONG:          return v.visitLong((Long) value, p);
   95               case FLOAT:         return v.visitFloat((Float) value, p);
   96               case DOUBLE:        return v.visitDouble((Double) value, p);
   97               }
   98               throw new AssertionError("Bad annotation element value: " + value);
   99           }
  100       }
  101   
  102       /** The value for an annotation element of type java.lang.Class,
  103        *  represented as a ClassSymbol.
  104        */
  105       public static class Class extends Attribute {
  106           public final Type type;
  107           public void accept(Visitor v) { v.visitClass(this); }
  108           public Class(Types types, Type type) {
  109               super(makeClassType(types, type));
  110               this.type = type;
  111           }
  112           static Type makeClassType(Types types, Type type) {
  113               Type arg = type.isPrimitive()
  114                   ? types.boxedClass(type).type
  115                   : types.erasure(type);
  116               return new Type.ClassType(types.syms.classType.getEnclosingType(),
  117                                         List.of(arg),
  118                                         types.syms.classType.tsym);
  119           }
  120           public String toString() {
  121               return type + ".class";
  122           }
  123           public Type getValue() {
  124               return type;
  125           }
  126           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
  127               return v.visitType(type, p);
  128           }
  129       }
  130   
  131       /** A compound annotation element value, the type of which is an
  132        *  attribute interface.
  133        */
  134       public static class Compound extends Attribute implements AnnotationMirror {
  135           /** The attributes values, as pairs.  Each pair contains a
  136            *  reference to the accessing method in the attribute interface
  137            *  and the value to be returned when that method is called to
  138            *  access this attribute.
  139            */
  140           public final List<Pair<MethodSymbol,Attribute>> values;
  141           public Compound(Type type,
  142                           List<Pair<MethodSymbol,Attribute>> values) {
  143               super(type);
  144               this.values = values;
  145           }
  146           public void accept(Visitor v) { v.visitCompound(this); }
  147   
  148           /**
  149            * Returns a string representation of this annotation.
  150            * String is of one of the forms:
  151            *     @com.example.foo(name1=val1, name2=val2)
  152            *     @com.example.foo(val)
  153            *     @com.example.foo
  154            * Omit parens for marker annotations, and omit "value=" when allowed.
  155            */
  156           public String toString() {
  157               StringBuilder buf = new StringBuilder();
  158               buf.append("@");
  159               buf.append(type);
  160               int len = values.length();
  161               if (len > 0) {
  162                   buf.append('(');
  163                   boolean first = true;
  164                   for (Pair<MethodSymbol, Attribute> value : values) {
  165                       if (!first) buf.append(", ");
  166                       first = false;
  167   
  168                       Name name = value.fst.name;
  169                       if (len > 1 || name != name.table.names.value) {
  170                           buf.append(name);
  171                           buf.append('=');
  172                       }
  173                       buf.append(value.snd);
  174                   }
  175                   buf.append(')');
  176               }
  177               return buf.toString();
  178           }
  179   
  180           public Attribute member(Name member) {
  181               for (Pair<MethodSymbol,Attribute> pair : values)
  182                   if (pair.fst.name == member) return pair.snd;
  183               return null;
  184           }
  185   
  186           public Attribute.Compound getValue() {
  187               return this;
  188           }
  189   
  190           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
  191               return v.visitAnnotation(this, p);
  192           }
  193   
  194           public DeclaredType getAnnotationType() {
  195               return (DeclaredType) type;
  196           }
  197   
  198           public Map<MethodSymbol, Attribute> getElementValues() {
  199               Map<MethodSymbol, Attribute> valmap =
  200                   new LinkedHashMap<MethodSymbol, Attribute>();
  201               for (Pair<MethodSymbol, Attribute> value : values)
  202                   valmap.put(value.fst, value.snd);
  203               return valmap;
  204           }
  205       }
  206   
  207       /** The value for an annotation element of an array type.
  208        */
  209       public static class Array extends Attribute {
  210           public final Attribute[] values;
  211           public Array(Type type, Attribute[] values) {
  212               super(type);
  213               this.values = values;
  214           }
  215           public void accept(Visitor v) { v.visitArray(this); }
  216           public String toString() {
  217               StringBuilder buf = new StringBuilder();
  218               buf.append('{');
  219               boolean first = true;
  220               for (Attribute value : values) {
  221                   if (!first)
  222                       buf.append(", ");
  223                   first = false;
  224                   buf.append(value);
  225               }
  226               buf.append('}');
  227               return buf.toString();
  228           }
  229           public List<Attribute> getValue() {
  230               return List.from(values);
  231           }
  232           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
  233               return v.visitArray(getValue(), p);
  234           }
  235       }
  236   
  237       /** The value for an annotation element of an enum type.
  238        */
  239       public static class Enum extends Attribute {
  240           public VarSymbol value;
  241           public Enum(Type type, VarSymbol value) {
  242               super(type);
  243               this.value = Assert.checkNonNull(value);
  244           }
  245           public void accept(Visitor v) { v.visitEnum(this); }
  246           public String toString() {
  247               return value.enclClass() + "." + value;     // qualified name
  248           }
  249           public VarSymbol getValue() {
  250               return value;
  251           }
  252           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
  253               return v.visitEnumConstant(value, p);
  254           }
  255       }
  256   
  257       public static class Error extends Attribute {
  258           public Error(Type type) {
  259               super(type);
  260           }
  261           public void accept(Visitor v) { v.visitError(this); }
  262           public String toString() {
  263               return "<error>";
  264           }
  265           public String getValue() {
  266               return toString();
  267           }
  268           public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
  269               return v.visitString(toString(), p);
  270           }
  271       }
  272   
  273       /** A visitor type for dynamic dispatch on the kind of attribute value. */
  274       public static interface Visitor {
  275           void visitConstant(Attribute.Constant value);
  276           void visitClass(Attribute.Class clazz);
  277           void visitCompound(Attribute.Compound compound);
  278           void visitArray(Attribute.Array array);
  279           void visitEnum(Attribute.Enum e);
  280           void visitError(Attribute.Error e);
  281       }
  282   
  283       /** A mirror of java.lang.annotation.RetentionPolicy. */
  284       public static enum RetentionPolicy {
  285           SOURCE,
  286           CLASS,
  287           RUNTIME
  288       }
  289   }

Save This Page
Home » openjdk-7 » com.sun.tools » javac » code » [javadoc | source]