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