Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2010, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 
 package org.jboss.forge.parser.java.impl;
 
 import java.util.List;
 
 import  org.eclipse.jdt.core.dom.AST;
 import  org.eclipse.jdt.core.dom.ASTNode;
 import  org.eclipse.jdt.core.dom.Expression;
 import  org.eclipse.jdt.core.dom.FieldDeclaration;
 import  org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
 import  org.eclipse.jdt.core.dom.Name;
 import  org.eclipse.jdt.core.dom.PrimitiveType;
 import  org.eclipse.jdt.core.dom.PrimitiveType.Code;
 import  org.eclipse.jdt.core.dom.Type;
 import  org.eclipse.jdt.core.dom.VariableDeclarationFragment;

Author(s):
Lincoln Baxter, III
 
 public class FieldImpl<O extends JavaSource<O>> implements Field<O>
 {
    private final AnnotationAccessor<O, Field<O>> annotations = new AnnotationAccessor<O, Field<O>>();
    private final ModifierAccessor modifiers = new ModifierAccessor();
 
    private O parent;
    private AST ast;
    private final FieldDeclaration field;
 
    private void init(final O parent)
    {
       this. = parent;
        = ((ASTNode) parent.getInternal()).getAST();
    }
 
    public FieldImpl(final O parent)
    {
       init(parent);
       this. = .newFieldDeclaration(.newVariableDeclarationFragment());
    }
 
    public FieldImpl(final O parentfinal String declaration)
    {
       init(parent);
 
       String stub = "public class Stub { " + declaration + " }";
       JavaClass temp = (JavaClass) JavaParser.parse(stub);
       List<Field<JavaClass>> fields = temp.getFields();
       FieldDeclaration newField = (FieldDeclaration) fields.get(0).getInternal();
       FieldDeclaration subtree = (FieldDeclaration) ASTNode.copySubtree(newField);
       this. = subtree;
    }
 
    public FieldImpl(final O parentfinal Object internal)
    {
       init(parent);
       this. = (FieldDeclaration) internal;
    }
 
    @Override
    public O getOrigin()
    {
       return .getOrigin();
    }
 
    @Override
    public Object getInternal()
    {
       return ;
   }
   /*
    * Annotation<O> Modifiers
    */
   public Annotation<O> addAnnotation()
   {
      return .addAnnotation(this);
   }
   public Annotation<O> addAnnotation(final Class<? extends java.lang.annotation.Annotationclazz)
   {
      if (.requiresImport(clazz))
      {
         .addImport(clazz);
      }
      return .addAnnotation(thisclazz.getSimpleName());
   }
   public Annotation<O> addAnnotation(final String className)
   {
      return .addAnnotation(thisclassName);
   }
   public List<Annotation<O>> getAnnotations()
   {
      return .getAnnotations(this);
   }
   public boolean hasAnnotation(final Class<? extends java.lang.annotation.Annotationtype)
   {
      return .hasAnnotation(thistype.getName());
   }
   public boolean hasAnnotation(final String type)
   {
      return .hasAnnotation(thistype);
   }
   public Annotation<O> getAnnotation(final Class<? extends java.lang.annotation.Annotationtype)
   {
      return .getAnnotation(thistype);
   }
   public Annotation<O> getAnnotation(final String type)
   {
      return .getAnnotation(thistype);
   }
   public Field<O> removeAnnotation(final Annotation<O> annotation)
   {
      return .removeAnnotation(thisannotation);
   }
   public String toString()
   {
      return .toString();
   }
   /*
    * Visibility Modifiers
    */
   public boolean isFinal()
   {
      return .hasModifier(, ModifierKeyword.FINAL_KEYWORD);
   }
   public Field<O> setFinal(boolean finl)
   {
      if (finl)
         .addModifier(, ModifierKeyword.FINAL_KEYWORD);
      else
         .removeModifier(, ModifierKeyword.FINAL_KEYWORD);
      return this;
   }
   public boolean isStatic()
   {
      return .hasModifier(, ModifierKeyword.STATIC_KEYWORD);
   }
   public Field<O> setStatic(boolean statc)
   {
      if (statc)
         .addModifier(, ModifierKeyword.STATIC_KEYWORD);
      else
         .removeModifier(, ModifierKeyword.STATIC_KEYWORD);
      return this;
   }
   public boolean isPackagePrivate()
   {
      return (!isPublic() && !isPrivate() && !isProtected());
   }
   public Field<O> setPackagePrivate()
   {
      return this;
   }
   public boolean isPublic()
   {
      return .hasModifier(, ModifierKeyword.PUBLIC_KEYWORD);
   }
   public Field<O> setPublic()
   {
      .addModifier(, ModifierKeyword.PUBLIC_KEYWORD);
      return this;
   }
   public boolean isPrivate()
   {
      return .hasModifier(, ModifierKeyword.PRIVATE_KEYWORD);
   }
   public Field<O> setPrivate()
   {
      .addModifier(, ModifierKeyword.PRIVATE_KEYWORD);
      return this;
   }
   public boolean isProtected()
   {
      return .hasModifier(, ModifierKeyword.PROTECTED_KEYWORD);
   }
   public Field<O> setProtected()
   {
      .addModifier(, ModifierKeyword.PROTECTED_KEYWORD);
      return this;
   }
   public Visibility getVisibility()
   {
      return Visibility.getFrom(this);
   }
   public Field<O> setVisibility(final Visibility scope)
   {
      return Visibility.set(thisscope);
   }
   /*
    * Field<O> methods
    */
   public String getName()
   {
      String result = null;
      for (Object f : .fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            VariableDeclarationFragment frag = (VariableDeclarationFragment) f;
            result = frag.getName().getFullyQualifiedName();
            break;
         }
      }
      return result;
   }
   public Field<O> setName(final String name)
   {
      for (Object f : .fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            VariableDeclarationFragment frag = (VariableDeclarationFragment) f;
            frag.setName(.newSimpleName(name));
            break;
         }
      }
      return this;
   }
   public String getType()
   {
      Object type = .getStructuralProperty(FieldDeclaration.TYPE_PROPERTY);
      return type.toString();
   }
   public boolean isType(Class<?> type)
   {
      if (Strings.areEqual(type.getName(), getType()))
      {
         return true;
      }
      String simpleName = type.getSimpleName();
      if (Strings.areEqual(simpleNamegetType()) && (getOrigin().hasImport(type) || !getOrigin().requiresImport(type)))
      {
         return true;
      }
      return false;
   }
   public boolean isType(String name)
   {
      if (Strings.areEqual(namegetType()))
      {
         return true;
      }
      if ((!Types.isQualified(name) || getOrigin().hasImport(name) || !getOrigin().requiresImport(name))
               && Types.areEquivalent(namegetType()))
      {
         return true;
      }
      return false;
   }
   public Field<O> setType(final Class<?> clazz)
   {
      if (.requiresImport(clazz))
      {
         .addImport(clazz);
      }
      return setType(clazz.getSimpleName());
   }
   public Field<O> setType(final JavaSource<?> source)
   {
      return setType(source.getQualifiedName());
   }
   public Field<O> setType(final String typeName)
   {
      String simpleName = Types.toSimpleName(typeName);
      O origin = getOrigin();
      if (!Strings.areEqual(typeNamesimpleName) && origin.requiresImport(typeName))
      {
         origin.addImport(typeName);
      }
      Code primitive = PrimitiveType.toCode(typeName);
      Type type = null;
      if (primitive != null)
      {
         type = .newPrimitiveType(primitive);
      }
      else
      {
         if (!origin.requiresImport(typeName))
         {
            Name name = .newSimpleName(simpleName);
            type = .newSimpleType(name);
         }
         else
         {
            String[] className = Types.tokenizeClassName(typeName);
            Name name = .newName(className);
            type = .newSimpleType(name);
         }
      }
      .setType(type);
      return this;
   }
   {
      String result = null;
      for (Object f : .fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            VariableDeclarationFragment frag = (VariableDeclarationFragment) f;
            result = frag.getInitializer().toString();
            break;
         }
      }
      return result;
   }
   {
      String result = null;
      for (Object f : .fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            VariableDeclarationFragment frag = (VariableDeclarationFragment) f;
            result = Strings.unquote(frag.getInitializer().toString());
            break;
         }
      }
      return result;
   }
   public Field<O> setLiteralInitializer(final String value)
   {
      String stub = "public class Stub { private Field<O> stub = " + value + " }";
      JavaClass temp = (JavaClass) JavaParser.parse(stub);
      FieldDeclaration internal = (FieldDeclaration) temp.getFields().get(0).getInternal();
      for (Object f : internal.fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            VariableDeclarationFragment tempFrag = (VariableDeclarationFragment) f;
            VariableDeclarationFragment localFrag = getFragment();
            localFrag.setInitializer((Expression) ASTNode.copySubtree(tempFrag.getInitializer()));
            break;
         }
      }
      return this;
   }
   public Field<O> setStringInitializer(final String value)
   {
      return setLiteralInitializer(Strings.enquote(value));
   }
   private VariableDeclarationFragment getFragment(final FieldDeclaration field)
   {
      VariableDeclarationFragment result = null;
      for (Object f : field.fragments())
      {
         if (f instanceof VariableDeclarationFragment)
         {
            result = (VariableDeclarationFragment) f;
            break;
         }
      }
      return result;
   }
   public int hashCode()
   {
      final int prime = 31;
      int result = 1;
      result = prime * result + (( == null) ? 0 : .hashCode());
      return result;
   }
   public boolean equals(final Object obj)
   {
      if (this == obj)
      {
         return true;
      }
      if (obj == null)
      {
         return false;
      }
      if (getClass() != obj.getClass())
      {
         return false;
      }
      FieldImpl<?> other = (FieldImpl<?>) obj;
      if ( == null)
      {
         if (other.field != null)
         {
            return false;
         }
      }
      else if (!.equals(other.field))
      {
         return false;
      }
      return true;
   }
   public boolean isPrimitive()
   {
      boolean result = false;
      Type type = .getType();
      if (type != null)
      {
         result = type.isPrimitiveType();
      }
      return result;
   }
New to GrepCode? Check out our FAQ X