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

package boggle.server.comms;

import boggle.server.player;
import java.io.*;
import java.rmi.*;
import java.rmi.server.*;

// Referenced classes of package boggle.server.comms:
//            serverServer

public final class serverServer_Skel
    implements Skeleton
{

    public Operation[] getOperations()
    {
        return operations;
    }

    public void dispatch(Remote remote, RemoteCall remotecall, int i, long l)
        throws RemoteException, Exception
    {
        if(l != 0x1aa32c0d2d6f5acbL)
            throw new SkeletonMismatchException("Hash mismatch");
        serverServer serverserver = (serverServer)remote;
        switch(i)
        {
        case 0: // '\0'
            String s;
            int j;
            player player1;
            try
            {
                ObjectInput objectinput4 = remotecall.getInputStream();
                s = (String)objectinput4.readObject();
                j = objectinput4.readInt();
                player1 = (player)objectinput4.readObject();
            }
            catch(IOException ioexception22)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception22);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.addNewPlayer(s, j, player1);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception13)
            {
                throw new MarshalException("Error marshaling return", ioexception13);
            }

        case 1: // '\001'
            String s1;
            try
            {
                ObjectInput objectinput = remotecall.getInputStream();
                s1 = (String)objectinput.readObject();
            }
            catch(IOException ioexception14)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception14);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            boolean flag = serverserver.attach(s1);
            try
            {
                ObjectOutput objectoutput9 = remotecall.getResultStream(true);
                objectoutput9.writeBoolean(flag);
                return;
            }
            catch(IOException ioexception9)
            {
                throw new MarshalException("Error marshaling return", ioexception9);
            }

        case 2: // '\002'
            String s2;
            String s10;
            int i2;
            try
            {
                ObjectInput objectinput5 = remotecall.getInputStream();
                s2 = (String)objectinput5.readObject();
                s10 = (String)objectinput5.readObject();
                i2 = objectinput5.readInt();
            }
            catch(IOException ioexception23)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception23);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.broadcast(s2, s10, i2);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception15)
            {
                throw new MarshalException("Error marshaling return", ioexception15);
            }

        case 3: // '\003'
            String s3;
            String s11;
            try
            {
                ObjectInput objectinput1 = remotecall.getInputStream();
                s3 = (String)objectinput1.readObject();
                s11 = (String)objectinput1.readObject();
            }
            catch(IOException ioexception18)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception18);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.changeServer(s3, s11);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception10)
            {
                throw new MarshalException("Error marshaling return", ioexception10);
            }

        case 4: // '\004'
            String s4;
            int k;
            int j2;
            int i3;
            try
            {
                ObjectInput objectinput8 = remotecall.getInputStream();
                s4 = (String)objectinput8.readObject();
                k = objectinput8.readInt();
                j2 = objectinput8.readInt();
                i3 = objectinput8.readInt();
            }
            catch(IOException ioexception26)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception26);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.finalscore(s4, k, j2, i3);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception19)
            {
                throw new MarshalException("Error marshaling return", ioexception19);
            }

        case 5: // '\005'
            remotecall.releaseInputStream();
            String as[] = serverserver.getAlternateServers();
            try
            {
                ObjectOutput objectoutput = remotecall.getResultStream(true);
                objectoutput.writeObject(as);
                return;
            }
            catch(IOException ioexception)
            {
                throw new MarshalException("Error marshaling return", ioexception);
            }

        case 6: // '\006'
            remotecall.releaseInputStream();
            String as1[] = serverserver.getGameDefinitions();
            try
            {
                ObjectOutput objectoutput1 = remotecall.getResultStream(true);
                objectoutput1.writeObject(as1);
                return;
            }
            catch(IOException ioexception1)
            {
                throw new MarshalException("Error marshaling return", ioexception1);
            }

        case 7: // '\007'
            remotecall.releaseInputStream();
            String as2[] = serverserver.getGameDescriptions();
            try
            {
                ObjectOutput objectoutput2 = remotecall.getResultStream(true);
                objectoutput2.writeObject(as2);
                return;
            }
            catch(IOException ioexception2)
            {
                throw new MarshalException("Error marshaling return", ioexception2);
            }

        case 8: // '\b'
            remotecall.releaseInputStream();
            int ai[] = serverserver.getGameLanguageList();
            try
            {
                ObjectOutput objectoutput3 = remotecall.getResultStream(true);
                objectoutput3.writeObject(ai);
                return;
            }
            catch(IOException ioexception3)
            {
                throw new MarshalException("Error marshaling return", ioexception3);
            }

        case 9: // '\t'
            remotecall.releaseInputStream();
            String as3[] = serverserver.getGameNames();
            try
            {
                ObjectOutput objectoutput4 = remotecall.getResultStream(true);
                objectoutput4.writeObject(as3);
                return;
            }
            catch(IOException ioexception4)
            {
                throw new MarshalException("Error marshaling return", ioexception4);
            }

        case 10: // '\n'
            remotecall.releaseInputStream();
            int ai1[] = serverserver.getGameTypeList();
            try
            {
                ObjectOutput objectoutput5 = remotecall.getResultStream(true);
                objectoutput5.writeObject(ai1);
                return;
            }
            catch(IOException ioexception5)
            {
                throw new MarshalException("Error marshaling return", ioexception5);
            }

        case 11: // '\013'
            remotecall.releaseInputStream();
            String as4[] = serverserver.getLanguages();
            try
            {
                ObjectOutput objectoutput6 = remotecall.getResultStream(true);
                objectoutput6.writeObject(as4);
                return;
            }
            catch(IOException ioexception6)
            {
                throw new MarshalException("Error marshaling return", ioexception6);
            }

        case 12: // '\f'
            remotecall.releaseInputStream();
            int ai2[] = serverserver.getLoggedInList();
            try
            {
                ObjectOutput objectoutput7 = remotecall.getResultStream(true);
                objectoutput7.writeObject(ai2);
                return;
            }
            catch(IOException ioexception7)
            {
                throw new MarshalException("Error marshaling return", ioexception7);
            }

        case 13: // '\r'
            remotecall.releaseInputStream();
            player aplayer[] = serverserver.getPlayerList();
            try
            {
                ObjectOutput objectoutput8 = remotecall.getResultStream(true);
                objectoutput8.writeObject(aplayer);
                return;
            }
            catch(IOException ioexception8)
            {
                throw new MarshalException("Error marshaling return", ioexception8);
            }

        case 14: // '\016'
            String s5;
            int i1;
            int k2;
            try
            {
                ObjectInput objectinput6 = remotecall.getInputStream();
                s5 = (String)objectinput6.readObject();
                i1 = objectinput6.readInt();
                k2 = objectinput6.readInt();
            }
            catch(IOException ioexception24)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception24);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.joingame(s5, i1, k2);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception16)
            {
                throw new MarshalException("Error marshaling return", ioexception16);
            }

        case 15: // '\017'
            String s6;
            int j1;
            int l2;
            try
            {
                ObjectInput objectinput7 = remotecall.getInputStream();
                s6 = (String)objectinput7.readObject();
                j1 = objectinput7.readInt();
                l2 = objectinput7.readInt();
            }
            catch(IOException ioexception25)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception25);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.login(s6, j1, l2);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception17)
            {
                throw new MarshalException("Error marshaling return", ioexception17);
            }

        case 16: // '\020'
            String s7;
            int k1;
            try
            {
                ObjectInput objectinput2 = remotecall.getInputStream();
                s7 = (String)objectinput2.readObject();
                k1 = objectinput2.readInt();
            }
            catch(IOException ioexception20)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception20);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.logout(s7, k1);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception11)
            {
                throw new MarshalException("Error marshaling return", ioexception11);
            }

        case 17: // '\021'
            String s8;
            int l1;
            String s12;
            String s13;
            int j3;
            int k3;
            try
            {
                ObjectInput objectinput9 = remotecall.getInputStream();
                s8 = (String)objectinput9.readObject();
                l1 = objectinput9.readInt();
                s12 = (String)objectinput9.readObject();
                s13 = (String)objectinput9.readObject();
                j3 = objectinput9.readInt();
                k3 = objectinput9.readInt();
            }
            catch(IOException ioexception28)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception28);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.newgame(s8, l1, s12, s13, j3, k3);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception27)
            {
                throw new MarshalException("Error marshaling return", ioexception27);
            }

        case 18: // '\022'
            String s9;
            String as5[];
            try
            {
                ObjectInput objectinput3 = remotecall.getInputStream();
                s9 = (String)objectinput3.readObject();
                as5 = (String[])objectinput3.readObject();
            }
            catch(IOException ioexception21)
            {
                throw new UnmarshalException("Error unmarshaling arguments", ioexception21);
            }
            finally
            {
                remotecall.releaseInputStream();
            }
            serverserver.takeOver(s9, as5);
            try
            {
                remotecall.getResultStream(true);
                return;
            }
            catch(IOException ioexception12)
            {
                throw new MarshalException("Error marshaling return", ioexception12);
            }
        }
        throw new RemoteException("Method number out of range");
    }

    public serverServer_Skel()
    {
    }

    private static Operation operations[] = {
        new Operation("void addNewPlayer(java.lang.String, int, boggle.server.player)"), new Operation("boolean attach(java.lang.String)"), new Operation("void broadcast(java.lang.String, java.lang.String, int)"), new Operation("void changeServer(java.lang.String, java.lang.String)"), new Operation("void finalscore(java.lang.String, int, int, int)"), new Operation("java.lang.String getAlternateServers()[]"), new Operation("java.lang.String getGameDefinitions()[]"), new Operation("java.lang.String getGameDescriptions()[]"), new Operation("int getGameLanguageList()[]"), new Operation("java.lang.String getGameNames()[]"), 
        new Operation("int getGameTypeList()[]"), new Operation("java.lang.String getLanguages()[]"), new Operation("int getLoggedInList()[]"), new Operation("boggle.server.player getPlayerList()[]"), new Operation("void joingame(java.lang.String, int, int)"), new Operation("void login(java.lang.String, int, int)"), new Operation("void logout(java.lang.String, int)"), new Operation("void newgame(java.lang.String, int, java.lang.String, java.lang.String, int, int)"), new Operation("void takeOver(java.lang.String, java.lang.String[])")
    };
    private static final long interfaceHash = 0x1aa32c0d2d6f5acbL;

}