// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   GenericRootClass.java

package hep.rootio.implementation;

import hep.rootio.*;
import hep.rootio.interfaces.RootObject;

import java.io.IOException;
import java.lang.reflect.*;
import java.util.Hashtable;
import java.util.Vector;

// Referenced classes of package hep.rootio.implementation:
//            GenericRootObject, StreamerInfo

public class GenericRootClass
    implements RootClass
{

    public GenericRootClass(String name, StreamerInfo info, RootFileReader rfr)
    {
        methodMap = new Hashtable();
        streamerInfo = info;
        this.name = name;
        this.rfr = rfr;
    }

    public void resolve(RootClassFactory factory)
        throws RootClassNotFound
    {
        streamerInfo.resolve(factory);
    }

    public String getClassName()
    {
        return name;
    }

    public RootObjectRepresentation newInstance()
    {
        GenericRootObject gen = new GenericRootObject();
        gen.init(this, streamerInfo);
        return gen;
    }

    public Object read(RootInput in)
        throws IOException
    {
        RootObjectRepresentation obj = newInstance();
        obj.read(in);
        return obj;
    }

    public RootClass[] getSuperClasses()
    {
        return streamerInfo.getSuperClasses();
    }

    public String toString()
    {
        return "RootClass: " + getClassName();
    }

    public boolean instanceOf(RootClass superClass)
    {
        if(superClass == this)
            return true;
        RootClass classes[] = getSuperClasses();
        for(int i = 0; i < classes.length; i++)
            if(classes[i].instanceOf(superClass))
                return true;

        return false;
    }

    public RootMember[] getMembers()
    {
        return streamerInfo.getMembers();
    }

    public String getJavaType()
    {
        return nameMangler.mangleClass(name);
    }

    private void addSuperClasses(Vector interFaces, RootClass klass, ClassLoader classLoader)
    {
        try
        {
            Class k = Class.forName(klass.getJavaType(), true, classLoader);
            if(interFaces.contains(k))
                return;
            if(!k.isInterface() || !(hep.rootio.interfaces.RootObject.class).isAssignableFrom(k))
                throw new RuntimeException("Invalid proxy class " + k);
            interFaces.add(k);
        }
        catch(ClassNotFoundException classnotfoundexception) { }
        RootClass superClasses[] = klass.getSuperClasses();
        for(int i = 0; i < superClasses.length; i++)
            addSuperClasses(interFaces, superClasses[i], classLoader);

    }

    public RootObject createProxy(InvocationHandler object)
    {
        try
        {
            ClassLoader classLoader = rfr.getClassLoader();
            if(proxyConstructor == null || proxyConstructor.getClass().getClassLoader() != classLoader)
            {
                if(classLoader == null)
                    classLoader = getClass().getClassLoader();
                Vector interFaces = new Vector();
                interFaces.add(hep.rootio.interfaces.RootObject.class);
                addSuperClasses(interFaces, this, classLoader);
                Class iClass[] = new Class[interFaces.size()];
                interFaces.copyInto(iClass);
                Class proxyClass = Proxy.getProxyClass(classLoader, iClass);
                proxyConstructor = proxyClass.getConstructor(new Class[] {
                    java.lang.reflect.InvocationHandler.class
                });
            }
            return (RootObject)proxyConstructor.newInstance(new Object[] {
                object
            });
        }
        catch(Throwable t)
        {
            t.printStackTrace();
        }
        throw new RuntimeException("Unable to create proxy for " + getClassName());
    }

    public int getVersion()
    {
        return streamerInfo.getVersion();
    }

    public int getCheckSum()
    {
        return streamerInfo.getCheckSum();
    }

    Hashtable getMethodMap()
    {
        return methodMap;
    }

    public boolean instanceOf(String className)
    {
        if(name.equals(className))
            return true;
        RootClass sups[] = getSuperClasses();
        for(int i = 0; i < sups.length; i++)
            if(sups[i].instanceOf(className))
                return true;

        return false;
    }

    private Constructor proxyConstructor;
    protected StreamerInfo streamerInfo;
    private String name;
    private Hashtable methodMap;
    private static final NameMangler nameMangler = NameMangler.instance();
    private RootFileReader rfr;

}