// 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:   AbstractRootObject.java

package hep.rootio.implementation;

import hep.rootio.*;

import java.io.IOException;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Hashtable;

public abstract class AbstractRootObject
    implements RootObjectRepresentation
{

    public AbstractRootObject()
    {
        expectedEnd = 0L;
        hash = new Hashtable();
        mangledHash = new Hashtable();
        superClasses = new RootObjectRepresentation[10];
    }

    public void init(RootClass rootClass)
    {
        this.rootClass = rootClass;
        superClasses = createSuperClasses();
    }

    private RootObjectRepresentation[] createSuperClasses()
    {
        RootClass superClasses[] = rootClass.getSuperClasses();
        if(superClasses.length == 0)
            return noSuperClasses;
        RootObjectRepresentation result[] = new RootObjectRepresentation[superClasses.length];
        for(int i = 0; i < result.length; i++)
            result[i] = superClasses[i].newInstance();

        return result;
    }

    public void read(RootInput in)
        throws IOException
    {
        try
        {
            int v = in.readVersion(this);
            RootObjectRepresentation superClasses[] = getSuperClasses();
            for(int i = 0; i < superClasses.length; i++)
                superClasses[i].read(in);

            readMembers(in, v);
            in.checkLength(this);
        }
        catch(IOException x)
        {
            System.err.println("Error occured while reading " + getRootClass());
            dump();
            throw x;
        }
    }

    protected abstract void readMembers(RootInput rootinput, int i)
        throws IOException;

    protected void put(String name, Object s)
    {
        if(s != null)
        {
            hash.put(name, s);
            mangledHash.put(nameMangler.mangleMember(name), s);
        }
    }

    public Enumeration members()
    {
        return hash.keys();
    }

    public int nMembers()
    {
        return hash.size();
    }

    public Object get(String name)
    {
        Object result = hash.get(name);
        if(result != null)
            return result;
        RootObjectRepresentation superClasses[] = getSuperClasses();
        for(int i = superClasses.length - 1; i >= 0; i--)
        {
            result = superClasses[i].get(name);
            if(result != null)
                return result;
        }

        return null;
    }

    public Object getMangled(String name)
    {
        Object result = mangledHash.get(name);
        if(result != null)
            return result;
        RootObjectRepresentation superClasses[] = getSuperClasses();
        for(int i = superClasses.length - 1; i >= 0; i--)
        {
            result = superClasses[i].getMangled(name);
            if(result != null)
                return result;
        }

        return null;
    }

    public void dump()
    {
        dump(System.out);
    }

    public void dump(PrintStream out)
    {
        out.println("Object Class " + getRootClass());
        Object key;
        Object value;
        for(Enumeration keys = hash.keys(); keys.hasMoreElements(); out.println("  " + key + "=" + value))
        {
            key = keys.nextElement();
            value = hash.get(key);
        }

    }

    void setExpectedLength(long start, int len)
    {
        length = len;
        expectedEnd = start + (long)len;
    }

    void checkLength(long end)
        throws IOException
    {
        if(expectedEnd != 0L && expectedEnd != end)
            throw new IOException("Error reading " + getRootClass().getClassName() + ": Unexpected length (expected " + length + " got " + ((end - expectedEnd) + (long)length) + ")");
        else
            return;
    }

    public RootObjectRepresentation[] getSuperClasses()
    {
        return superClasses;
    }

    public RootClass getRootClass()
    {
        return rootClass;
    }

    public RootObjectRepresentation getSuperClass(String name)
    {
        if(rootClass.getClassName().equals(name))
            return this;
        for(int i = superClasses.length; i-- > 0;)
            if(superClasses[i].getRootClass().getClassName().equals(name))
                return superClasses[i];

        return null;
    }

    public abstract Object getProxy();

    private long expectedEnd;
    private int length;
    private Hashtable hash;
    private Hashtable mangledHash;
    private static final RootObjectRepresentation noSuperClasses[] = new RootObjectRepresentation[0];
    private RootClass rootClass;
    private RootObjectRepresentation superClasses[];
    private static final NameMangler nameMangler = NameMangler.instance();

}