package.java

cisco－2950交换机的应用程序的源代码

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   Package.java

package cisco.dsbu.cms.boot.internal;

import cisco.dsbu.cms.boot.internal.xmllite.CharString;
import cisco.dsbu.cms.boot.internal.xmllite.Handler;
import cisco.dsbu.cms.boot.internal.xmllite.ParseException;
import cisco.dsbu.cms.boot.internal.xmllite.Parser;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;

// Referenced classes of package cisco.dsbu.cms.boot.internal:
//            Component, SgzReader, VersionXml, Distribution

class Package
    implements Handler, VersionXml
{

    private static final boolean DEBUG = true;
    private static final byte NOT_LOADED = 0;
    private static final byte LOADING = 1;
    private static final byte LOADED = 2;
    private Distribution container;
    private String name;
    private String extension;
    private int size;
    private List components;
    private CharString currElem;
    private byte loadState;
    private int numLatest;

    Package(Distribution distribution)
    {
        container = distribution;
        loadState = 0;
    }

    URL getFilesystem()
    {
        return container.getFilesystem();
    }

    public String toString()
    {
        return name + "." + extension;
    }

    List getComponents()
    {
        return components;
    }

    void updateNumLatest(boolean flag)
    {
        if(flag)
            numLatest++;
        else
            numLatest--;
        container.updateNumLatest(flag);
    }

    void load()
    {
        synchronized(this)
        {
            if(loadState != 0)
                return;
            loadState = 1;
        }
        loadPackage();
        synchronized(this)
        {
            loadState = 2;
        }
    }

    private void loadPackage()
    {
        if(extension == null || extension.equals(""))
            loadUnpackaged();
        else
        if(extension.equals("sgz"))
            loadSgzPackage();
        else
            System.out.println("Unknown extension; ignoring " + name + '.' + extension);
    }

    private void getContents(InputStream inputstream, byte abyte0[])
        throws IOException
    {
        int i = 0;
        while(inputstream.available() > 0) 
        {
            try
            {
                int j = inputstream.read(abyte0, i, abyte0.length - i);
                if(j <= 0)
                    break;
                i += j;
                continue;
            }
            catch(EOFException eofexception) { }
            break;
        }
    }

    private void loadUnpackaged()
    {
        for(Iterator iterator = components.iterator(); iterator.hasNext();)
        {
            Component component = (Component)iterator.next();
            if(component.isLatest())
            {
                InputStream inputstream = null;
                try
                {
                    URL url = new URL(getFilesystem(), component.getName());
                    inputstream = url.openStream();
                    byte abyte0[] = new byte[component.getSize()];
                    getContents(inputstream, abyte0);
                    component.setSigned(true);
                    component.setContents(abyte0);
                }
                catch(MalformedURLException malformedurlexception)
                {
                    component.setContentsNotFound();
                    malformedurlexception.printStackTrace();
                }
                catch(IOException ioexception)
                {
                    component.setContentsNotFound();
                    ioexception.printStackTrace();
                }
                finally
                {
                    try
                    {
                        if(inputstream != null)
                            inputstream.close();
                    }
                    catch(IOException ioexception1)
                    {
                        ioexception1.printStackTrace();
                    }
                }
            }
        }

    }

    private void loadSgzPackage()
    {
        URL url;
        try
        {
            url = new URL(getFilesystem(), name + "." + extension);
        }
        catch(MalformedURLException malformedurlexception)
        {
            malformedurlexception.printStackTrace();
            return;
        }
        System.out.println("Loading package: " + url);
        InputStream inputstream = null;
        SgzReader sgzreader = null;
        try
        {
            inputstream = url.openStream();
            sgzreader = new SgzReader(inputstream);
            for(Iterator iterator = components.iterator(); iterator.hasNext();)
            {
                Component component = (Component)iterator.next();
                if(component.isLatest())
                {
                    String s = component.getName();
                    String s1;
                    do
                    {
                        s1 = sgzreader.getNextElement();
                        if(s1 == null)
                        {
                            markContentsNotFound(component, iterator);
                            return;
                        }
                    } while(!s1.equals(s));
                    int i = sgzreader.getElementStatus();
                    if(i == 2)
                    {
                        component.setContentsNotFound();
                    } else
                    {
                        component.setSigned(i == 1);
                        byte abyte0[] = sgzreader.getElementData();
                        component.setContents(abyte0);
                    }
                }
            }

        }
        catch(IOException ioexception)
        {
            ioexception.printStackTrace();
        }
        finally
        {
            try
            {
                if(sgzreader != null)
                    sgzreader.close();
                else
                if(inputstream != null)
                    inputstream.close();
            }
            catch(IOException ioexception1)
            {
                ioexception1.printStackTrace();
            }
        }
    }

    private void markContentsNotFound(Component component, Iterator iterator)
    {
        component.setContentsNotFound();
        Component component1;
        for(; iterator.hasNext(); component1.setContentsNotFound())
            component1 = (Component)iterator.next();

    }

    public void startDocument(Parser parser)
        throws ParseException
    {
        throw new ParseException(parser, "Unexpected start-of-document");
    }

    public CharString startElement(Parser parser, CharString charstring)
        throws ParseException
    {
        currElem = null;
        if(charstring.equals(VersionXml.NAME))
            currElem = VersionXml.NAME;
        else
        if(charstring.equals(VersionXml.EXTENSION))
            currElem = VersionXml.EXTENSION;
        else
        if(charstring.equals(VersionXml.SIZE))
            currElem = VersionXml.SIZE;
        else
        if(charstring.equals(VersionXml.NUM_COMP))
            currElem = VersionXml.NUM_COMP;
        else
        if(charstring.equals(VersionXml.COMPONENT))
        {
            currElem = VersionXml.COMPONENT;
            Component component = new Component(this);
            components.add(component);
            parser.pushHandler(component);
        }
        return currElem;
    }

    public void elementData(Parser parser, CharString charstring)
        throws ParseException
    {
        if(currElem == VersionXml.NAME)
            name = charstring.toString();
        else
        if(currElem == VersionXml.EXTENSION)
            extension = charstring.toString();
        else
        if(currElem == VersionXml.SIZE)
            size = charstring.toInt();
        else
        if(currElem == VersionXml.NUM_COMP)
            components = new ArrayList(charstring.toInt());
    }

    public void endElement(Parser parser, CharString charstring)
        throws ParseException
    {
        if(charstring.equals(VersionXml.PACKAGE))
            parser.popHandler();
    }

    public void endDocument(Parser parser)
        throws ParseException
    {
        throw new ParseException(parser, "Unexpected end-of-document");
    }
}