src/main/java/org/apache/bcel/generic/ClassGen.java - commons-bcel - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.bcel.generic;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;

 import org.apache.bcel.Const;
 import org.apache.bcel.classfile.AccessFlags;
 import org.apache.bcel.classfile.Annotations;
 import org.apache.bcel.classfile.Attribute;
 import org.apache.bcel.classfile.ConstantPool;
 import org.apache.bcel.classfile.Field;
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
 import org.apache.bcel.classfile.RuntimeInvisibleAnnotations;
 import org.apache.bcel.classfile.RuntimeVisibleAnnotations;
 import org.apache.bcel.classfile.SourceFile;
 import org.apache.bcel.classfile.Utility;
 import org.apache.bcel.util.BCELComparator;
 import org.apache.commons.lang3.ArrayUtils;

 /**
  * Template class for building up a java class. May be initialized with an existing Java class (file).
  *
  * @see JavaClass
  */
 public class ClassGen extends AccessFlags implements Cloneable {

     private static BCELComparator<ClassGen> bcelComparator = new BCELComparator<ClassGen>() {

         @Override
         public boolean equals(final ClassGen a, final ClassGen b) {
             return a == b || a != null && b != null && Objects.equals(a.getClassName(), b.getClassName());
         }

         @Override
         public int hashCode(final ClassGen o) {
             return o != null ? Objects.hashCode(o.getClassName()) : 0;
         }
     };

     /**
      * Gets the comparison strategy object.
      *
      * @return Comparison strategy object.
      */
     public static BCELComparator<ClassGen> getComparator() {
         return bcelComparator;
     }

     /**
      * Sets the comparison strategy object.
      *
      * @param comparator Comparison strategy object.
      */
     public static void setComparator(final BCELComparator<ClassGen> comparator) {
         bcelComparator = comparator;
     }

     /*
      * Corresponds to the fields found in a JavaClass object.
      */
     private String className;
     private String superClassName;
     private final String fileName;
     private int classNameIndex = -1;
     private int superclassNameIndex = -1;
     private int major = Const.MAJOR_1_1;
     private int minor = Const.MINOR_1_1;
     private ConstantPoolGen cp; // Template for building up constant pool
     // ArrayLists instead of arrays to gather fields, methods, etc.
     private final List<Field> fieldList = new ArrayList<>();
     private final List<Method> methodList = new ArrayList<>();

     private final List<Attribute> attributeList = new ArrayList<>();

     private final List<String> interfaceList = new ArrayList<>();

     private final List<AnnotationEntryGen> annotationList = new ArrayList<>();

     private List<ClassObserver> observers;

     /**
      * Constructs a new instance from an existing class.
      *
      * @param clazz JavaClass object (for example read from file).
      */
     public ClassGen(final JavaClass clazz) {
         super(clazz.getAccessFlags());
         classNameIndex = clazz.getClassNameIndex();
         superclassNameIndex = clazz.getSuperclassNameIndex();
         className = clazz.getClassName();
         superClassName = clazz.getSuperclassName();
         fileName = clazz.getSourceFileName();
         cp = new ConstantPoolGen(clazz.getConstantPool());
         major = clazz.getMajor();
         minor = clazz.getMinor();
         final Attribute[] attributes = clazz.getAttributes();
         // J5TODO: Could make unpacking lazy, done on first reference
         final AnnotationEntryGen[] annotations = unpackAnnotations(attributes);
         final String[] interfaceNames = clazz.getInterfaceNames();
         if (interfaceNames != null) {
             Collections.addAll(interfaceList, interfaceNames);
         }
         if (attributes != null) {
             for (final Attribute attribute : attributes) {
                 if (!(attribute instanceof Annotations)) {
                     addAttribute(attribute);
                 }
             }
         }
         Collections.addAll(annotationList, annotations);
         final Method[] methods = clazz.getMethods();
         if (methods != null) {
             Collections.addAll(methodList, methods);
         }
         final Field[] fields = clazz.getFields();
         if (fields != null) {
             Collections.addAll(fieldList, fields);
         }
     }

     /**
      * Convenience constructor to set up some important values initially.
      *
      * @param className fully qualified class name.
      * @param superClassName fully qualified superclass name.
      * @param fileName source file name.
      * @param accessFlags access qualifiers.
      * @param interfaces implemented interfaces.
      */
     public ClassGen(final String className, final String superClassName, final String fileName, final int accessFlags, final String[] interfaces) {
         this(className, superClassName, fileName, accessFlags, interfaces, new ConstantPoolGen());
     }

     /**
      * Convenience constructor to set up some important values initially.
      *
      * @param className fully qualified class name.
      * @param superClassName fully qualified superclass name.
      * @param fileName source file name.
      * @param accessFlags access qualifiers.
      * @param interfaces implemented interfaces.
      * @param cp constant pool to use.
      */
     public ClassGen(final String className, final String superClassName, final String fileName, final int accessFlags, final String[] interfaces,
         final ConstantPoolGen cp) {
         super(accessFlags);
         this.className = className;
         this.superClassName = superClassName;
         this.fileName = fileName;
         this.cp = cp;
         // Put everything needed by default into the constant pool and the vectors
         if (fileName != null) {
             addAttribute(new SourceFile(cp.addUtf8("SourceFile"), 2, cp.addUtf8(fileName), cp.getConstantPool()));
         }
         classNameIndex = cp.addClass(className);
         superclassNameIndex = cp.addClass(superClassName);
         if (interfaces != null) {
             Collections.addAll(interfaceList, interfaces);
         }
     }

     /**
      * Adds an annotation entry to this class.
      *
      * @param a the annotation entry to add.
      */
     public void addAnnotationEntry(final AnnotationEntryGen a) {
         annotationList.add(a);
     }

     /**
      * Add an attribute to this class.
      *
      * @param a attribute to add.
      */
     public void addAttribute(final Attribute a) {
         attributeList.add(a);
     }

     /**
      * Convenience method.
      *
      * Add an empty constructor to this class that does nothing but calling super().
      *
      * @param accessFlags rights for constructor.
      */
     public void addEmptyConstructor(final int accessFlags) {
         final InstructionList il = new InstructionList();
         il.append(InstructionConst.THIS); // Push 'this'
         il.append(new INVOKESPECIAL(cp.addMethodref(superClassName, Const.CONSTRUCTOR_NAME, "()V")));
         il.append(InstructionConst.RETURN);
         final MethodGen mg = new MethodGen(accessFlags, Type.VOID, Type.NO_ARGS, null, Const.CONSTRUCTOR_NAME, className, il, cp);
         mg.setMaxStack(1);
         addMethod(mg.getMethod());
     }

     /**
      * Add a field to this class.
      *
      * @param f field to add.
      */
     public void addField(final Field f) {
         fieldList.add(f);
     }

     /**
      * Add an interface to this class, that is, this class has to implement it.
      *
      * @param name interface to implement (fully qualified class name).
      */
     public void addInterface(final String name) {
         interfaceList.add(name);
     }

     /**
      * Add a method to this class.
      *
      * @param m method to add.
      */
     public void addMethod(final Method m) {
         methodList.add(m);
     }

     /**
      * Add observer for this object.
      *
      * @param o the observer.
      */
     public void addObserver(final ClassObserver o) {
         if (observers == null) {
             observers = new ArrayList<>();
         }
         observers.add(o);
     }

     @Override
     public Object clone() {
         try {
             return super.clone();
         } catch (final CloneNotSupportedException e) {
             throw new UnsupportedOperationException("Clone Not Supported", e); // never happens
         }
     }

     /**
      * Checks if this class contains the given field.
      *
      * @param f the field to check.
      * @return true if this class contains the field.
      */
     public boolean containsField(final Field f) {
         return fieldList.contains(f);
     }

     /**
      * Gets the field object with given name, or null.
      *
      * @param name the field name.
      * @return field object with given name, or null.
      */
     public Field containsField(final String name) {
         for (final Field f : fieldList) {
             if (f.getName().equals(name)) {
                 return f;
             }
         }
         return null;
     }

     /**
      * Gets the method object with given name and signature, or null.
      *
      * @param name the method name.
      * @param signature the method signature.
      * @return method object with given name and signature, or null.
      */
     public Method containsMethod(final String name, final String signature) {
         for (final Method m : methodList) {
             if (m.getName().equals(name) && m.getSignature().equals(signature)) {
                 return m;
             }
         }
         return null;
     }

     /**
      * Return value as defined by given BCELComparator strategy. By default two ClassGen objects are said to be equal when
      * their class names are equal.
      *
      * @see Object#equals(Object)
      */
     @Override
     public boolean equals(final Object obj) {
         return obj instanceof ClassGen && bcelComparator.equals(this, (ClassGen) obj);
     }

     /**
      * Gets the annotation entries.
      *
      * @return the annotation entries.
      */
     // J5TODO: Should we make calling unpackAnnotations() lazy and put it in here?
     public AnnotationEntryGen[] getAnnotationEntries() {
         return annotationList.toArray(AnnotationEntryGen.EMPTY_ARRAY);
     }

     /**
      * Gets the attributes.
      *
      * @return the attributes.
      */
     public Attribute[] getAttributes() {
         return attributeList.toArray(Attribute.EMPTY_ARRAY);
     }

     /**
      * Gets the class name.
      *
      * @return the class name.
      */
     public String getClassName() {
         return className;
     }

     /**
      * Gets the class name index.
      *
      * @return the class name index.
      */
     public int getClassNameIndex() {
         return classNameIndex;
     }

     /**
      * Gets the constant pool.
      *
      * @return the constant pool.
      */
     public ConstantPoolGen getConstantPool() {
         return cp;
     }

     /**
      * Gets the fields.
      *
      * @return the fields.
      */
     public Field[] getFields() {
         return fieldList.toArray(Field.EMPTY_ARRAY);
     }

     /**
      * Gets the file name.
      *
      * @return the file name.
      */
     public String getFileName() {
         return fileName;
     }

     /**
      * Gets the interface names.
      *
      * @return the interface names.
      */
     public String[] getInterfaceNames() {
         return interfaceList.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
     }

     /**
      * Gets the interfaces.
      *
      * @return the interfaces.
      */
     public int[] getInterfaces() {
         final int size = interfaceList.size();
         final int[] interfaces = new int[size];
         Arrays.setAll(interfaces, i -> cp.addClass(interfaceList.get(i)));
         return interfaces;
     }

     /**
      * Gets the (finally) built up Java class object.
      *
      * @return the (finally) built up Java class object.
      */
     public JavaClass getJavaClass() {
         final int[] interfaces = getInterfaces();
         final Field[] fields = getFields();
         final Method[] methods = getMethods();
         Attribute[] attributes = null;
         if (annotationList.isEmpty()) {
             attributes = getAttributes();
         } else {
             // TODO: Sometime later, trash any attributes called 'RuntimeVisibleAnnotations' or 'RuntimeInvisibleAnnotations'
             final Attribute[] annAttributes = AnnotationEntryGen.getAnnotationAttributes(cp, getAnnotationEntries());
             attributes = new Attribute[attributeList.size() + annAttributes.length];
             attributeList.toArray(attributes);
             System.arraycopy(annAttributes, 0, attributes, attributeList.size(), annAttributes.length);
         }
         // Must be last since the above calls may still add something to it
         final ConstantPool cp = this.cp.getFinalConstantPool();
         return new JavaClass(classNameIndex, superclassNameIndex, fileName, major, minor, super.getAccessFlags(), cp, interfaces, fields, methods,
             attributes);
     }

     /**
      * Gets major version number of class file.
      *
      * @return major version number of class file.
      */
     public int getMajor() {
         return major;
     }

     /**
      * Gets the method at the given position.
      *
      * @param pos the position.
      * @return the method at the given position.
      */
     public Method getMethodAt(final int pos) {
         return methodList.get(pos);
     }

     /**
      * Gets the methods.
      *
      * @return the methods.
      */
     public Method[] getMethods() {
         return methodList.toArray(Method.EMPTY_ARRAY);
     }

     /**
      * Gets minor version number of class file.
      *
      * @return minor version number of class file.
      */
     public int getMinor() {
         return minor;
     }

     /**
      * Gets the superclass name.
      *
      * @return the superclass name.
      */
     public String getSuperclassName() {
         return superClassName;
     }

     /**
      * Gets the superclass name index.
      *
      * @return the superclass name index.
      */
     public int getSuperclassNameIndex() {
         return superclassNameIndex;
     }

     /**
      * Return value as defined by given BCELComparator strategy. By default return the hash code of the class name.
      *
      * @see Object#hashCode()
      */
     @Override
     public int hashCode() {
         return bcelComparator.hashCode(this);
     }

     /**
      * Remove an attribute from this class.
      *
      * @param a attribute to remove.
      */
     public void removeAttribute(final Attribute a) {
         attributeList.remove(a);
     }

     /**
      * Remove a field to this class.
      *
      * @param f field to remove.
      */
     public void removeField(final Field f) {
         fieldList.remove(f);
     }

     /**
      * Remove an interface from this class.
      *
      * @param name interface to remove (fully qualified name).
      */
     public void removeInterface(final String name) {
         interfaceList.remove(name);
     }

     /**
      * Remove a method from this class.
      *
      * @param m method to remove.
      */
     public void removeMethod(final Method m) {
         methodList.remove(m);
     }

     /**
      * Remove observer for this object.
      *
      * @param o the observer to remove.
      */
     public void removeObserver(final ClassObserver o) {
         if (observers != null) {
             observers.remove(o);
         }
     }

     /**
      * Replace given field with new one. If the old one does not exist add the new_ field to the class anyway.
      *
      * @param old the old field.
      * @param newField the new field.
      */
     public void replaceField(final Field old, final Field newField) {
         if (newField == null) {
             throw new ClassGenException("Replacement method must not be null");
         }
         final int i = fieldList.indexOf(old);
         if (i < 0) {
             fieldList.add(newField);
         } else {
             fieldList.set(i, newField);
         }
     }

     /**
      * Replace given method with new one. If the old one does not exist add the newMethod method to the class anyway.
      *
      * @param old the old method.
      * @param newMethod the new method.
      */
     public void replaceMethod(final Method old, final Method newMethod) {
         if (newMethod == null) {
             throw new ClassGenException("Replacement method must not be null");
         }
         final int i = methodList.indexOf(old);
         if (i < 0) {
             methodList.add(newMethod);
         } else {
             methodList.set(i, newMethod);
         }
     }

     /**
      * Sets the class name.
      *
      * @param name the class name.
      */
     public void setClassName(final String name) {
         className = Utility.pathToPackage(name);
         classNameIndex = cp.addClass(name);
     }

     /**
      * Sets the class name index.
      *
      * @param classNameIndex the class name index.
      */
     public void setClassNameIndex(final int classNameIndex) {
         this.classNameIndex = classNameIndex;
         this.className = Utility.pathToPackage(cp.getConstantPool().getConstantString(classNameIndex, Const.CONSTANT_Class));
     }

     /**
      * Sets the constant pool.
      *
      * @param constantPool the constant pool.
      */
     public void setConstantPool(final ConstantPoolGen constantPool) {
         cp = constantPool;
     }

     /**
      * Sets major version number of class file, default value is 45 (JDK 1.1).
      *
      * @param major major version number.
      */
     public void setMajor(final int major) { // TODO could be package-protected - only called by test code
         this.major = major;
     }

     /**
      * Sets the method at the given position.
      *
      * @param method the method.
      * @param pos the position.
      */
     public void setMethodAt(final Method method, final int pos) {
         methodList.set(pos, method);
     }

     /**
      * Sets the methods.
      *
      * @param methods the methods.
      */
     public void setMethods(final Method[] methods) {
         methodList.clear();
         if (methods != null) {
             Collections.addAll(methodList, methods);
         }
     }

     /**
      * Sets minor version number of class file, default value is 3 (JDK 1.1).
      *
      * @param minor minor version number.
      */
     public void setMinor(final int minor) { // TODO could be package-protected - only called by test code
         this.minor = minor;
     }

     /**
      * Sets the superclass name.
      *
      * @param name the superclass name.
      */
     public void setSuperclassName(final String name) {
         superClassName = Utility.pathToPackage(name);
         superclassNameIndex = cp.addClass(name);
     }

     /**
      * Sets the superclass name index.
      *
      * @param superclassNameIndex the superclass name index.
      */
     public void setSuperclassNameIndex(final int superclassNameIndex) {
         this.superclassNameIndex = superclassNameIndex;
         superClassName = Utility.pathToPackage(cp.getConstantPool().getConstantString(superclassNameIndex, Const.CONSTANT_Class));
     }

     /**
      * Unpacks attributes representing annotations.
      */
     private AnnotationEntryGen[] unpackAnnotations(final Attribute[] attributes) {
         final List<AnnotationEntryGen> annotationGenObjs = new ArrayList<>();
         if (attributes != null) {
             for (final Attribute attr : attributes) {
                 if (attr instanceof RuntimeVisibleAnnotations) {
                     final RuntimeVisibleAnnotations rva = (RuntimeVisibleAnnotations) attr;
                     rva.forEach(a -> annotationGenObjs.add(new AnnotationEntryGen(a, getConstantPool(), false)));
                 } else if (attr instanceof RuntimeInvisibleAnnotations) {
                     final RuntimeInvisibleAnnotations ria = (RuntimeInvisibleAnnotations) attr;
                     ria.forEach(a -> annotationGenObjs.add(new AnnotationEntryGen(a, getConstantPool(), false)));
                 }
             }
         }
         return annotationGenObjs.toArray(AnnotationEntryGen.EMPTY_ARRAY);
     }

     /**
      * Call notify() method on all observers. This method is not called automatically whenever the state has changed, but
      * has to be called by the user after they have finished editing the object.
      */
     public void update() {
         if (observers != null) {
             for (final ClassObserver observer : observers) {
                 observer.notify(this);
             }
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* https://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.bcel.generic;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;
	import java.util.Objects;

	import org.apache.bcel.Const;
	import org.apache.bcel.classfile.AccessFlags;
	import org.apache.bcel.classfile.Annotations;
	import org.apache.bcel.classfile.Attribute;
	import org.apache.bcel.classfile.ConstantPool;
	import org.apache.bcel.classfile.Field;
	import org.apache.bcel.classfile.JavaClass;
	import org.apache.bcel.classfile.Method;
	import org.apache.bcel.classfile.RuntimeInvisibleAnnotations;
	import org.apache.bcel.classfile.RuntimeVisibleAnnotations;
	import org.apache.bcel.classfile.SourceFile;
	import org.apache.bcel.classfile.Utility;
	import org.apache.bcel.util.BCELComparator;
	import org.apache.commons.lang3.ArrayUtils;

	/**
	* Template class for building up a java class. May be initialized with an existing Java class (file).
	*
	* @see JavaClass
	*/
	public class ClassGen extends AccessFlags implements Cloneable {

	private static BCELComparator<ClassGen> bcelComparator = new BCELComparator<ClassGen>() {

	@Override
	public boolean equals(final ClassGen a, final ClassGen b) {
	return a == b \|\| a != null && b != null && Objects.equals(a.getClassName(), b.getClassName());
	}

	@Override
	public int hashCode(final ClassGen o) {
	return o != null ? Objects.hashCode(o.getClassName()) : 0;
	}
	};

	/**
	* Gets the comparison strategy object.
	*
	* @return Comparison strategy object.
	*/
	public static BCELComparator<ClassGen> getComparator() {
	return bcelComparator;
	}

	/**
	* Sets the comparison strategy object.
	*
	* @param comparator Comparison strategy object.
	*/
	public static void setComparator(final BCELComparator<ClassGen> comparator) {
	bcelComparator = comparator;
	}

	/*
	* Corresponds to the fields found in a JavaClass object.
	*/
	private String className;
	private String superClassName;
	private final String fileName;
	private int classNameIndex = -1;
	private int superclassNameIndex = -1;
	private int major = Const.MAJOR_1_1;
	private int minor = Const.MINOR_1_1;
	private ConstantPoolGen cp; // Template for building up constant pool
	// ArrayLists instead of arrays to gather fields, methods, etc.
	private final List<Field> fieldList = new ArrayList<>();
	private final List<Method> methodList = new ArrayList<>();

	private final List<Attribute> attributeList = new ArrayList<>();

	private final List<String> interfaceList = new ArrayList<>();

	private final List<AnnotationEntryGen> annotationList = new ArrayList<>();

	private List<ClassObserver> observers;

	/**
	* Constructs a new instance from an existing class.
	*
	* @param clazz JavaClass object (for example read from file).
	*/
	public ClassGen(final JavaClass clazz) {
	super(clazz.getAccessFlags());
	classNameIndex = clazz.getClassNameIndex();
	superclassNameIndex = clazz.getSuperclassNameIndex();
	className = clazz.getClassName();
	superClassName = clazz.getSuperclassName();
	fileName = clazz.getSourceFileName();
	cp = new ConstantPoolGen(clazz.getConstantPool());
	major = clazz.getMajor();
	minor = clazz.getMinor();
	final Attribute[] attributes = clazz.getAttributes();
	// J5TODO: Could make unpacking lazy, done on first reference
	final AnnotationEntryGen[] annotations = unpackAnnotations(attributes);
	final String[] interfaceNames = clazz.getInterfaceNames();
	if (interfaceNames != null) {
	Collections.addAll(interfaceList, interfaceNames);
	}
	if (attributes != null) {
	for (final Attribute attribute : attributes) {
	if (!(attribute instanceof Annotations)) {
	addAttribute(attribute);
	}
	}
	}
	Collections.addAll(annotationList, annotations);
	final Method[] methods = clazz.getMethods();
	if (methods != null) {
	Collections.addAll(methodList, methods);
	}
	final Field[] fields = clazz.getFields();
	if (fields != null) {
	Collections.addAll(fieldList, fields);
	}
	}

	/**
	* Convenience constructor to set up some important values initially.
	*
	* @param className fully qualified class name.
	* @param superClassName fully qualified superclass name.
	* @param fileName source file name.
	* @param accessFlags access qualifiers.
	* @param interfaces implemented interfaces.
	*/
	public ClassGen(final String className, final String superClassName, final String fileName, final int accessFlags, final String[] interfaces) {
	this(className, superClassName, fileName, accessFlags, interfaces, new ConstantPoolGen());
	}

	/**
	* Convenience constructor to set up some important values initially.
	*
	* @param className fully qualified class name.
	* @param superClassName fully qualified superclass name.
	* @param fileName source file name.
	* @param accessFlags access qualifiers.
	* @param interfaces implemented interfaces.
	* @param cp constant pool to use.
	*/
	public ClassGen(final String className, final String superClassName, final String fileName, final int accessFlags, final String[] interfaces,
	final ConstantPoolGen cp) {
	super(accessFlags);
	this.className = className;
	this.superClassName = superClassName;
	this.fileName = fileName;
	this.cp = cp;
	// Put everything needed by default into the constant pool and the vectors
	if (fileName != null) {
	addAttribute(new SourceFile(cp.addUtf8("SourceFile"), 2, cp.addUtf8(fileName), cp.getConstantPool()));
	}
	classNameIndex = cp.addClass(className);
	superclassNameIndex = cp.addClass(superClassName);
	if (interfaces != null) {
	Collections.addAll(interfaceList, interfaces);
	}
	}

	/**
	* Adds an annotation entry to this class.
	*
	* @param a the annotation entry to add.
	*/
	public void addAnnotationEntry(final AnnotationEntryGen a) {
	annotationList.add(a);
	}

	/**
	* Add an attribute to this class.
	*
	* @param a attribute to add.
	*/
	public void addAttribute(final Attribute a) {
	attributeList.add(a);
	}

	/**
	* Convenience method.
	*
	* Add an empty constructor to this class that does nothing but calling super().
	*
	* @param accessFlags rights for constructor.
	*/
	public void addEmptyConstructor(final int accessFlags) {
	final InstructionList il = new InstructionList();
	il.append(InstructionConst.THIS); // Push 'this'
	il.append(new INVOKESPECIAL(cp.addMethodref(superClassName, Const.CONSTRUCTOR_NAME, "()V")));
	il.append(InstructionConst.RETURN);
	final MethodGen mg = new MethodGen(accessFlags, Type.VOID, Type.NO_ARGS, null, Const.CONSTRUCTOR_NAME, className, il, cp);
	mg.setMaxStack(1);
	addMethod(mg.getMethod());
	}

	/**
	* Add a field to this class.
	*
	* @param f field to add.
	*/
	public void addField(final Field f) {
	fieldList.add(f);
	}

	/**
	* Add an interface to this class, that is, this class has to implement it.
	*
	* @param name interface to implement (fully qualified class name).
	*/
	public void addInterface(final String name) {
	interfaceList.add(name);
	}

	/**
	* Add a method to this class.
	*
	* @param m method to add.
	*/
	public void addMethod(final Method m) {
	methodList.add(m);
	}

	/**
	* Add observer for this object.
	*
	* @param o the observer.
	*/
	public void addObserver(final ClassObserver o) {
	if (observers == null) {
	observers = new ArrayList<>();
	}
	observers.add(o);
	}

	@Override
	public Object clone() {
	try {
	return super.clone();
	} catch (final CloneNotSupportedException e) {
	throw new UnsupportedOperationException("Clone Not Supported", e); // never happens
	}
	}

	/**
	* Checks if this class contains the given field.
	*
	* @param f the field to check.
	* @return true if this class contains the field.
	*/
	public boolean containsField(final Field f) {
	return fieldList.contains(f);
	}

	/**
	* Gets the field object with given name, or null.
	*
	* @param name the field name.
	* @return field object with given name, or null.
	*/
	public Field containsField(final String name) {
	for (final Field f : fieldList) {
	if (f.getName().equals(name)) {
	return f;
	}
	}
	return null;
	}

	/**
	* Gets the method object with given name and signature, or null.
	*
	* @param name the method name.
	* @param signature the method signature.
	* @return method object with given name and signature, or null.
	*/
	public Method containsMethod(final String name, final String signature) {
	for (final Method m : methodList) {
	if (m.getName().equals(name) && m.getSignature().equals(signature)) {
	return m;
	}
	}
	return null;
	}

	/**
	* Return value as defined by given BCELComparator strategy. By default two ClassGen objects are said to be equal when
	* their class names are equal.
	*
	* @see Object#equals(Object)
	*/
	@Override
	public boolean equals(final Object obj) {
	return obj instanceof ClassGen && bcelComparator.equals(this, (ClassGen) obj);
	}

	/**
	* Gets the annotation entries.
	*
	* @return the annotation entries.
	*/
	// J5TODO: Should we make calling unpackAnnotations() lazy and put it in here?
	public AnnotationEntryGen[] getAnnotationEntries() {
	return annotationList.toArray(AnnotationEntryGen.EMPTY_ARRAY);
	}

	/**
	* Gets the attributes.
	*
	* @return the attributes.
	*/
	public Attribute[] getAttributes() {
	return attributeList.toArray(Attribute.EMPTY_ARRAY);
	}

	/**
	* Gets the class name.
	*
	* @return the class name.
	*/
	public String getClassName() {
	return className;
	}

	/**
	* Gets the class name index.
	*
	* @return the class name index.
	*/
	public int getClassNameIndex() {
	return classNameIndex;
	}

	/**
	* Gets the constant pool.
	*
	* @return the constant pool.
	*/
	public ConstantPoolGen getConstantPool() {
	return cp;
	}

	/**
	* Gets the fields.
	*
	* @return the fields.
	*/
	public Field[] getFields() {
	return fieldList.toArray(Field.EMPTY_ARRAY);
	}

	/**
	* Gets the file name.
	*
	* @return the file name.
	*/
	public String getFileName() {
	return fileName;
	}

	/**
	* Gets the interface names.
	*
	* @return the interface names.
	*/
	public String[] getInterfaceNames() {
	return interfaceList.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
	}

	/**
	* Gets the interfaces.
	*
	* @return the interfaces.
	*/
	public int[] getInterfaces() {
	final int size = interfaceList.size();
	final int[] interfaces = new int[size];
	Arrays.setAll(interfaces, i -> cp.addClass(interfaceList.get(i)));
	return interfaces;
	}

	/**
	* Gets the (finally) built up Java class object.
	*
	* @return the (finally) built up Java class object.
	*/
	public JavaClass getJavaClass() {
	final int[] interfaces = getInterfaces();
	final Field[] fields = getFields();
	final Method[] methods = getMethods();
	Attribute[] attributes = null;
	if (annotationList.isEmpty()) {
	attributes = getAttributes();
	} else {
	// TODO: Sometime later, trash any attributes called 'RuntimeVisibleAnnotations' or 'RuntimeInvisibleAnnotations'
	final Attribute[] annAttributes = AnnotationEntryGen.getAnnotationAttributes(cp, getAnnotationEntries());
	attributes = new Attribute[attributeList.size() + annAttributes.length];
	attributeList.toArray(attributes);
	System.arraycopy(annAttributes, 0, attributes, attributeList.size(), annAttributes.length);
	}
	// Must be last since the above calls may still add something to it
	final ConstantPool cp = this.cp.getFinalConstantPool();
	return new JavaClass(classNameIndex, superclassNameIndex, fileName, major, minor, super.getAccessFlags(), cp, interfaces, fields, methods,
	attributes);
	}

	/**
	* Gets major version number of class file.
	*
	* @return major version number of class file.
	*/
	public int getMajor() {
	return major;
	}

	/**
	* Gets the method at the given position.
	*
	* @param pos the position.
	* @return the method at the given position.
	*/
	public Method getMethodAt(final int pos) {
	return methodList.get(pos);
	}

	/**
	* Gets the methods.
	*
	* @return the methods.
	*/
	public Method[] getMethods() {
	return methodList.toArray(Method.EMPTY_ARRAY);
	}

	/**
	* Gets minor version number of class file.
	*
	* @return minor version number of class file.
	*/
	public int getMinor() {
	return minor;
	}

	/**
	* Gets the superclass name.
	*
	* @return the superclass name.
	*/
	public String getSuperclassName() {
	return superClassName;
	}

	/**
	* Gets the superclass name index.
	*
	* @return the superclass name index.
	*/
	public int getSuperclassNameIndex() {
	return superclassNameIndex;
	}

	/**
	* Return value as defined by given BCELComparator strategy. By default return the hash code of the class name.
	*
	* @see Object#hashCode()
	*/
	@Override
	public int hashCode() {
	return bcelComparator.hashCode(this);
	}

	/**
	* Remove an attribute from this class.
	*
	* @param a attribute to remove.
	*/
	public void removeAttribute(final Attribute a) {
	attributeList.remove(a);
	}

	/**
	* Remove a field to this class.
	*
	* @param f field to remove.
	*/
	public void removeField(final Field f) {
	fieldList.remove(f);
	}

	/**
	* Remove an interface from this class.
	*
	* @param name interface to remove (fully qualified name).
	*/
	public void removeInterface(final String name) {
	interfaceList.remove(name);
	}

	/**
	* Remove a method from this class.
	*
	* @param m method to remove.
	*/
	public void removeMethod(final Method m) {
	methodList.remove(m);
	}

	/**
	* Remove observer for this object.
	*
	* @param o the observer to remove.
	*/
	public void removeObserver(final ClassObserver o) {
	if (observers != null) {
	observers.remove(o);
	}
	}

	/**
	* Replace given field with new one. If the old one does not exist add the new_ field to the class anyway.
	*
	* @param old the old field.
	* @param newField the new field.
	*/
	public void replaceField(final Field old, final Field newField) {
	if (newField == null) {
	throw new ClassGenException("Replacement method must not be null");
	}
	final int i = fieldList.indexOf(old);
	if (i < 0) {
	fieldList.add(newField);
	} else {
	fieldList.set(i, newField);
	}
	}

	/**
	* Replace given method with new one. If the old one does not exist add the newMethod method to the class anyway.
	*
	* @param old the old method.
	* @param newMethod the new method.
	*/
	public void replaceMethod(final Method old, final Method newMethod) {
	if (newMethod == null) {
	throw new ClassGenException("Replacement method must not be null");
	}
	final int i = methodList.indexOf(old);
	if (i < 0) {
	methodList.add(newMethod);
	} else {
	methodList.set(i, newMethod);
	}
	}

	/**
	* Sets the class name.
	*
	* @param name the class name.
	*/
	public void setClassName(final String name) {
	className = Utility.pathToPackage(name);
	classNameIndex = cp.addClass(name);
	}

	/**
	* Sets the class name index.
	*
	* @param classNameIndex the class name index.
	*/
	public void setClassNameIndex(final int classNameIndex) {
	this.classNameIndex = classNameIndex;
	this.className = Utility.pathToPackage(cp.getConstantPool().getConstantString(classNameIndex, Const.CONSTANT_Class));
	}

	/**
	* Sets the constant pool.
	*
	* @param constantPool the constant pool.
	*/
	public void setConstantPool(final ConstantPoolGen constantPool) {
	cp = constantPool;
	}

	/**
	* Sets major version number of class file, default value is 45 (JDK 1.1).
	*
	* @param major major version number.
	*/
	public void setMajor(final int major) { // TODO could be package-protected - only called by test code
	this.major = major;
	}

	/**
	* Sets the method at the given position.
	*
	* @param method the method.
	* @param pos the position.
	*/
	public void setMethodAt(final Method method, final int pos) {
	methodList.set(pos, method);
	}

	/**
	* Sets the methods.
	*
	* @param methods the methods.
	*/
	public void setMethods(final Method[] methods) {
	methodList.clear();
	if (methods != null) {
	Collections.addAll(methodList, methods);
	}
	}

	/**
	* Sets minor version number of class file, default value is 3 (JDK 1.1).
	*
	* @param minor minor version number.
	*/
	public void setMinor(final int minor) { // TODO could be package-protected - only called by test code
	this.minor = minor;
	}

	/**
	* Sets the superclass name.
	*
	* @param name the superclass name.
	*/
	public void setSuperclassName(final String name) {
	superClassName = Utility.pathToPackage(name);
	superclassNameIndex = cp.addClass(name);
	}

	/**
	* Sets the superclass name index.
	*
	* @param superclassNameIndex the superclass name index.
	*/
	public void setSuperclassNameIndex(final int superclassNameIndex) {
	this.superclassNameIndex = superclassNameIndex;
	superClassName = Utility.pathToPackage(cp.getConstantPool().getConstantString(superclassNameIndex, Const.CONSTANT_Class));
	}

	/**
	* Unpacks attributes representing annotations.
	*/
	private AnnotationEntryGen[] unpackAnnotations(final Attribute[] attributes) {
	final List<AnnotationEntryGen> annotationGenObjs = new ArrayList<>();
	if (attributes != null) {
	for (final Attribute attr : attributes) {
	if (attr instanceof RuntimeVisibleAnnotations) {
	final RuntimeVisibleAnnotations rva = (RuntimeVisibleAnnotations) attr;
	rva.forEach(a -> annotationGenObjs.add(new AnnotationEntryGen(a, getConstantPool(), false)));
	} else if (attr instanceof RuntimeInvisibleAnnotations) {
	final RuntimeInvisibleAnnotations ria = (RuntimeInvisibleAnnotations) attr;
	ria.forEach(a -> annotationGenObjs.add(new AnnotationEntryGen(a, getConstantPool(), false)));
	}
	}
	}
	return annotationGenObjs.toArray(AnnotationEntryGen.EMPTY_ARRAY);
	}

	/**
	* Call notify() method on all observers. This method is not called automatically whenever the state has changed, but
	* has to be called by the user after they have finished editing the object.
	*/
	public void update() {
	if (observers != null) {
	for (final ClassObserver observer : observers) {
	observer.notify(this);
	}
	}
	}
	}