nbt

README

Nested Binary Trees notes

This package is an implementation of Mojang's NBT data structure.

Documentation

Index

• Constants
• Variables
• func WriteCompressedFile(filename string, t Tag) error
• func WriteUncompressedFile(filename string, t Tag) error
• type CompoundElem
• type ListReader
• type PayloadReader
• type PayloadWriter
• type Tag
  • func MakeCompound(name string, elems []CompoundElem) Tag
  • func MakeCompoundPayload(elems []CompoundElem) []Tag
  • func MakeTag(Type byte, Name string) Tag
  • func NewTag(Type byte, Name string) *Tag
  • func ReadCompressedFile(filename string) (Tag, error)
  • func ReadTag(r io.Reader) (Tag, error)
  • func ReadUncompressedFile(filename string) (Tag, error)
  • func (t *Tag) SetPayload(newp interface{}) error
  • func (t Tag) String() string
  • func (t Tag) Write(w io.Writer) error

Constants

const (
	TAG_End        byte = 0
	TAG_Byte       byte = 1
	TAG_Short      byte = 2
	TAG_Int        byte = 3
	TAG_Long       byte = 4
	TAG_Float      byte = 5
	TAG_Double     byte = 6
	TAG_Byte_Array byte = 7
	TAG_String     byte = 8
	TAG_List       byte = 9
	TAG_Compound   byte = 10
	TAG_Int_Array  byte = 11
)

Variables

var Debug = false

var LReaders = map[byte]ListReader{
	TAG_Byte: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]byte, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Byte](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(byte)
			}
		}
		return iarr, nil
	},
	TAG_Short: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]int16, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Short](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(int16)
			}
		}
		return iarr, nil
	},
	TAG_Int: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]int32, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Int](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(int32)
			}
		}
		return iarr, nil
	},
	TAG_Long: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]int64, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Long](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(int64)
			}
		}
		return iarr, nil
	},
	TAG_Float: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]float32, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Float](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(float32)
			}
		}
		return iarr, nil
	},
	TAG_Double: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]float64, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Double](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(float64)
			}
		}
		return iarr, nil
	},
	TAG_Byte_Array: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([][]byte, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Byte_Array](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.([]byte)
			}
		}
		return iarr, nil
	},
	TAG_String: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([]string, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_String](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.(string)
			}
		}
		return iarr, nil
	},
	TAG_Int_Array: func(r io.Reader, tlen int) (interface{}, error) {
		iarr := make([][]int32, tlen)
		for j := 0; j < tlen; j++ {
			if iarrj, err := PReaders[TAG_Int_Array](r); err != nil {
				return nil, err
			} else {
				iarr[j] = iarrj.([]int32)
			}
		}
		return iarr, nil
	},
}

var Names = map[byte]string{
	TAG_End:        "TAG_End",
	TAG_Byte:       "TAG_Byte",
	TAG_Short:      "TAG_Short",
	TAG_Int:        "TAG_Int",
	TAG_Long:       "TAG_Long",
	TAG_Float:      "TAG_Float",
	TAG_Double:     "TAG_Double",
	TAG_Byte_Array: "TAG_Byte_Array",
	TAG_String:     "TAG_String",
	TAG_List:       "TAG_List",
	TAG_Compound:   "TAG_Compound",
	TAG_Int_Array:  "TAG_Int_Array",
}

