1 /* 2 * Copyright (c) 1997, 2012, 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.codemodel.internal; 27 28 import java.lang.annotation.Annotation; 29 import java.util.ArrayList; 30 import java.util.List; 31 import java.util.Collection; 32 import java.util.Collections; 33 34 35 /** 36 * Variables and fields. 37 */ 38 39 public class JVar extends JExpressionImpl implements JDeclaration, JAssignmentTarget, JAnnotatable { 40 41 /** 42 * Modifiers. 43 */ 44 private JMods mods; 45 46 /** 47 * JType of the variable 48 */ 49 private JType type; 50 51 /** 52 * Name of the variable 53 */ 54 private String name; 55 56 /** 57 * Initialization of the variable in its declaration 58 */ 59 private JExpression init; 60 61 /** 62 * Annotations on this variable. Lazily created. 63 */ 64 private List<JAnnotationUse> annotations = null; 65 66 67 68 /** 69 * JVar constructor 70 * 71 * @param type 72 * Datatype of this variable 73 * 74 * @param name 75 * Name of this variable 76 * 77 * @param init 78 * Value to initialize this variable to 79 */ 80 JVar(JMods mods, JType type, String name, JExpression init) { 81 this.mods = mods; 82 this.type = type; 83 this.name = name; 84 this.init = init; 85 } 86 87 88 /** 89 * Initialize this variable 90 * 91 * @param init 92 * JExpression to be used to initialize this field 93 */ 94 public JVar init(JExpression init) { 95 this.init = init; 96 return this; 97 } 98 99 /** 100 * Get the name of this variable 101 * 102 * @return Name of the variable 103 */ 104 public String name() { 105 return name; 106 } 107 108 /** 109 * Changes the name of this variable. 110 */ 111 public void name(String name) { 112 if(!JJavaName.isJavaIdentifier(name)) 113 throw new IllegalArgumentException(); 114 this.name = name; 115 } 116 117 /** 118 * Return the type of this variable. 119 * @return 120 * always non-null. 121 */ 122 public JType type() { 123 return type; 124 } 125 126 /** 127 * @return 128 * the current modifiers of this method. 129 * Always return non-null valid object. 130 */ 131 public JMods mods() { 132 return mods; 133 } 134 135 /** 136 * Sets the type of this variable. 137 * 138 * @param newType 139 * must not be null. 140 * 141 * @return 142 * the old type value. always non-null. 143 */ 144 public JType type(JType newType) { 145 JType r = type; 146 if(newType==null) 147 throw new IllegalArgumentException(); 148 type = newType; 149 return r; 150 } 151 152 153 /** 154 * Adds an annotation to this variable. 155 * @param clazz 156 * The annotation class to annotate the field with 157 */ 158 public JAnnotationUse annotate(JClass clazz){ 159 if(annotations==null) 160 annotations = new ArrayList<JAnnotationUse>(); 161 JAnnotationUse a = new JAnnotationUse(clazz); 162 annotations.add(a); 163 return a; 164 } 165 166 /** 167 * Adds an annotation to this variable. 168 * 169 * @param clazz 170 * The annotation class to annotate the field with 171 */ 172 public JAnnotationUse annotate(Class <? extends Annotation> clazz){ 173 return annotate(type.owner().ref(clazz)); 174 } 175 176 public <W extends JAnnotationWriter> W annotate2(Class<W> clazz) { 177 return TypedAnnotationWriter.create(clazz,this); 178 } 179 180 public Collection<JAnnotationUse> annotations() { 181 if (annotations == null) 182 annotations = new ArrayList<JAnnotationUse>(); 183 return Collections.unmodifiableList(annotations); 184 } 185 186 protected boolean isAnnotated() { 187 return annotations!=null; 188 } 189 190 public void bind(JFormatter f) { 191 if (annotations != null){ 192 for( int i=0; i<annotations.size(); i++ ) 193 f.g(annotations.get(i)).nl(); 194 } 195 f.g(mods).g(type).id(name); 196 if (init != null) 197 f.p('=').g(init); 198 } 199 200 public void declare(JFormatter f) { 201 f.b(this).p(';').nl(); 202 } 203 204 public void generate(JFormatter f) { 205 f.id(name); 206 } 207 208 209 public JExpression assign(JExpression rhs) { 210 return JExpr.assign(this,rhs); 211 } 212 public JExpression assignPlus(JExpression rhs) { 213 return JExpr.assignPlus(this,rhs); 214 } 215 216 }