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.compiler.IProblem;
 import  org.eclipse.jdt.core.dom.ASTNode;
 import  org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
 import  org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
 import  org.eclipse.jdt.core.dom.CompilationUnit;
 import  org.eclipse.jdt.core.dom.EnumDeclaration;
 import  org.eclipse.jdt.core.dom.ImportDeclaration;
 import  org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
 import  org.eclipse.jdt.core.dom.PackageDeclaration;
 import  org.eclipse.jdt.core.dom.Type;
 import  org.eclipse.jdt.core.dom.TypeDeclaration;
 import  org.eclipse.jface.text.Document;
Represents a Java Source File

Author(s):
Lincoln Baxter, III
 
 @SuppressWarnings("unchecked")
 public abstract class AbstractJavaSource<O extends JavaSource<O>> implements
          JavaSource<O>, InterfaceCapable<O>
 {
    private final AnnotationAccessor<O, O> annotations = new AnnotationAccessor<O, O>();
    private final ModifierAccessor modifiers = new ModifierAccessor();
 
    private final Document document;
    protected CompilationUnit unit;
 
    public AbstractJavaSource(final Document documentfinal CompilationUnit unit)
    {
       this. = document;
       this. = unit;
    }
 
    /*
     * Annotation modifiers
     */
    @Override
    public Annotation<O> addAnnotation()
    {
       return .addAnnotation(thisgetBodyDeclaration());
    }
 
    @Override
    public Annotation<O> addAnnotation(final Class<? extends java.lang.annotation.Annotationclazz)
    {
       return .addAnnotation(thisgetBodyDeclaration(), clazz.getName());
    }
 
    @Override
    public Annotation<O> addAnnotation(final String className)
    {
       return .addAnnotation(thisgetBodyDeclaration(), className);
    }
 
    @Override
    public List<Annotation<O>> getAnnotations()
    {
      return .getAnnotations(thisgetBodyDeclaration());
   }
   public boolean hasAnnotation(final Class<? extends java.lang.annotation.Annotationtype)
   {
      return .hasAnnotation(thisgetBodyDeclaration(), type.getName());
   }
   public boolean hasAnnotation(final String type)
   {
      return .hasAnnotation(thisgetBodyDeclaration(), type);
   }
   public O removeAnnotation(final Annotation<O> annotation)
   {
      return (O) .removeAnnotation(thisgetBodyDeclaration(), annotation);
   }
   public Annotation<O> getAnnotation(final Class<? extends java.lang.annotation.Annotationtype)
   {
      return .getAnnotation(thisgetBodyDeclaration(), type);
   }
   public Annotation<O> getAnnotation(final String type)
   {
      return .getAnnotation(thisgetBodyDeclaration(), type);
   }
   /*
    * Import modifiers
    */
   public Import addImport(final Class<?> type)
   {
      return addImport(type.getName());
   }
   public <T extends JavaSource<?>> Import addImport(final T type)
   {
      return this.addImport(type.getQualifiedName());
   }
   public Import addImport(final Import imprt)
   {
      return addImport(imprt.getQualifiedName()).setStatic(imprt.isStatic());
   }
   public Import addImport(final String className)
   {
      Import imprt;
      String simpleName = Types.toSimpleName(className);
      if (!hasImport(simpleName) && validImport(className))
      {
         imprt = new ImportImpl(this).setName(className);
         .imports().add(imprt.getInternal());
      }
      else if (hasImport(className))
      {
         imprt = getImport(className);
      }
      else
      {
         if (hasImport(simpleName))
         {
            throw new IllegalStateException("Cannot import [" + className
                     + "] because of existing conflicting import [" + getImport(simpleName) + "].");
         }
         else
         {
            throw new IllegalArgumentException("Attempted to import the illegal type [" + className + "]");
         }
      }
      return imprt;
   }
   public Import getImport(final String className)
   {
      List<Importimports = getImports();
      for (Import imprt : imports)
      {
         if (imprt.getQualifiedName().equals(className) || imprt.getSimpleName().equals(className))
         {
            return imprt;
         }
      }
      return null;
   }
   public Import getImport(final Class<?> type)
   {
      return getImport(type.getName());
   }
   public <T extends JavaSource<?>> Import getImport(final T type)
   {
      return getImport(type.getQualifiedName());
   };
   public Import getImport(final Import imprt)
   {
      return getImport(imprt.getQualifiedName());
   }
   public List<ImportgetImports()
   {
      List<Importresults = new ArrayList<Import>();
      for (ImportDeclaration i : (List<ImportDeclaration>) .imports())
      {
         results.add(new ImportImpl(thisi));
      }
      return Collections.unmodifiableList(results);
   }
   public boolean hasImport(final Class<?> type)
   {
      return hasImport(type.getName());
   }
   public <T extends JavaSource<T>> boolean hasImport(final T type)
   {
      return hasImport(type.getQualifiedName());
   };
   public boolean hasImport(final Import imprt)
   {
      return hasImport(imprt.getQualifiedName());
   }
   public boolean hasImport(final String type)
   {
      return getImport(type) != null;
   }
   public boolean requiresImport(final Class<?> type)
   {
      return requiresImport(type.getName());
   }
   public boolean requiresImport(final String type)
   {
      if (!validImport(type)
               || hasImport(type)
               || type.startsWith("java.lang."))
      {
         return false;
      }
      return true;
   }
   private boolean validImport(final String type)
   {
      return (type != null) && !type.matches("byte|short|int|long|float|double|char|boolean");
   }
   public O removeImport(final String name)
   {
      for (Import i : getImports())
      {
         if (i.getQualifiedName().equals(name))
         {
            removeImport(i);
            break;
         }
      }
      return (O) this;
   }
   public O removeImport(final Class<?> clazz)
   {
      return removeImport(clazz.getName());
   }
   public <T extends JavaSource<?>> O removeImport(final T type)
   {
      return removeImport(type.getQualifiedName());
   };
   public O removeImport(final Import imprt)
   {
      Object internal = imprt.getInternal();
      if (.imports().contains(internal))
      {
         .imports().remove(internal);
      }
      return (O) this;
   }
   public List<Member<O, ?>> getMembers()
   {
      List<Member<O, ?>> result = new ArrayList<Member<O, ?>>();
      return result;
   }
   protected AbstractTypeDeclaration getBodyDeclaration()
   {
      TypeDeclarationFinderVisitor typeDeclarationFinder = new TypeDeclarationFinderVisitor();
      .accept(typeDeclarationFinder);
      AbstractTypeDeclaration declaration = typeDeclarationFinder.getTypeDeclaration();
      if (declaration == null)
      {
         throw new RuntimeException(
                  "A type-declaration is required in order to complete the current operation, but no type-declaration exists in compilation unit: "
                           + .toString());
      }
      return declaration;
   }
   /*
    * Name modifiers
    */
   public String getName()
   {
      return getBodyDeclaration().getName().getIdentifier();
   }
   public O setName(final String name)
   {
      getBodyDeclaration().setName(.getAST().newSimpleName(name));
      return updateTypeNames(name);
   }

   
Call-back to allow updating of any necessary internal names with the given name.
   protected abstract O updateTypeNames(String name);
   public String getQualifiedName()
   {
      String packg = getPackage();
      String name = getName();
      if ((packg != null) && !packg.isEmpty())
      {
         return packg + "." + name;
      }
      return name;
   }
   /*
    * Package modifiers
    */
   public String getPackage()
   {
      PackageDeclaration pkg = .getPackage();
      if (pkg != null)
      {
         return pkg.getName().getFullyQualifiedName();
      }
      else
      {
         return null;
      }
   }
   public O setPackage(final String name)
   {
      if (.getPackage() == null)
      {
         .setPackage(.getAST().newPackageDeclaration());
      }
      .getPackage().setName(.getAST().newName(name));
      return (O) this;
   }
   public O setDefaultPackage()
   {
      .setPackage(null);
      return (O) this;
   }
   public boolean isDefaultPackage()
   {
      return .getPackage() == null;
   }
   /*
    * Visibility modifiers
    */
   public boolean isPackagePrivate()
   {
      return (!isPublic() && !isPrivate() && !isProtected());
   }
   public O setPackagePrivate()
   {
      return (O) this;
   }
   public boolean isPublic()
   {
      return .hasModifier(getBodyDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
   }
   public O setPublic()
   {
      .addModifier(getBodyDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
      return (O) this;
   }
   public boolean isPrivate()
   {
      return .hasModifier(getBodyDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
   }
   public O setPrivate()
   {
      .addModifier(getBodyDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
      return (O) this;
   }
   public boolean isProtected()
   {
      return .hasModifier(getBodyDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
   }
   public O setProtected()
   {
      .addModifier(getBodyDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
      return (O) this;
   }
   public Visibility getVisibility()
   {
      return Visibility.getFrom(this);
   }
   public O setVisibility(final Visibility scope)
   {
      return (O) Visibility.set(thisscope);
   }
   /*
    * Non-manipulation methods.
    */
   public String toString()
   {
      return .toString();
   }
   public Object getInternal()
   {
      return ;
   }
   public O getOrigin()
   {
      // try
      // {
      // TextEdit edit = unit.rewrite(document, null);
      // edit.apply(document);
      // }
      // catch (MalformedTreeException e)
      // {
      // throw new RuntimeException(e);
      // }
      // catch (BadLocationException e)
      // {
      // throw new RuntimeException(e);
      // }
      return (O) this;
   }
   public int hashCode()
   {
      final int prime = 31;
      int result = 1;
      result = prime * result + ((toString() == null) ? 0 : .toString().hashCode());
      return result;
   }
   public boolean equals(final Object obj)
   {
      return (this == obj)
               || ((obj != null) && (getClass() == obj.getClass()) && this.toString().equals(obj.toString()));
   }
   {
      List<SyntaxErrorresult = new ArrayList<SyntaxError>();
      IProblem[] problems = .getProblems();
      if (problems != null)
      {
         for (IProblem problem : problems)
         {
            result.add(new SyntaxErrorImpl(thisproblem));
         }
      }
      return result;
   }
   public boolean hasSyntaxErrors()
   {
      return !getSyntaxErrors().isEmpty();
   }
   public boolean isClass()
   {
      AbstractTypeDeclaration declaration = getBodyDeclaration();
      return (declaration instanceof TypeDeclaration)
               && !((TypeDeclaration) declaration).isInterface();
   }
   public boolean isEnum()
   {
      AbstractTypeDeclaration declaration = getBodyDeclaration();
      return declaration instanceof EnumDeclaration;
   }
   public boolean isInterface()
   {
      AbstractTypeDeclaration declaration = getBodyDeclaration();
      return (declaration instanceof TypeDeclaration)
               && ((TypeDeclaration) declaration).isInterface();
   }
   public boolean isAnnotation()
   {
      AbstractTypeDeclaration declaration = getBodyDeclaration();
      return declaration instanceof AnnotationTypeDeclaration;
   }
   /*
    * Interfaced Methods
    */
   public List<StringgetInterfaces()
   {
      List<Stringresult = new ArrayList<String>();
      List<Type> superTypes = JDTHelper.getInterfaces(getBodyDeclaration());
      for (Type type : superTypes)
      {
         String name = JDTHelper.getTypeName(type);
         if (Types.isSimpleName(name) && this.hasImport(name))
         {
            Import imprt = this.getImport(name);
            String pkg = imprt.getPackage();
            if (!Strings.isNullOrEmpty(pkg))
            {
               name = pkg + "." + name;
            }
         }
         result.add(name);
      }
      return result;
   }
   public O addInterface(final String type)
   {
      List<Type> interfaces = JDTHelper.getInterfaces(
               JavaParser.parse(JavaInterfaceImpl.class"public interface Mock extends " + type
                        + " {}").getBodyDeclaration());
      if (!interfaces.isEmpty())
      {
         if (!this.hasImport(Types.toSimpleName(type)))
         {
            this.addImport(type);
         }
         Type t = interfaces.get(0);
         ASTNode node = ASTNode.copySubtree(.getAST(), t);
         JDTHelper.getInterfaces(getBodyDeclaration()).add((Type) node);
      }
      else
      {
         throw new IllegalArgumentException("Could not parse interface declaration [" + type + "]");
      }
      return (O) this;
   }
   public O addInterface(final Class<?> type)
   {
      return addInterface(type.getName());
   }
   public O addInterface(final JavaInterface type)
   {
      return addInterface(type.getQualifiedName());
   }
   public boolean hasInterface(final String type)
   {
      for (String name : getInterfaces())
      {
         if (Types.areEquivalent(nametype))
         {
            return true;
         }
      }
      return false;
   }
   public boolean hasInterface(final Class<?> type)
   {
      return hasInterface(type.getName());
   }
   public boolean hasInterface(final JavaInterface type)
   {
      return hasInterface(type.getQualifiedName());
   }
   public O removeInterface(final String type)
   {
      List<Type> interfaces = JDTHelper.getInterfaces(getBodyDeclaration());
      for (Type i : interfaces)
      {
         if (Types.areEquivalent(i.toString(), type))
         {
            interfaces.remove(i);
            break;
         }
      }
      return (O) this;
   }
   public O removeInterface(final Class<?> type)
   {
      return removeInterface(type.getName());
   }
   public O removeInterface(final JavaInterface type)
   {
      return removeInterface(type.getQualifiedName());
   }
New to GrepCode? Check out our FAQ X