/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 * The Original Code is HAT. The Initial Developer of the

 * Original Code is Bill Foote, with contributions from others

 * at JavaSoft/Sun.

 */

package com.sun.tools.hat.internal.model;

import java.util.Vector;

import java.util.Enumeration;

import com.sun.tools.hat.internal.util.CompositeEnumeration;

import com.sun.tools.hat.internal.parser.ReadBuffer;

/**

 *

 * @author      Bill Foote

 */

public class JavaClass extends JavaHeapObject {

    // my id

    private long id;

    // my name

    private String name;

    // These are JavaObjectRef before resolve

    private JavaThing superclass;

    private JavaThing loader;

    private JavaThing signers;

    private JavaThing protectionDomain;

    // non-static fields

    private JavaField[] fields;

    // static fields

    private JavaStatic[] statics;

    private static final JavaClass[] EMPTY_CLASS_ARRAY = new JavaClass[0];

    // my subclasses

    private JavaClass[] subclasses = EMPTY_CLASS_ARRAY;

    // my instances

    private Vector<JavaHeapObject> instances = new Vector<JavaHeapObject>();

    // Who I belong to.  Set on resolve.

    private Snapshot mySnapshot;

    // Size of an instance, including VM overhead

    private int instanceSize;

    // Total number of fields including inherited ones

    private int totalNumFields;

    public JavaClass(long id, String name, long superclassId, long loaderId,

                     long signersId, long protDomainId,

                     JavaField[] fields, JavaStatic[] statics,

                     int instanceSize) {

        this.id = id;

        this.name = name;

        this.superclass = new JavaObjectRef(superclassId);

        this.loader = new JavaObjectRef(loaderId);

        this.signers = new JavaObjectRef(signersId);

        this.protectionDomain = new JavaObjectRef(protDomainId);

        this.fields = fields;

        this.statics = statics;

        this.instanceSize = instanceSize;

    }

    public JavaClass(String name, long superclassId, long loaderId,

                     long signersId, long protDomainId,

                     JavaField[] fields, JavaStatic[] statics,

                     int instanceSize) {

        this(-1L, name, superclassId, loaderId, signersId,

             protDomainId, fields, statics, instanceSize);

    }

    public final JavaClass getClazz() {

        return mySnapshot.getJavaLangClass();

    }

    public final int getIdentifierSize() {

        return mySnapshot.getIdentifierSize();

    }

    public final int getMinimumObjectSize() {

        return mySnapshot.getMinimumObjectSize();

    }

    public void resolve(Snapshot snapshot) {

        if (mySnapshot != null) {

            return;

        }

        mySnapshot = snapshot;

        resolveSuperclass(snapshot);

        if (superclass != null) {

            ((JavaClass) superclass).addSubclass(this);

        }

        loader  = loader.dereference(snapshot, null);

        signers  = signers.dereference(snapshot, null);

        protectionDomain  = protectionDomain.dereference(snapshot, null);

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

            statics[i].resolve(this, snapshot);

        }

        snapshot.getJavaLangClass().addInstance(this);

        super.resolve(snapshot);