var PReaders = map[byte]PayloadReader{
	TAG_Byte: func(r io.Reader) (interface{}, error) {
		payload := make([]byte, 1)
		if _, err := io.ReadFull(r, payload); err != nil {
			return nil, err
		}
		return payload[0], nil
	},
	TAG_Short: func(r io.Reader) (interface{}, error) {
		var payload int16
		if err := binary.Read(r, binary.BigEndian, &payload); err != nil {
			return nil, err
		}
		return payload, nil
	},
	TAG_Int: func(r io.Reader) (interface{}, error) {
		var payload int32
		if err := binary.Read(r, binary.BigEndian, &payload); err != nil {
			return nil, err
		}
		return payload, nil
	},
	TAG_Long: func(r io.Reader) (interface{}, error) {
		var payload int64
		if err := binary.Read(r, binary.BigEndian, &payload); err != nil {
			return nil, err
		}
		return payload, nil
	},
	TAG_Float: func(r io.Reader) (interface{}, error) {
		var payload float32
		if err := binary.Read(r, binary.BigEndian, &payload); err != nil {
			return nil, err
		}
		return payload, nil
	},
	TAG_Double: func(r io.Reader) (interface{}, error) {
		var payload float64
		if err := binary.Read(r, binary.BigEndian, &payload); err != nil {
			return nil, err
		}
		return payload, nil
	},
	TAG_Byte_Array: func(r io.Reader) (interface{}, error) {
		var strlen int32
		if err := binary.Read(r, binary.BigEndian, &strlen); err != nil {
			return nil, err
		}

		strbytes := make([]byte, strlen)

		if _, err := io.ReadFull(r, strbytes); err != nil {
			return nil, err
		}

		return strbytes, nil
	},
	TAG_String: func(r io.Reader) (interface{}, error) {
		var strlen int16
		if err := binary.Read(r, binary.BigEndian, &strlen); err != nil {
			return nil, err
		}

		strbytes := make([]byte, strlen)

		if _, err := io.ReadFull(r, strbytes); err != nil {
			return nil, err
		}

		return string(strbytes), nil
	},
	TAG_Int_Array: func(r io.Reader) (interface{}, error) {
		var strlen int32
		if err := binary.Read(r, binary.BigEndian, &strlen); err != nil {
			return nil, err
		}

		ints := make([]int32, strlen)
		for key := range ints {
			if err := binary.Read(r, binary.BigEndian, &ints[key]); err != nil {
				return nil, err
			}
		}

		return ints, nil
	},
}

var PWriters = map[byte]PayloadWriter{
	TAG_Byte: func(w io.Writer, i interface{}) error {
		b := make([]byte, 1)
		b[0] = i.(byte)
		_, err := w.Write(b)
		return err
	},
	TAG_Short: func(w io.Writer, i interface{}) error {
		return binary.Write(w, binary.BigEndian, i.(int16))
	},
	TAG_Int: func(w io.Writer, i interface{}) error {
		return binary.Write(w, binary.BigEndian, i.(int32))
	},
	TAG_Long: func(w io.Writer, i interface{}) error {
		return binary.Write(w, binary.BigEndian, i.(int64))
	},
	TAG_Float: func(w io.Writer, i interface{}) error {
		return binary.Write(w, binary.BigEndian, i.(float32))
	},
	TAG_Double: func(w io.Writer, i interface{}) error {
		return binary.Write(w, binary.BigEndian, i.(float64))
	},
	TAG_Byte_Array: func(w io.Writer, i interface{}) error {
		if err := binary.Write(w, binary.BigEndian, int32(len(i.([]byte)))); err != nil {
			return err
		}
		for _, value := range i.([]byte) {
			if err := binary.Write(w, binary.BigEndian, value); err != nil {
				return err
			}
		}
		return nil
	},
	TAG_String: func(w io.Writer, i interface{}) error {
		if err := binary.Write(w, binary.BigEndian, int16(len(i.(string)))); err != nil {
			return err
		}
		_, err := w.Write([]byte(i.(string)))
		return err
	},
	TAG_Int_Array: func(w io.Writer, i interface{}) error {
		if err := binary.Write(w, binary.BigEndian, int32(len(i.([]int32)))); err != nil {
			return err
		}
		for _, value := range i.([]int32) {
			if err := binary.Write(w, binary.BigEndian, value); err != nil {
				return err
			}
		}
		return nil
	},
}

Functions

func WriteCompressedFile

func WriteCompressedFile(filename string, t Tag) error

func WriteUncompressedFile

func WriteUncompressedFile(filename string, t Tag) error

Types

type CompoundElem

type CompoundElem struct {
	Key   string
	Tag   byte
	Value interface{}
}

type ListReader

type ListReader func(io.Reader, int) (interface{}, error)

type PayloadReader

type PayloadReader func(io.Reader) (interface{}, error)

type PayloadWriter

type PayloadWriter func(io.Writer, interface{}) error

type Tag

type Tag struct {
	Type    byte
	Name    string
	Payload interface{}
}

func MakeCompound

func MakeCompound(name string, elems []CompoundElem) Tag

func MakeCompoundPayload

func MakeCompoundPayload(elems []CompoundElem) []Tag

func MakeTag

func MakeTag(Type byte, Name string) Tag

func NewTag

func NewTag(Type byte, Name string) *Tag

func ReadCompressedFile

func ReadCompressedFile(filename string) (Tag, error)

func ReadTag

func ReadTag(r io.Reader) (Tag, error)

func ReadUncompressedFile

func ReadUncompressedFile(filename string) (Tag, error)

func (*Tag) SetPayload

func (t *Tag) SetPayload(newp interface{}) error

func (Tag) String

func (t Tag) String() string

func (Tag) Write

func (t Tag) Write(w io.Writer) error