/*

 */

/*

 * 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.classfile;

import java.io.ByteArrayOutputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import java.util.TreeSet;

import com.sun.org.apache.bcel.internal.Const;

import com.sun.org.apache.bcel.internal.generic.Type;

import com.sun.org.apache.bcel.internal.util.BCELComparator;

import com.sun.org.apache.bcel.internal.util.ClassQueue;

import com.sun.org.apache.bcel.internal.util.SyntheticRepository;

/**

 * Represents a Java class, i.e., the data structures, constant pool, fields,

 * methods and commands contained in a Java .class file. See <a

 * href="http://docs.oracle.com/javase/specs/">JVM specification</a> for

 * details. The intent of this class is to represent a parsed or otherwise

 * existing class file. Those interested in programatically generating classes

 * should see the <a href="../generic/ClassGen.html">ClassGen</a> class.

 * @see com.sun.org.apache.bcel.internal.generic.ClassGen

 */

public class JavaClass extends AccessFlags implements Cloneable, Node, Comparable<JavaClass> {

    private String file_name;

    private String package_name;

    private String source_file_name = "<Unknown>";

    private int class_name_index;

    private int superclass_name_index;

    private String class_name;

    private String superclass_name;

    private int major;

    private int minor; // Compiler version

    private ConstantPool constant_pool; // Constant pool

    private int[] interfaces; // implemented interfaces

    private String[] interface_names;

    private Field[] fields; // Fields, i.e., variables of class

    private Method[] methods; // methods defined in the class

    private Attribute[] attributes; // attributes defined in the class

    private AnnotationEntry[] annotations;   // annotations defined on the class

    private byte source = HEAP; // Generated in memory

    private boolean isAnonymous = false;

    private boolean isNested = false;

    private boolean computedNestedTypeStatus = false;

    public static final byte HEAP = 1;

    public static final byte FILE = 2;

    public static final byte ZIP = 3;

    private static BCELComparator bcelComparator = new BCELComparator() {

        @Override

            final JavaClass THIS = (JavaClass) o1;

            final JavaClass THAT = (JavaClass) o2;

        }

        @Override

            final JavaClass THIS = (JavaClass) o;

