// Code generated by the FlatBuffers compiler. DO NOT EDIT.

package Example

import (
	flatbuffers "github.com/google/flatbuffers/go"
)

type TypeAliasesT struct {
	I8 int8 `json:"i8"`
	U8 byte `json:"u8"`
	I16 int16 `json:"i16"`
	U16 uint16 `json:"u16"`
	I32 int32 `json:"i32"`
	U32 uint32 `json:"u32"`
	I64 int64 `json:"i64"`
	U64 uint64 `json:"u64"`
	F32 float32 `json:"f32"`
	F64 float64 `json:"f64"`
	V8 []int8 `json:"v8"`
	Vf64 []float64 `json:"vf64"`
}

func (t *TypeAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	if t == nil {
		return 0
	}
	v8Offset := flatbuffers.UOffsetT(0)
	if t.V8 != nil {
		v8Length := len(t.V8)
		TypeAliasesStartV8Vector(builder, v8Length)
		for j := v8Length - 1; j >= 0; j-- {
			builder.PrependInt8(t.V8[j])
		}
		v8Offset = builder.EndVector(v8Length)
	}
	vf64Offset := flatbuffers.UOffsetT(0)
	if t.Vf64 != nil {
		vf64Length := len(t.Vf64)
		TypeAliasesStartVf64Vector(builder, vf64Length)
		for j := vf64Length - 1; j >= 0; j-- {
			builder.PrependFloat64(t.Vf64[j])
		}
		vf64Offset = builder.EndVector(vf64Length)
	}
	TypeAliasesStart(builder)
	TypeAliasesAddI8(builder, t.I8)
	TypeAliasesAddU8(builder, t.U8)
	TypeAliasesAddI16(builder, t.I16)
	TypeAliasesAddU16(builder, t.U16)
	TypeAliasesAddI32(builder, t.I32)
	TypeAliasesAddU32(builder, t.U32)
	TypeAliasesAddI64(builder, t.I64)
	TypeAliasesAddU64(builder, t.U64)
	TypeAliasesAddF32(builder, t.F32)
	TypeAliasesAddF64(builder, t.F64)
	TypeAliasesAddV8(builder, v8Offset)
	TypeAliasesAddVf64(builder, vf64Offset)
	return TypeAliasesEnd(builder)
}

func (rcv *TypeAliases) UnPackTo(t *TypeAliasesT) {
	t.I8 = rcv.I8()
	t.U8 = rcv.U8()
	t.I16 = rcv.I16()
	t.U16 = rcv.U16()
	t.I32 = rcv.I32()
	t.U32 = rcv.U32()
	t.I64 = rcv.I64()
	t.U64 = rcv.U64()
	t.F32 = rcv.F32()
	t.F64 = rcv.F64()
	v8Length := rcv.V8Length()
	t.V8 = make([]int8, v8Length)
	for j := 0; j < v8Length; j++ {
		t.V8[j] = rcv.V8(j)
	}
	vf64Length := rcv.Vf64Length()
	t.Vf64 = make([]float64, vf64Length)
	for j := 0; j < vf64Length; j++ {
		t.Vf64[j] = rcv.Vf64(j)
	}
}

func (rcv *TypeAliases) UnPack() *TypeAliasesT {
	if rcv == nil {
		return nil
	}
	t := &TypeAliasesT{}
	rcv.UnPackTo(t)
	return t
}

type TypeAliases struct {
	_tab flatbuffers.Table
}

func GetRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
	n := flatbuffers.GetUOffsetT(buf[offset:])
	x := &TypeAliases{}
	x.Init(buf, n+offset)
	return x
}

func FinishTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
	builder.Finish(offset)
}

func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
	x := &TypeAliases{}
	x.Init(buf, n+offset+flatbuffers.SizeUint32)
	return x
}

func FinishSizePrefixedTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
	builder.FinishSizePrefixed(offset)
}

func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) {
	rcv._tab.Bytes = buf
	rcv._tab.Pos = i
}

func (rcv *TypeAliases) Table() flatbuffers.Table {
	return rcv._tab
}

