1 files changed, 1093 insertions, 0 deletions
diff --git a/binary/schema/README.md b/binary/schema/README.md
new file mode 100644
index 000000000..3d60e6d48
--- /dev/null
+++ b/binary/schema/README.md
@@ -0,0 +1,1093 @@
+# schema
+--
+    import "android.googlesource.com/platform/tools/gpu/binary/schema"
+
+Package schema implements rtti for the binary system.
+
+## Usage
+
+#### type Array
+
+```go
+type Array struct {
+	binary.Generate
+	Alias     string // The alias this array type was given, if present
+	ValueType Type   // The value type stored in the array
+	Size      uint32 // The fixed size of the array
+}
+```
+
+Array is the Type descriptor for fixed size buffers of known type.
+
+#### func (*Array) Basename
+
+```go
+func (a *Array) Basename() string
+```
+
+#### func (*Array) Class
+
+```go
+func (*Array) Class() binary.Class
+```
+
+#### func (*Array) Decode
+
+```go
+func (a *Array) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Array) Encode
+
+```go
+func (a *Array) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Array) Skip
+
+```go
+func (a *Array) Skip(d binary.Decoder) error
+```
+
+#### func (*Array) String
+
+```go
+func (a *Array) String() string
+```
+
+#### func (*Array) Typename
+
+```go
+func (a *Array) Typename() string
+```
+
+#### type Class
+
+```go
+type Class struct {
+	binary.Generate
+	TypeID  binary.ID // The unique type identifier for the Object.
+	Package string    // The package that declared the struct.
+	Name    string    // The simple name of the Object.
+	Fields  []Field   // Descriptions of the fields of the Object.
+}
+```
+
+Class represents an encodable object type with a type ID.
+
+#### func  Lookup
+
+```go
+func Lookup(id binary.ID) *Class
+```
+Lookup looks up a Class by the given type id. If there is no match, it will
+return nil.
+
+#### func (*Class) Class
+
+```go
+func (*Class) Class() binary.Class
+```
+
+#### func (*Class) Decode
+
+```go
+func (c *Class) Decode(d binary.Decoder) (binary.Object, error)
+```
+
+#### func (*Class) DecodeTo
+
+```go
+func (c *Class) DecodeTo(d binary.Decoder, object binary.Object) error
+```
+
+#### func (*Class) Encode
+
+```go
+func (c *Class) Encode(e binary.Encoder, object binary.Object) error
+```
+
+#### func (*Class) ID
+
+```go
+func (c *Class) ID() binary.ID
+```
+
+#### func (*Class) New
+
+```go
+func (c *Class) New() binary.Object
+```
+
+#### func (*Class) Skip
+
+```go
+func (c *Class) Skip(d binary.Decoder) error
+```
+
+#### type Constants
+
+```go
+type Constants []interface{}
+```
+
+
+#### type Field
+
+```go
+type Field struct {
+	binary.Generate
+	Declared string // The name of the field.
+	Type     Type   // The type stored in the field.
+}
+```
+
+Field represents a name/type pair for a field in an Object.
+
+#### func (*Field) Class
+
+```go
+func (*Field) Class() binary.Class
+```
+
+#### func (Field) Name
+
+```go
+func (f Field) Name() string
+```
+
+#### type Int16Constant
+
+```go
+type Int16Constant struct {
+	binary.Generate
+	Name  string
+	Value int16
+}
+```
+
+
+#### func (Int16Constant) Add
+
+```go
+func (v Int16Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Int16Constant) Class
+
+```go
+func (*Int16Constant) Class() binary.Class
+```
+
+#### type Int16Constants
+
+```go
+type Int16Constants struct {
+	binary.Generate
+	Type   Type            // The type of the constant.
+	Values []Int16Constant // The constant values
+}
+```
+
+
+#### func (*Int16Constants) Class
+
+```go
+func (*Int16Constants) Class() binary.Class
+```
+
+#### func (Int16Constants) Len
+
+```go
+func (s Int16Constants) Len() int
+```
+
+#### func (Int16Constants) Less
+
+```go
+func (s Int16Constants) Less(i, j int) bool
+```
+
+#### func (Int16Constants) Swap
+
+```go
+func (s Int16Constants) Swap(i, j int)
+```
+
+#### type Int32Constant
+
+```go
+type Int32Constant struct {
+	binary.Generate
+	Name  string
+	Value int32
+}
+```
+
+
+#### func (Int32Constant) Add
+
+```go
+func (v Int32Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Int32Constant) Class
+
+```go
+func (*Int32Constant) Class() binary.Class
+```
+
+#### type Int32Constants
+
+```go
+type Int32Constants struct {
+	binary.Generate
+	Type   Type            // The type of the constant.
+	Values []Int32Constant // The constant values
+}
+```
+
+
+#### func (*Int32Constants) Class
+
+```go
+func (*Int32Constants) Class() binary.Class
+```
+
+#### func (Int32Constants) Len
+
+```go
+func (s Int32Constants) Len() int
+```
+
+#### func (Int32Constants) Less
+
+```go
+func (s Int32Constants) Less(i, j int) bool
+```
+
+#### func (Int32Constants) Swap
+
+```go
+func (s Int32Constants) Swap(i, j int)
+```
+
+#### type Int64Constant
+
+```go
+type Int64Constant struct {
+	binary.Generate
+	Name  string
+	Value int64
+}
+```
+
+
+#### func (Int64Constant) Add
+
+```go
+func (v Int64Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Int64Constant) Class
+
+```go
+func (*Int64Constant) Class() binary.Class
+```
+
+#### type Int64Constants
+
+```go
+type Int64Constants struct {
+	binary.Generate
+	Type   Type            // The type of the constant.
+	Values []Int64Constant // The constant values
+}
+```
+
+
+#### func (*Int64Constants) Class
+
+```go
+func (*Int64Constants) Class() binary.Class
+```
+
+#### func (Int64Constants) Len
+
+```go
+func (s Int64Constants) Len() int
+```
+
+#### func (Int64Constants) Less
+
+```go
+func (s Int64Constants) Less(i, j int) bool
+```
+
+#### func (Int64Constants) Swap
+
+```go
+func (s Int64Constants) Swap(i, j int)
+```
+
+#### type Int8Constant
+
+```go
+type Int8Constant struct {
+	binary.Generate
+	Name  string
+	Value int8
+}
+```
+
+
+#### func (Int8Constant) Add
+
+```go
+func (v Int8Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Int8Constant) Class
+
+```go
+func (*Int8Constant) Class() binary.Class
+```
+
+#### type Int8Constants
+
+```go
+type Int8Constants struct {
+	binary.Generate
+	Type   Type           // The type of the constant.
+	Values []Int8Constant // The constant values
+}
+```
+
+
+#### func (*Int8Constants) Class
+
+```go
+func (*Int8Constants) Class() binary.Class
+```
+
+#### func (Int8Constants) Len
+
+```go
+func (s Int8Constants) Len() int
+```
+
+#### func (Int8Constants) Less
+
+```go
+func (s Int8Constants) Less(i, j int) bool
+```
+
+#### func (Int8Constants) Swap
+
+```go
+func (s Int8Constants) Swap(i, j int)
+```
+
+#### type Interface
+
+```go
+type Interface struct {
+	binary.Generate
+	Name string // The simple name of the type.
+}
+```
+
+Interface is the Type descriptor for a field who's underlying type is dynamic.
+
+#### func (*Interface) Basename
+
+```go
+func (i *Interface) Basename() string
+```
+
+#### func (*Interface) Class
+
+```go
+func (*Interface) Class() binary.Class
+```
+
+#### func (*Interface) Decode
+
+```go
+func (i *Interface) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Interface) Encode
+
+```go
+func (i *Interface) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Interface) Skip
+
+```go
+func (i *Interface) Skip(d binary.Decoder) error
+```
+
+#### func (*Interface) String
+
+```go
+func (i *Interface) String() string
+```
+
+#### func (*Interface) Typename
+
+```go
+func (i *Interface) Typename() string
+```
+
+#### type Map
+
+```go
+type Map struct {
+	binary.Generate
+	Alias     string // The alias this array type was given, if present
+	KeyType   Type   // The key type used.
+	ValueType Type   // The value type stored in the map.
+}
+```
+
+Map is the Type descriptor for key/value stores.
+
+#### func (*Map) Basename
+
+```go
+func (m *Map) Basename() string
+```
+
+#### func (*Map) Class
+
+```go
+func (*Map) Class() binary.Class
+```
+
+#### func (*Map) Decode
+
+```go
+func (m *Map) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Map) Encode
+
+```go
+func (m *Map) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Map) Skip
+
+```go
+func (m *Map) Skip(d binary.Decoder) error
+```
+
+#### func (*Map) String
+
+```go
+func (m *Map) String() string
+```
+
+#### func (*Map) Typename
+
+```go
+func (m *Map) Typename() string
+```
+
+#### type Method
+
+```go
+type Method int
+```
+
+Method denotes the encoding/decoding method a primitive type will use.
+
+```go
+const (
+	ID Method = iota
+	Bool
+	Int8
+	Uint8
+	Int16
+	Uint16
+	Int32
+	Uint32
+	Int64
+	Uint64
+	Float32
+	Float64
+	String
+)
+```
+
+#### func  ParseMethod
+
+```go
+func ParseMethod(s string) (Method, error)
+```
+This will convert a string to a Method, or return an error if the string was not
+a valid method name.
+
+#### func (Method) Skippable
+
+```go
+func (m Method) Skippable() bool
+```
+Skippable returns true if the method has a complimentary skip method on the
+decoder interface. If this is not true, the normal decoding method is used
+during skipping.
+
+#### func (Method) String
+
+```go
+func (m Method) String() string
+```
+
+#### type Object
+
+```go
+type Object struct {
+	Fields []interface{}
+}
+```
+
+Object is an instance of a Class.
+
+#### func (*Object) Class
+
+```go
+func (o *Object) Class() binary.Class
+```
+Class implements binary.Object using the schema system to do the encoding and
+decoding of fields.
+
+#### type Pointer
+
+```go
+type Pointer struct {
+	binary.Generate
+	Type Type // The pointed to type.
+}
+```
+
+Pointer is the Type descriptor for pointers.
+
+#### func (*Pointer) Basename
+
+```go
+func (p *Pointer) Basename() string
+```
+
+#### func (*Pointer) Class
+
+```go
+func (*Pointer) Class() binary.Class
+```
+
+#### func (*Pointer) Decode
+
+```go
+func (p *Pointer) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Pointer) Encode
+
+```go
+func (p *Pointer) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Pointer) Skip
+
+```go
+func (p *Pointer) Skip(d binary.Decoder) error
+```
+
+#### func (*Pointer) String
+
+```go
+func (p *Pointer) String() string
+```
+
+#### func (*Pointer) Typename
+
+```go
+func (p *Pointer) Typename() string
+```
+
+#### type Primitive
+
+```go
+type Primitive struct {
+	binary.Generate
+	Name   string // The simple name of the type.
+	Method Method // The enocde/decode method to use.
+}
+```
+
+Primitive is the kind for primitive types with corresponding direct methods on
+Encoder and Decoder
+
+#### func (*Primitive) Basename
+
+```go
+func (p *Primitive) Basename() string
+```
+
+#### func (*Primitive) Class
+
+```go
+func (*Primitive) Class() binary.Class
+```
+
+#### func (*Primitive) Decode
+
+```go
+func (p *Primitive) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Primitive) Encode
+
+```go
+func (p *Primitive) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Primitive) Native
+
+```go
+func (p *Primitive) Native() string
+```
+Native returns the go native type name for this primitive.
+
+#### func (*Primitive) Skip
+
+```go
+func (p *Primitive) Skip(d binary.Decoder) error
+```
+Implements binary.Class
+
+#### func (*Primitive) String
+
+```go
+func (p *Primitive) String() string
+```
+
+#### func (*Primitive) Typename
+
+```go
+func (p *Primitive) Typename() string
+```
+
+#### type Slice
+
+```go
+type Slice struct {
+	binary.Generate
+	Alias     string // The alias this array type was given, if present
+	ValueType Type   // The value type stored in the slice.
+}
+```
+
+Slice is the Type descriptor for dynamically sized buffers of known type,
+encoded with a preceding count.
+
+#### func (*Slice) Basename
+
+```go
+func (s *Slice) Basename() string
+```
+
+#### func (*Slice) Class
+
+```go
+func (*Slice) Class() binary.Class
+```
+
+#### func (*Slice) Decode
+
+```go
+func (s *Slice) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Slice) Encode
+
+```go
+func (s *Slice) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Slice) Skip
+
+```go
+func (s *Slice) Skip(d binary.Decoder) error
+```
+
+#### func (*Slice) String
+
+```go
+func (s *Slice) String() string
+```
+
+#### func (*Slice) Typename
+
+```go
+func (s *Slice) Typename() string
+```
+
+#### type Stream
+
+```go
+type Stream struct {
+	binary.Generate
+	Alias     string // The alias this array type was given, if present
+	ValueType Type   // The value type stored in the stream.
+}
+```
+
+Stream is the Type descriptor for dynamically sized streams of a known type,
+where the stream is terminated with a speical token rather than prefixed by a
+count.
+
+#### func (*Stream) Basename
+
+```go
+func (s *Stream) Basename() string
+```
+
+#### func (*Stream) Class
+
+```go
+func (*Stream) Class() binary.Class
+```
+
+#### func (*Stream) Decode
+
+```go
+func (s *Stream) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Stream) Encode
+
+```go
+func (s *Stream) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Stream) Skip
+
+```go
+func (s *Stream) Skip(d binary.Decoder) error
+```
+
+#### func (*Stream) String
+
+```go
+func (s *Stream) String() string
+```
+
+#### func (*Stream) Typename
+
+```go
+func (s *Stream) Typename() string
+```
+
+#### type Struct
+
+```go
+type Struct struct {
+	binary.Generate
+	Name string    // The simple name of the type.
+	ID   binary.ID // The unique type identifier for the Object.
+}
+```
+
+Struct is the Type descriptor for an binary.Object typed value.
+
+#### func (*Struct) Basename
+
+```go
+func (s *Struct) Basename() string
+```
+
+#### func (*Struct) Class
+
+```go
+func (*Struct) Class() binary.Class
+```
+
+#### func (*Struct) Decode
+
+```go
+func (s *Struct) Decode(d binary.Decoder) (interface{}, error)
+```
+
+#### func (*Struct) Encode
+
+```go
+func (s *Struct) Encode(e binary.Encoder, value interface{}) error
+```
+
+#### func (*Struct) Skip
+
+```go
+func (s *Struct) Skip(d binary.Decoder) error
+```
+
+#### func (*Struct) String
+
+```go
+func (s *Struct) String() string
+```
+
+#### func (*Struct) Typename
+
+```go
+func (s *Struct) Typename() string
+```
+
+#### type Type
+
+```go
+type Type interface {
+	binary.Object
+	String() string
+	Encode(e binary.Encoder, value interface{}) error
+	Decode(d binary.Decoder) (interface{}, error)
+	Skip(d binary.Decoder) error
+	Typename() string
+	Basename() string
+}
+```
+
+Type represents the common iterface to all type objects in the schema.
+
+#### type Uint16Constant
+
+```go
+type Uint16Constant struct {
+	binary.Generate
+	Name  string
+	Value uint16
+}
+```
+
+
+#### func (Uint16Constant) Add
+
+```go
+func (v Uint16Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Uint16Constant) Class
+
+```go
+func (*Uint16Constant) Class() binary.Class
+```
+
+#### type Uint16Constants
+
+```go
+type Uint16Constants struct {
+	binary.Generate
+	Type   Type             // The type of the constant.
+	Values []Uint16Constant // The constant values
+}
+```
+
+
+#### func (*Uint16Constants) Class
+
+```go
+func (*Uint16Constants) Class() binary.Class
+```
+
+#### func (Uint16Constants) Len
+
+```go
+func (s Uint16Constants) Len() int
+```
+
+#### func (Uint16Constants) Less
+
+```go
+func (s Uint16Constants) Less(i, j int) bool
+```
+
+#### func (Uint16Constants) Swap
+
+```go
+func (s Uint16Constants) Swap(i, j int)
+```
+
+#### type Uint32Constant
+
+```go
+type Uint32Constant struct {
+	binary.Generate
+	Name  string
+	Value uint32
+}
+```
+
+
+#### func (Uint32Constant) Add
+
+```go
+func (v Uint32Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Uint32Constant) Class
+
+```go
+func (*Uint32Constant) Class() binary.Class
+```
+
+#### type Uint32Constants
+
+```go
+type Uint32Constants struct {
+	binary.Generate
+	Type   Type             // The type of the constant.
+	Values []Uint32Constant // The constant values
+}
+```
+
+
+#### func (*Uint32Constants) Class
+
+```go
+func (*Uint32Constants) Class() binary.Class
+```
+
+#### func (Uint32Constants) Len
+
+```go
+func (s Uint32Constants) Len() int
+```
+
+#### func (Uint32Constants) Less
+
+```go
+func (s Uint32Constants) Less(i, j int) bool
+```
+
+#### func (Uint32Constants) Swap
+
+```go
+func (s Uint32Constants) Swap(i, j int)
+```
+
+#### type Uint64Constant
+
+```go
+type Uint64Constant struct {
+	binary.Generate
+	Name  string
+	Value uint64
+}
+```
+
+
+#### func (Uint64Constant) Add
+
+```go
+func (v Uint64Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Uint64Constant) Class
+
+```go
+func (*Uint64Constant) Class() binary.Class
+```
+
+#### type Uint64Constants
+
+```go
+type Uint64Constants struct {
+	binary.Generate
+	Type   Type             // The type of the constant.
+	Values []Uint64Constant // The constant values
+}
+```
+
+
+#### func (*Uint64Constants) Class
+
+```go
+func (*Uint64Constants) Class() binary.Class
+```
+
+#### func (Uint64Constants) Len
+
+```go
+func (s Uint64Constants) Len() int
+```
+
+#### func (Uint64Constants) Less
+
+```go
+func (s Uint64Constants) Less(i, j int) bool
+```
+
+#### func (Uint64Constants) Swap
+
+```go
+func (s Uint64Constants) Swap(i, j int)
+```
+
+#### type Uint8Constant
+
+```go
+type Uint8Constant struct {
+	binary.Generate
+	Name  string
+	Value uint8
+}
+```
+
+
+#### func (Uint8Constant) Add
+
+```go
+func (v Uint8Constant) Add(c *Constants, t Type)
+```
+
+#### func (*Uint8Constant) Class
+
+```go
+func (*Uint8Constant) Class() binary.Class
+```
+
+#### type Uint8Constants
+
+```go
+type Uint8Constants struct {
+	binary.Generate
+	Type   Type            // The type of the constant.
+	Values []Uint8Constant // The constant values
+}
+```
+
+
+#### func (*Uint8Constants) Class
+
+```go
+func (*Uint8Constants) Class() binary.Class
+```
+
+#### func (Uint8Constants) Len
+
+```go
+func (s Uint8Constants) Len() int
+```
+
+#### func (Uint8Constants) Less
+
+```go
+func (s Uint8Constants) Less(i, j int) bool
+```
+
+#### func (Uint8Constants) Swap
+
+```go
+func (s Uint8Constants) Swap(i, j int)
+```