AxsStateCalcPipelineInputs.go

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

package fbtypes

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

/// input parameters for reading the pipeline
type AxsStateCalcPipelineInputsT struct {
	Axes []string
	SyncMode SyncMode
	Inputs []*AxsStateCalcPipelineSingleInputT
}

func (t *AxsStateCalcPipelineInputsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	if t == nil { return 0 }
	axesOffset := flatbuffers.UOffsetT(0)
	if t.Axes != nil {
		axesLength := len(t.Axes)
		axesOffsets := make([]flatbuffers.UOffsetT, axesLength)
		for j := 0; j < axesLength; j++ {
			axesOffsets[j] = builder.CreateString(t.Axes[j])
		}
		AxsStateCalcPipelineInputsStartAxesVector(builder, axesLength)
		for j := axesLength - 1; j >= 0; j-- {
			builder.PrependUOffsetT(axesOffsets[j])
		}
		axesOffset = builder.EndVector(axesLength)
	}
	inputsOffset := flatbuffers.UOffsetT(0)
	if t.Inputs != nil {
		inputsLength := len(t.Inputs)
		inputsOffsets := make([]flatbuffers.UOffsetT, inputsLength)
		for j := 0; j < inputsLength; j++ {
			inputsOffsets[j] = t.Inputs[j].Pack(builder)
		}
		AxsStateCalcPipelineInputsStartInputsVector(builder, inputsLength)
		for j := inputsLength - 1; j >= 0; j-- {
			builder.PrependUOffsetT(inputsOffsets[j])
		}
		inputsOffset = builder.EndVector(inputsLength)
	}
	AxsStateCalcPipelineInputsStart(builder)
	AxsStateCalcPipelineInputsAddAxes(builder, axesOffset)
	AxsStateCalcPipelineInputsAddSyncMode(builder, t.SyncMode)
	AxsStateCalcPipelineInputsAddInputs(builder, inputsOffset)
	return AxsStateCalcPipelineInputsEnd(builder)
}

func (rcv *AxsStateCalcPipelineInputs) UnPackTo(t *AxsStateCalcPipelineInputsT) {
	axesLength := rcv.AxesLength()
	t.Axes = make([]string, axesLength)
	for j := 0; j < axesLength; j++ {
		t.Axes[j] = string(rcv.Axes(j))
	}
	t.SyncMode = rcv.SyncMode()
	inputsLength := rcv.InputsLength()
	t.Inputs = make([]*AxsStateCalcPipelineSingleInputT, inputsLength)
	for j := 0; j < inputsLength; j++ {
		x := AxsStateCalcPipelineSingleInput{}
		rcv.Inputs(&x, j)
		t.Inputs[j] = x.UnPack()
	}
}

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

type AxsStateCalcPipelineInputs struct {
	_tab flatbuffers.Table
}

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

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

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

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

/// master input id
func (rcv *AxsStateCalcPipelineInputs) Axes(j int) []byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
	}
	return nil
}

func (rcv *AxsStateCalcPipelineInputs) AxesLength() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

/// master input id
/// sync cmd mode to run calculation pipeline
func (rcv *AxsStateCalcPipelineInputs) SyncMode() SyncMode {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
	if o != 0 {
		return SyncMode(rcv._tab.GetInt8(o + rcv._tab.Pos))
	}
	return 2
}

/// sync cmd mode to run calculation pipeline
func (rcv *AxsStateCalcPipelineInputs) MutateSyncMode(n SyncMode) bool {
	return rcv._tab.MutateInt8Slot(6, int8(n))
}

/// id of the requested data
func (rcv *AxsStateCalcPipelineInputs) Inputs(obj *AxsStateCalcPipelineSingleInput, j int) bool {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
	if o != 0 {
		x := rcv._tab.Vector(o)
		x += flatbuffers.UOffsetT(j) * 4
		x = rcv._tab.Indirect(x)
		obj.Init(rcv._tab.Bytes, x)
		return true
	}
	return false
}

func (rcv *AxsStateCalcPipelineInputs) InputsLength() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

/// id of the requested data
func AxsStateCalcPipelineInputsStart(builder *flatbuffers.Builder) {
	builder.StartObject(3)
}
func AxsStateCalcPipelineInputsAddAxes(builder *flatbuffers.Builder, axes flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axes), 0)
}
func AxsStateCalcPipelineInputsStartAxesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(4, numElems, 4)
}
func AxsStateCalcPipelineInputsAddSyncMode(builder *flatbuffers.Builder, syncMode SyncMode) {
	builder.PrependInt8Slot(1, int8(syncMode), 2)
}
func AxsStateCalcPipelineInputsAddInputs(builder *flatbuffers.Builder, inputs flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inputs), 0)
}
func AxsStateCalcPipelineInputsStartInputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(4, numElems, 4)
}
func AxsStateCalcPipelineInputsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	return builder.EndObject()
}