/*
 * reserved comment block
 * DO NOT REMOVE OR ALTER!
 */
/*
 * 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
 *
 *      http://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 com.sun.org.apache.bcel.internal.generic;

import java.util.ArrayList;
import java.util.List;

import com.sun.org.apache.bcel.internal.Const;
import com.sun.org.apache.bcel.internal.classfile.AccessFlags;
import com.sun.org.apache.bcel.internal.classfile.AnnotationEntry;
import com.sun.org.apache.bcel.internal.classfile.Annotations;
import com.sun.org.apache.bcel.internal.classfile.Attribute;
import com.sun.org.apache.bcel.internal.classfile.ConstantPool;
import com.sun.org.apache.bcel.internal.classfile.Field;
import com.sun.org.apache.bcel.internal.classfile.JavaClass;
import com.sun.org.apache.bcel.internal.classfile.Method;
import com.sun.org.apache.bcel.internal.classfile.RuntimeInvisibleAnnotations;
import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleAnnotations;
import com.sun.org.apache.bcel.internal.classfile.SourceFile;
import com.sun.org.apache.bcel.internal.util.BCELComparator;

Template class for building up a java class. May be initialized with an
existing java class (file).
See Also:
JavaClass
Version:
$Id: ClassGen.java 1749603 2016-06-21 20:50:19Z ggregory $/**
 * Template class for building up a java class. May be initialized with an
 * existing java class (file).
 *
 * @see JavaClass
 * @version $Id: ClassGen.java 1749603 2016-06-21 20:50:19Z ggregory $
 */
public class ClassGen extends AccessFlags implements Cloneable {

    /* Corresponds to the fields found in a JavaClass object.
     */
    private String class_name;
    private String super_class_name;
    private final String file_name;
    private int class_name_index = -1;
    private int superclass_name_index = -1;
    private int major = Const.MAJOR;
    private int minor = Const.MINOR;
    private ConstantPoolGen cp; // Template for building up constant pool
    // ArrayLists instead of arrays to gather fields, methods, etc.
    private final List<Field> field_vec = new ArrayList<>();
    private final List<Method> method_vec = new ArrayList<>();
    private final List<Attribute> attribute_vec = new ArrayList<>();
    private final List<String> interface_vec = new ArrayList<>();
    private final List<AnnotationEntryGen> annotation_vec = new ArrayList<>();