func (rcv *TypeAliases) I8() int8 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		return rcv._tab.GetInt8(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateI8(n int8) bool {
	return rcv._tab.MutateInt8Slot(4, n)
}

func (rcv *TypeAliases) U8() byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
	if o != 0 {
		return rcv._tab.GetByte(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateU8(n byte) bool {
	return rcv._tab.MutateByteSlot(6, n)
}

func (rcv *TypeAliases) I16() int16 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
	if o != 0 {
		return rcv._tab.GetInt16(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateI16(n int16) bool {
	return rcv._tab.MutateInt16Slot(8, n)
}

func (rcv *TypeAliases) U16() uint16 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
	if o != 0 {
		return rcv._tab.GetUint16(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateU16(n uint16) bool {
	return rcv._tab.MutateUint16Slot(10, n)
}

func (rcv *TypeAliases) I32() int32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
	if o != 0 {
		return rcv._tab.GetInt32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateI32(n int32) bool {
	return rcv._tab.MutateInt32Slot(12, n)
}

func (rcv *TypeAliases) U32() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateU32(n uint32) bool {
	return rcv._tab.MutateUint32Slot(14, n)
}

func (rcv *TypeAliases) I64() int64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
	if o != 0 {
		return rcv._tab.GetInt64(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateI64(n int64) bool {
	return rcv._tab.MutateInt64Slot(16, n)
}

func (rcv *TypeAliases) U64() uint64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
	if o != 0 {
		return rcv._tab.GetUint64(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *TypeAliases) MutateU64(n uint64) bool {
	return rcv._tab.MutateUint64Slot(18, n)
}

func (rcv *TypeAliases) F32() float32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
	if o != 0 {
		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
	}
	return 0.0
}

func (rcv *TypeAliases) MutateF32(n float32) bool {
	return rcv._tab.MutateFloat32Slot(20, n)
}

func (rcv *TypeAliases) F64() float64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
	if o != 0 {
		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
	}
	return 0.0
}

func (rcv *TypeAliases) MutateF64(n float64) bool {
	return rcv._tab.MutateFloat64Slot(22, n)
}

func (rcv *TypeAliases) V8(j int) int8 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))
	}
	return 0
}

func (rcv *TypeAliases) V8Length() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

func (rcv *TypeAliases) MutateV8(j int, n int8) bool {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), n)
	}
	return false
}

func (rcv *TypeAliases) Vf64(j int) float64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8))
	}
	return 0
}

func (rcv *TypeAliases) Vf64Length() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

func (rcv *TypeAliases) MutateVf64(j int, n float64) bool {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n)
	}
	return false
}

func TypeAliasesStart(builder *flatbuffers.Builder) {
	builder.StartObject(12)
}
func TypeAliasesAddI8(builder *flatbuffers.Builder, i8 int8) {
	builder.PrependInt8Slot(0, i8, 0)
}
func TypeAliasesAddU8(builder *flatbuffers.Builder, u8 byte) {
	builder.PrependByteSlot(1, u8, 0)
}
func TypeAliasesAddI16(builder *flatbuffers.Builder, i16 int16) {
	builder.PrependInt16Slot(2, i16, 0)
}
func TypeAliasesAddU16(builder *flatbuffers.Builder, u16 uint16) {
	builder.PrependUint16Slot(3, u16, 0)
}
func TypeAliasesAddI32(builder *flatbuffers.Builder, i32 int32) {
	builder.PrependInt32Slot(4, i32, 0)
}
func TypeAliasesAddU32(builder *flatbuffers.Builder, u32 uint32) {
	builder.PrependUint32Slot(5, u32, 0)
}
func TypeAliasesAddI64(builder *flatbuffers.Builder, i64 int64) {
	builder.PrependInt64Slot(6, i64, 0)
}
func TypeAliasesAddU64(builder *flatbuffers.Builder, u64 uint64) {
	builder.PrependUint64Slot(7, u64, 0)
}
func TypeAliasesAddF32(builder *flatbuffers.Builder, f32 float32) {
	builder.PrependFloat32Slot(8, f32, 0.0)
}
func TypeAliasesAddF64(builder *flatbuffers.Builder, f64 float64) {
	builder.PrependFloat64Slot(9, f64, 0.0)
}
func TypeAliasesAddV8(builder *flatbuffers.Builder, v8 flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(v8), 0)
}
func TypeAliasesStartV8Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(1, numElems, 1)
}
func TypeAliasesAddVf64(builder *flatbuffers.Builder, vf64 flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(vf64), 0)
}
func TypeAliasesStartVf64Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(8, numElems, 8)
}
func TypeAliasesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	return builder.EndObject()
}