        return;

    }

    /**

     * Resolve our superclass.  This might be called well before

     * all instances are available (like when reading deferred

     * instances in a 1.2 dump file :-)  Calling this is sufficient

     * to be able to explore this class' fields.

     */

    public void resolveSuperclass(Snapshot snapshot) {

        if (superclass == null) {

            // We must be java.lang.Object, so we have no superclass.

        } else {

            totalNumFields = fields.length;

            superclass = superclass.dereference(snapshot, null);

            if (superclass == snapshot.getNullThing()) {

                superclass = null;

            } else {

                try {

                    JavaClass sc = (JavaClass) superclass;

                    sc.resolveSuperclass(snapshot);

                    totalNumFields += sc.totalNumFields;

                } catch (ClassCastException ex) {

                    System.out.println("Warning!  Superclass of " + name + " is " + superclass);

                    superclass = null;

                }

            }

        }

    }

    public boolean isString() {

        return mySnapshot.getJavaLangString() == this;

    }

    public boolean isClassLoader() {

        return mySnapshot.getJavaLangClassLoader().isAssignableFrom(this);

    }

    /**

     * Get a numbered field from this class

     */

    public JavaField getField(int i) {

        if (i < 0 || i >= fields.length) {

            throw new Error("No field " + i + " for " + name);

        }

        return fields[i];

    }

    /**

     * Get the total number of fields that are part of an instance of

     * this class.  That is, include superclasses.

     */

    public int getNumFieldsForInstance() {

        return totalNumFields;

    }

    /**

     * Get a numbered field from all the fields that are part of instance

     * of this class.  That is, include superclasses.

     */

    public JavaField getFieldForInstance(int i) {

        if (superclass != null) {

            JavaClass sc = (JavaClass) superclass;

            if (i < sc.totalNumFields) {

                return sc.getFieldForInstance(i);

            }

            i -= sc.totalNumFields;

        }

        return getField(i);

    }

    /**

     * Get the class responsible for field i, where i is a field number that

     * could be passed into getFieldForInstance.

     *

     * @see JavaClass.getFieldForInstance()

     */

    public JavaClass getClassForField(int i) {

        if (superclass != null) {

            JavaClass sc = (JavaClass) superclass;

            if (i < sc.totalNumFields) {

                return sc.getClassForField(i);

            }

        }

        return this;

    }

    public long getId() {

        return id;

    }

    public String getName() {

        return name;

    }

    public boolean isArray() {

        return name.indexOf('[') != -1;

    }

    public Enumeration getInstances(boolean includeSubclasses) {

        if (includeSubclasses) {

            Enumeration res = instances.elements();

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

                res = new CompositeEnumeration(res,

                              subclasses[i].getInstances(true));

            }

            return res;

        } else {

            return instances.elements();

        }

    }

    /**

     * @return a count of the instances of this class

     */

    public int getInstancesCount(boolean includeSubclasses) {

        int result = instances.size();

        if (includeSubclasses) {

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

                result += subclasses[i].getInstancesCount(includeSubclasses);

            }

        }

        return result;

    }

    public JavaClass[] getSubclasses() {

        return subclasses;

    }

    /**

     * This can only safely be called after resolve()

     */

    public JavaClass getSuperclass() {

        return (JavaClass) superclass;

    }

    /**

     * This can only safely be called after resolve()

     */

    public JavaThing getLoader() {

        return loader;

    }

    /**

     * This can only safely be called after resolve()

     */

    public boolean isBootstrap() {

        return loader == mySnapshot.getNullThing();

    }

    /**

     * This can only safely be called after resolve()

     */

    public JavaThing getSigners() {

        return signers;

    }

    /**

     * This can only safely be called after resolve()

     */

    public JavaThing getProtectionDomain() {

        return protectionDomain;

    }

    public JavaField[] getFields() {

        return fields;

    }

    /**

     * Includes superclass fields

     */

    public JavaField[] getFieldsForInstance() {

        Vector<JavaField> v = new Vector<JavaField>();

        addFields(v);

        JavaField[] result = new JavaField[v.size()];

        for (int i = 0; i < v.size(); i++) {

            result[i] =  v.elementAt(i);

        }

        return result;

    }

    public JavaStatic[] getStatics() {

        return statics;

    }

    // returns value of static field of given name

    public JavaThing getStaticField(String name) {

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

            JavaStatic s = statics[i];

            if (s.getField().getName().equals(name)) {

                return s.getValue();

            }

        }

        return null;

    }

    public String toString() {

        return "class " + name;

    }

    public int compareTo(JavaThing other) {

        if (other instanceof JavaClass) {

            return name.compareTo(((JavaClass) other).name);

        }

        return super.compareTo(other);

    }

    /**

     * @return true iff a variable of type this is assignable from an instance

     *          of other

     */

    public boolean isAssignableFrom(JavaClass other) {

        if (this == other) {

            return true;

        } else if (other == null) {

            return false;

        } else {

            return isAssignableFrom((JavaClass) other.superclass);

            // Trivial tail recursion:  I have faith in javac.

        }

    }

    /**

     * Describe the reference that this thing has to target.  This will only

     * be called if target is in the array returned by getChildrenForRootset.

     */

     public String describeReferenceTo(JavaThing target, Snapshot ss) {

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

            JavaField f = statics[i].getField();

            if (f.hasId()) {

                JavaThing other = statics[i].getValue();

                if (other == target) {

                    return "static field " + f.getName();

                }

            }

        }

        return super.describeReferenceTo(target, ss);

    }

    /**

     * @return the size of an instance of this class.  Gives 0 for an array

     *          type.

     */

    public int getInstanceSize() {

        return instanceSize + mySnapshot.getMinimumObjectSize();

    }

    /**

     * @return The size of all instances of this class.  Correctly handles

     *          arrays.

     */

    public long getTotalInstanceSize() {

        int count = instances.size();

        if (count == 0 || !isArray()) {

            return count * instanceSize;

        }

        // array class and non-zero count, we have to

        // get the size of each instance and sum it

        long result = 0;

        for (int i = 0; i < count; i++) {

            JavaThing t = (JavaThing) instances.elementAt(i);

            result += t.getSize();

        }

        return result;

    }

    /**

     * @return the size of this object

     */

    public int getSize() {

        JavaClass cl = mySnapshot.getJavaLangClass();

        if (cl == null) {

            return 0;

        } else {

            return cl.getInstanceSize();

        }

    }

    public void visitReferencedObjects(JavaHeapObjectVisitor v) {

        super.visitReferencedObjects(v);

        JavaHeapObject sc = getSuperclass();

        if (sc != null) v.visit(getSuperclass());

        JavaThing other;

        other = getLoader();

        if (other instanceof JavaHeapObject) {

            v.visit((JavaHeapObject)other);

        }

        other = getSigners();

        if (other instanceof JavaHeapObject) {

            v.visit((JavaHeapObject)other);

        }

        other = getProtectionDomain();

        if (other instanceof JavaHeapObject) {

            v.visit((JavaHeapObject)other);

        }

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

            JavaField f = statics[i].getField();

            if (!v.exclude(this, f) && f.hasId()) {

                other = statics[i].getValue();

                if (other instanceof JavaHeapObject) {

                    v.visit((JavaHeapObject) other);

                }

            }

        }

    }

    // package-privates below this point

    final ReadBuffer getReadBuffer() {

        return mySnapshot.getReadBuffer();

    }

    final void setNew(JavaHeapObject obj, boolean flag) {

        mySnapshot.setNew(obj, flag);

    }

    final boolean isNew(JavaHeapObject obj) {

        return mySnapshot.isNew(obj);

    }

    final StackTrace getSiteTrace(JavaHeapObject obj) {

        return mySnapshot.getSiteTrace(obj);

    }

    final void addReferenceFromRoot(Root root, JavaHeapObject obj) {

        mySnapshot.addReferenceFromRoot(root, obj);

    }

    final Root getRoot(JavaHeapObject obj) {

        return mySnapshot.getRoot(obj);

    }

    final Snapshot getSnapshot() {

        return mySnapshot;

    }

    void addInstance(JavaHeapObject inst) {

        instances.addElement(inst);

    }

    // Internals only below this point

    private void addFields(Vector<JavaField> v) {

        if (superclass != null) {

            ((JavaClass) superclass).addFields(v);

        }

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

            v.addElement(fields[i]);

        }

    }

    private void addSubclassInstances(Vector<JavaHeapObject> v) {

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

            subclasses[i].addSubclassInstances(v);

        }

        for (int i = 0; i < instances.size(); i++) {

            v.addElement(instances.elementAt(i));

        }

    }

    private void addSubclass(JavaClass sub) {

        JavaClass newValue[] = new JavaClass[subclasses.length + 1];

        System.arraycopy(subclasses, 0, newValue, 0, subclasses.length);

        newValue[subclasses.length] = sub;

        subclasses = newValue;

    }

}