    001    package net.minecraft.src;
    002
    003    import java.io.DataInput;
    004    import java.io.DataOutput;
    005    import java.io.IOException;
    006
    007    public abstract class NBTBase
    008    {
    009        /** The UTF string key used to lookup values. */
    010        private String name;
    011
    012        /**
    013         * Write the actual data contents of the tag, implemented in NBT extension classes
    014         */
    015        abstract void write(DataOutput var1) throws IOException;
    016
    017        /**
    018         * Read the actual data contents of the tag, implemented in NBT extension classes
    019         */
    020        abstract void load(DataInput var1) throws IOException;
    021
    022        /**
    023         * Gets the type byte for the tag.
    024         */
    025        public abstract byte getId();
    026
    027        protected NBTBase(String par1Str)
    028        {
    029            if (par1Str == null)
    030            {
    031                this.name = "";
    032            }
    033            else
    034            {
    035                this.name = par1Str;
    036            }
    037        }
    038
    039        /**
    040         * Sets the name for this tag and returns this for convenience.
    041         */
    042        public NBTBase setName(String par1Str)
    043        {
    044            if (par1Str == null)
    045            {
    046                this.name = "";
    047            }
    048            else
    049            {
    050                this.name = par1Str;
    051            }
    052
    053            return this;
    054        }
    055
    056        /**
    057         * Gets the name corresponding to the tag, or an empty string if none set.
    058         */
    059        public String getName()
    060        {
    061            return this.name == null ? "" : this.name;
    062        }
    063
    064        /**
    065         * Reads and returns a tag from the given DataInput, or the End tag if no tag could be read.
    066         */
    067        public static NBTBase readNamedTag(DataInput par0DataInput) throws IOException
    068        {
    069            byte var1 = par0DataInput.readByte();
    070
    071            if (var1 == 0)
    072            {
    073                return new NBTTagEnd();
    074            }
    075            else
    076            {
    077                String var2 = par0DataInput.readUTF();
    078                NBTBase var3 = newTag(var1, var2);
    079                var3.load(par0DataInput);
    080                return var3;
    081            }
    082        }
    083
    084        /**
    085         * Writes the specified tag to the given DataOutput, writing the type byte, the UTF string key and then calling the
    086         * tag to write its data.
    087         */
    088        public static void writeNamedTag(NBTBase par0NBTBase, DataOutput par1DataOutput) throws IOException
    089        {
    090            par1DataOutput.writeByte(par0NBTBase.getId());
    091
    092            if (par0NBTBase.getId() != 0)
    093            {
    094                par1DataOutput.writeUTF(par0NBTBase.getName());
    095                par0NBTBase.write(par1DataOutput);
    096            }
    097        }
    098
    099        /**
    100         * Creates and returns a new tag of the specified type, or null if invalid.
    101         */
    102        public static NBTBase newTag(byte par0, String par1Str)
    103        {
    104            switch (par0)
    105            {
    106                case 0:
    107                    return new NBTTagEnd();
    108                case 1:
    109                    return new NBTTagByte(par1Str);
    110                case 2:
    111                    return new NBTTagShort(par1Str);
    112                case 3:
    113                    return new NBTTagInt(par1Str);
    114                case 4:
    115                    return new NBTTagLong(par1Str);
    116                case 5:
    117                    return new NBTTagFloat(par1Str);
    118                case 6:
    119                    return new NBTTagDouble(par1Str);
    120                case 7:
    121                    return new NBTTagByteArray(par1Str);
    122                case 8:
    123                    return new NBTTagString(par1Str);
    124                case 9:
    125                    return new NBTTagList(par1Str);
    126                case 10:
    127                    return new NBTTagCompound(par1Str);
    128                case 11:
    129                    return new NBTTagIntArray(par1Str);
    130                default:
    131                    return null;
    132            }
    133        }
    134
    135        /**
    136         * Returns the string name of a tag with the specified type, or 'UNKNOWN' if invalid.
    137         */
    138        public static String getTagName(byte par0)
    139        {
    140            switch (par0)
    141            {
    142                case 0:
    143                    return "TAG_End";
    144                case 1:
    145                    return "TAG_Byte";
    146                case 2:
    147                    return "TAG_Short";
    148                case 3:
    149                    return "TAG_Int";
    150                case 4:
    151                    return "TAG_Long";
    152                case 5:
    153                    return "TAG_Float";
    154                case 6:
    155                    return "TAG_Double";
    156                case 7:
    157                    return "TAG_Byte_Array";
    158                case 8:
    159                    return "TAG_String";
    160                case 9:
    161                    return "TAG_List";
    162                case 10:
    163                    return "TAG_Compound";
    164                case 11:
    165                    return "TAG_Int_Array";
    166                default:
    167                    return "UNKNOWN";
    168            }
    169        }
    170
    171        /**
    172         * Creates a clone of the tag.
    173         */
    174        public abstract NBTBase copy();
    175
    176        public boolean equals(Object par1Obj)
    177        {
    178            if (!(par1Obj instanceof NBTBase))
    179            {
    180                return false;
    181            }
    182            else
    183            {
    184                NBTBase var2 = (NBTBase)par1Obj;
    185                return this.getId() != var2.getId() ? false : ((this.name != null || var2.name == null) && (this.name == null || var2.name != null) ? this.name == null || this.name.equals(var2.name) : false);
    186            }
    187        }
    188
    189        public int hashCode()
    190        {
    191            return this.name.hashCode() ^ this.getId();
    192        }
    193    }