            return THIS.getClassName().hashCode();

        }

    };

    /**

     */

    private transient com.sun.org.apache.bcel.internal.util.Repository repository

            = SyntheticRepository.getInstance();

    /**

     * Constructor gets all contents as arguments.

     *

     * @param class_name_index Index into constant pool referencing a

     * ConstantClass that represents this class.

     * @param superclass_name_index Index into constant pool referencing a

     * ConstantClass that represents this class's superclass.

     * @param file_name File name

     * @param major Major compiler version

     * @param minor Minor compiler version

     * @param access_flags Access rights defined by bit flags

     * @param constant_pool Array of constants

     * @param interfaces Implemented interfaces

     * @param fields Class fields

     * @param methods Class methods

     * @param attributes Class attributes

     * @param source Read from file or generated in memory?

     */

    public JavaClass(final int class_name_index, final int superclass_name_index,

            final String file_name, final int major, final int minor, final int access_flags,

            final ConstantPool constant_pool, int[] interfaces, Field[] fields,

            Method[] methods, Attribute[] attributes, final byte source) {

        super(access_flags);

        if (interfaces == null) {

            interfaces = new int[0];

        }

        if (attributes == null) {

            attributes = new Attribute[0];

        }

        if (fields == null) {

            fields = new Field[0];

        }

        if (methods == null) {

            methods = new Method[0];

        }

        this.class_name_index = class_name_index;

        this.superclass_name_index = superclass_name_index;

        this.file_name = file_name;

        this.major = major;

        this.minor = minor;

        this.constant_pool = constant_pool;

        this.interfaces = interfaces;

        this.fields = fields;

        this.methods = methods;

        this.attributes = attributes;

        this.source = source;

        // Get source file name if available

        for (final Attribute attribute : attributes) {

            if (attribute instanceof SourceFile) {

                source_file_name = ((SourceFile) attribute).getSourceFileName();

                break;

            }

        }

        /* According to the specification the following entries must be of type

         * `ConstantClass' but we check that anyway via the

         * `ConstPool.getConstant' method.

         */

        class_name = constant_pool.getConstantString(class_name_index, Const.CONSTANT_Class);

        class_name = Utility.compactClassName(class_name, false);

        final int index = class_name.lastIndexOf('.');

        if (index < 0) {

            package_name = "";

        } else {

            package_name = class_name.substring(0, index);

        }

        if (superclass_name_index > 0) {

            // May be zero -> class is java.lang.Object

            superclass_name = constant_pool.getConstantString(superclass_name_index,

                    Const.CONSTANT_Class);

            superclass_name = Utility.compactClassName(superclass_name, false);

        } else {

            superclass_name = "java.lang.Object";

        }

        interface_names = new String[interfaces.length];

        for (int i = 0; i < interfaces.length; i++) {

            final String str = constant_pool.getConstantString(interfaces[i], Const.CONSTANT_Class);

            interface_names[i] = Utility.compactClassName(str, false);

        }

    }

    /**

     * Constructor gets all contents as arguments.

     *

     * @param class_name_index Class name

     * @param superclass_name_index Superclass name

     * @param file_name File name

     * @param major Major compiler version

     * @param minor Minor compiler version

     * @param access_flags Access rights defined by bit flags

     * @param constant_pool Array of constants

     * @param interfaces Implemented interfaces

     * @param fields Class fields

     * @param methods Class methods

     * @param attributes Class attributes

     */

    public JavaClass(final int class_name_index, final int superclass_name_index,

            final String file_name, final int major, final int minor, final int access_flags,

            final ConstantPool constant_pool, final int[] interfaces, final Field[] fields,

            final Method[] methods, final Attribute[] attributes) {

        this(class_name_index, superclass_name_index, file_name, major, minor, access_flags,

                constant_pool, interfaces, fields, methods, attributes, HEAP);

    }

    /**

     * defined by the contents of a Java class. I.e., the hierarchy of methods,

     * fields, attributes, etc. spawns a tree of objects.

     *

     * @param v Visitor object

     */

    @Override

        v.visitJavaClass(this);

    }

    /**

     * Dump class to a file.

     *

     * @param file Output file

     * @throws IOException

     */

    public void dump(final File file) throws IOException {

        final String parent = file.getParent();

        if (parent != null) {

            final File dir = new File(parent);

            if (!dir.mkdirs()) { // either was not created or already existed

                    throw new IOException("Could not create the directory " + dir);

                }

            }

        }

        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(file))) {

            dump(dos);

        }

    }

    /**

     * Dump class to a file named file_name.

     *

     * @param _file_name Output file name

     * @throws IOException

     */

        dump(new File(_file_name));

    }

    /**

     * @return class in binary format

     */

    public byte[] getBytes() {

        final ByteArrayOutputStream s = new ByteArrayOutputStream();

        final DataOutputStream ds = new DataOutputStream(s);

        try {

            dump(ds);

        } catch (final IOException e) {

            System.err.println("Error dumping class: " + e.getMessage());

        } finally {

            try {

                ds.close();

            } catch (final IOException e2) {

                System.err.println("Error dumping class: " + e2.getMessage());

            }

        }

        return s.toByteArray();

    }

    /**

     * Dump Java class to output stream in binary format.

     *

     * @param file Output stream

     * @throws IOException

     */

        file.writeInt(Const.JVM_CLASSFILE_MAGIC);

        file.writeShort(minor);

        file.writeShort(major);

        constant_pool.dump(file);

        file.writeShort(super.getAccessFlags());

        file.writeShort(class_name_index);

        file.writeShort(superclass_name_index);

        file.writeShort(interfaces.length);

        for (final int interface1 : interfaces) {

            file.writeShort(interface1);

        }

        file.writeShort(fields.length);

        for (final Field field : fields) {

            field.dump(file);

        }

        file.writeShort(methods.length);

        for (final Method method : methods) {

            method.dump(file);

        }

        if (attributes != null) {

            file.writeShort(attributes.length);

            for (final Attribute attribute : attributes) {

                attribute.dump(file);

            }

        } else {

            file.writeShort(0);

        }

        file.flush();

    }

    /**

     * @return Attributes of the class.

     */

    public Attribute[] getAttributes() {

        return attributes;

    }

    /**

     * @return Annotations on the class

     * @since 6.0

     */

    public AnnotationEntry[] getAnnotationEntries() {

        if (annotations == null) {

            annotations = AnnotationEntry.createAnnotationEntries(getAttributes());

        }

        return annotations;

    }

    /**

     * @return Class name.

     */

    public String getClassName() {

        return class_name;

    }

    /**

     * @return Package name.

     */

    public String getPackageName() {

        return package_name;

    }

    /**

     * @return Class name index.

     */

    public int getClassNameIndex() {

        return class_name_index;

    }

    /**

     * @return Constant pool.

     */

    public ConstantPool getConstantPool() {

        return constant_pool;

    }

    /**

     */

    public Field[] getFields() {

        return fields;

    }

    /**

     * @return File name of class, aka SourceFile attribute value

     */

    public String getFileName() {

        return file_name;

    }

    /**

     * @return Names of implemented interfaces.

     */

    public String[] getInterfaceNames() {

        return interface_names;

    }

    /**

     * @return Indices in constant pool of implemented interfaces.

     */

    public int[] getInterfaceIndices() {

        return interfaces;

    }

    /**

     * @return Major number of class file version.

     */

    public int getMajor() {

        return major;

    }

    /**

     * @return Methods of the class.

     */

    public Method[] getMethods() {

        return methods;

    }

    /**

     */

        for (final Method method : methods) {

            if (m.getName().equals(method.getName()) && (m.getModifiers() == method.getModifiers())

                    && Type.getSignature(m).equals(method.getSignature())) {

                return method;

            }

        }

        return null;

    }

    /**

     * @return Minor number of class file version.

     */

    public int getMinor() {

        return minor;

    }

    /**

     * @return sbsolute path to file where this class was read from

     */

    public String getSourceFileName() {

        return source_file_name;

    }

    /**

     *

     * @return Superclass name.

     */

    public String getSuperclassName() {

        return superclass_name;

    }

    /**

     * @return Class name index.

     */

    public int getSuperclassNameIndex() {

        return superclass_name_index;

    }

    /**

     * @param attributes .

     */

        this.attributes = attributes;

    }

    /**

     * @param class_name .

     */

        this.class_name = class_name;

    }