    private static BCELComparator _cmp = new BCELComparator() {

        @Override
        public boolean equals(final Object o1, final Object o2) {
            final ClassGen THIS = (ClassGen) o1;
            final ClassGen THAT = (ClassGen) o2;
            return THIS.getClassName().equals(THAT.getClassName());
        }

        @Override
        public int hashCode(final Object o) {
            final ClassGen THIS = (ClassGen) o;
            return THIS.getClassName().hashCode();
        }
    };

    
Convenience constructor to set up some important values initially.
Params:
class_name – fully qualified class name
super_class_name – fully qualified superclass name
file_name – source file name
access_flags – access qualifiers
interfaces – implemented interfaces
cp – constant pool to use/**
     * Convenience constructor to set up some important values initially.
     *
     * @param class_name fully qualified class name
     * @param super_class_name fully qualified superclass name
     * @param file_name source file name
     * @param access_flags access qualifiers
     * @param interfaces implemented interfaces
     * @param cp constant pool to use
     */
    public ClassGen(final String class_name, final String super_class_name, final String file_name, final int access_flags,
            final String[] interfaces, final ConstantPoolGen cp) {
        super(access_flags);
        this.class_name = class_name;
        this.super_class_name = super_class_name;
        this.file_name = file_name;
        this.cp = cp;
        // Put everything needed by default into the constant pool and the vectors
        if (file_name != null) {
            addAttribute(new SourceFile(cp.addUtf8("SourceFile"), 2, cp.addUtf8(file_name), cp
                    .getConstantPool()));
        }
        class_name_index = cp.addClass(class_name);
        superclass_name_index = cp.addClass(super_class_name);
        if (interfaces != null) {
            for (final String interface1 : interfaces) {
                addInterface(interface1);
            }
        }
    }

    
Convenience constructor to set up some important values initially.
Params:
class_name – fully qualified class name
super_class_name – fully qualified superclass name
file_name – source file name
access_flags – access qualifiers
interfaces – implemented interfaces/**
     * Convenience constructor to set up some important values initially.
     *
     * @param class_name fully qualified class name
     * @param super_class_name fully qualified superclass name
     * @param file_name source file name
     * @param access_flags access qualifiers
     * @param interfaces implemented interfaces
     */
    public ClassGen(final String class_name, final String super_class_name, final String file_name, final int access_flags,
            final String[] interfaces) {
        this(class_name, super_class_name, file_name, access_flags, interfaces,
                new ConstantPoolGen());
    }

    
Initialize with existing class.
Params:
clazz – JavaClass object (e.g. read from file)/**
     * Initialize with existing class.
     *
     * @param clazz JavaClass object (e.g. read from file)
     */
    public ClassGen(final JavaClass clazz) {
        super(clazz.getAccessFlags());
        class_name_index = clazz.getClassNameIndex();
        superclass_name_index = clazz.getSuperclassNameIndex();
        class_name = clazz.getClassName();
        super_class_name = clazz.getSuperclassName();
        file_name = 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 Method[] methods = clazz.getMethods();
        final Field[] fields = clazz.getFields();
        final String[] interfaces = clazz.getInterfaceNames();
        for (final String interface1 : interfaces) {
            addInterface(interface1);
        }
        for (final Attribute attribute : attributes) {
            if (!(attribute instanceof Annotations)) {
                addAttribute(attribute);
            }
        }
        for (final AnnotationEntryGen annotation : annotations) {
            addAnnotationEntry(annotation);
        }
        for (final Method method : methods) {
            addMethod(method);
        }
        for (final Field field : fields) {
            addField(field);
        }
    }

    
Look for attributes representing annotations and unpack them.
/**
     * Look for attributes representing annotations and unpack them.
     */
    private AnnotationEntryGen[] unpackAnnotations(final Attribute[] attrs) {
        final List<AnnotationEntryGen> annotationGenObjs = new ArrayList<>();
        for (final Attribute attr : attrs) {
            if (attr instanceof RuntimeVisibleAnnotations) {
                final RuntimeVisibleAnnotations rva = (RuntimeVisibleAnnotations) attr;
                final AnnotationEntry[] annos = rva.getAnnotationEntries();
                for (final AnnotationEntry a : annos) {
                    annotationGenObjs.add(new AnnotationEntryGen(a,
                            getConstantPool(), false));
                }
            } else if (attr instanceof RuntimeInvisibleAnnotations) {
                final RuntimeInvisibleAnnotations ria = (RuntimeInvisibleAnnotations) attr;
                final AnnotationEntry[] annos = ria.getAnnotationEntries();
                for (final AnnotationEntry a : annos) {
                    annotationGenObjs.add(new AnnotationEntryGen(a,
                            getConstantPool(), false));
                }
            }
        }
        return annotationGenObjs.toArray(new AnnotationEntryGen[annotationGenObjs.size()]);
    }

    
Returns:
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;
        if (annotation_vec.isEmpty()) {
            attributes = getAttributes();
        } else {
            // TODO: Sometime later, trash any attributes called 'RuntimeVisibleAnnotations' or 'RuntimeInvisibleAnnotations'
            final Attribute[] annAttributes = AnnotationEntryGen.getAnnotationAttributes(cp, getAnnotationEntries());
            attributes = new Attribute[attribute_vec.size() + annAttributes.length];
            attribute_vec.toArray(attributes);
            System.arraycopy(annAttributes, 0, attributes, attribute_vec.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(class_name_index, superclass_name_index, file_name, major, minor,
                super.getAccessFlags(), _cp, interfaces, fields, methods, attributes);
    }

    
Add an interface to this class, i.e., this class has to implement it.
Params:
name – interface to implement (fully qualified class name)/**
     * Add an interface to this class, i.e., this class has to implement it.
     *
     * @param name interface to implement (fully qualified class name)
     */
    public final void addInterface(final String name) {
        interface_vec.add(name);
    }

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

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

    
Set major version number of class file, default value is 45 (JDK 1.1)
Params:
major – major version number/**
     * Set 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;
    }

    
Set minor version number of class file, default value is 3 (JDK 1.1)
Params:
minor – minor version number/**
     * Set 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;
    }

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

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

    public final void addAnnotationEntry(final AnnotationEntryGen a) {
        annotation_vec.add(a);
    }

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

    
Convenience method.
Add an empty constructor to this class that does nothing but calling
super().
Params:
access_flags – rights for constructor/**
     * Convenience method.
     *
     * Add an empty constructor to this class that does nothing but calling
     * super().
     *
     * @param access_flags rights for constructor
     */
    public void addEmptyConstructor(final int access_flags) {
        final InstructionList il = new InstructionList();
        il.append(InstructionConst.THIS); // Push `this'
        il.append(new INVOKESPECIAL(cp.addMethodref(super_class_name, "<init>", "()V")));
        il.append(InstructionConst.RETURN);
        final MethodGen mg = new MethodGen(access_flags, Type.VOID, Type.NO_ARGS, null, "<init>",
                class_name, il, cp);
        mg.setMaxStack(1);
        addMethod(mg.getMethod());
    }

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

    public boolean containsField(final Field f) {
        return field_vec.contains(f);
    }

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

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

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

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

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

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

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

    public String getClassName() {
        return class_name;
    }

    public String getSuperclassName() {
        return super_class_name;
    }

    public String getFileName() {
        return file_name;
    }

    public void setClassName(final String name) {
        class_name = name.replace('/', '.');
        class_name_index = cp.addClass(name);
    }

    public void setSuperclassName(final String name) {
        super_class_name = name.replace('/', '.');
        superclass_name_index = cp.addClass(name);
    }

    public Method[] getMethods() {
        return method_vec.toArray(new Method[method_vec.size()]);
    }

    public void setMethods(final Method[] methods) {
        method_vec.clear();
        for (final Method method : methods) {
            addMethod(method);
        }
    }

    public void setMethodAt(final Method method, final int pos) {
        method_vec.set(pos, method);
    }

    public Method getMethodAt(final int pos) {
        return method_vec.get(pos);
    }

    public String[] getInterfaceNames() {
        final int size = interface_vec.size();
        final String[] interfaces = new String[size];
        interface_vec.toArray(interfaces);
        return interfaces;
    }

    public int[] getInterfaces() {
        final int size = interface_vec.size();
        final int[] interfaces = new int[size];
        for (int i = 0; i < size; i++) {
            interfaces[i] = cp.addClass(interface_vec.get(i));
        }
        return interfaces;
    }

    public Field[] getFields() {
        return field_vec.toArray(new Field[field_vec.size()]);
    }

    public Attribute[] getAttributes() {
        return attribute_vec.toArray(new Attribute[attribute_vec.size()]);
    }

    //  J5TODO: Should we make calling unpackAnnotations() lazy and put it in here?
    public AnnotationEntryGen[] getAnnotationEntries() {
        return annotation_vec.toArray(new AnnotationEntryGen[annotation_vec.size()]);
    }

    public ConstantPoolGen getConstantPool() {
        return cp;
    }

    public void setConstantPool(final ConstantPoolGen constant_pool) {
        cp = constant_pool;
    }

    public void setClassNameIndex(final int class_name_index) {
        this.class_name_index = class_name_index;
        class_name = cp.getConstantPool().getConstantString(class_name_index,
                Const.CONSTANT_Class).replace('/', '.');
    }

    public void setSuperclassNameIndex(final int superclass_name_index) {
        this.superclass_name_index = superclass_name_index;
        super_class_name = cp.getConstantPool().getConstantString(superclass_name_index,
                Const.CONSTANT_Class).replace('/', '.');
    }

    public int getSuperclassNameIndex() {
        return superclass_name_index;
    }

    public int getClassNameIndex() {
        return class_name_index;
    }

    private List<ClassObserver> observers;

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

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

    
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 he has finished editing the object.
/**
     * 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 he has finished editing the object.
     */
    public void update() {
        if (observers != null) {
            for (final ClassObserver observer : observers) {
                observer.notify(this);
            }
        }
    }

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

    
Returns:
Comparison strategy object/**
     * @return Comparison strategy object
     */
    public static BCELComparator getComparator() {
        return _cmp;
    }

    
Params:
comparator – Comparison strategy object/**
     * @param comparator Comparison strategy object
     */
    public static void setComparator(final BCELComparator comparator) {
        _cmp = comparator;
    }

    
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 Also:
equals.equals(Object)/**
     * 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 java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(final Object obj) {
        return _cmp.equals(this, obj);
    }

    
Return value as defined by given BCELComparator strategy. By default
return the hashcode of the class name.
See Also:
hashCode.hashCode()/**
     * Return value as defined by given BCELComparator strategy. By default
     * return the hashcode of the class name.
     *
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        return _cmp.hashCode(this);
    }
}