AppTaskInfo.go

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

package fbs

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

type AppTaskInfoT struct {
	Name string
	Priority uint32
	Watchdog bool
	WatchdogTime uint32
	CycleTime uint32
	AverageCycleTime uint32
	MaxCycleTime uint32
	MinCycleTime uint32
	CycleCount uint32
	WatchdogSensitivity uint32
	Interval uint32
	TaskType TaskType
	OsHandle uint64
}

func (t *AppTaskInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	if t == nil { return 0 }
	nameOffset := builder.CreateString(t.Name)
	AppTaskInfoStart(builder)
	AppTaskInfoAddName(builder, nameOffset)
	AppTaskInfoAddPriority(builder, t.Priority)
	AppTaskInfoAddWatchdog(builder, t.Watchdog)
	AppTaskInfoAddWatchdogTime(builder, t.WatchdogTime)
	AppTaskInfoAddCycleTime(builder, t.CycleTime)
	AppTaskInfoAddAverageCycleTime(builder, t.AverageCycleTime)
	AppTaskInfoAddMaxCycleTime(builder, t.MaxCycleTime)
	AppTaskInfoAddMinCycleTime(builder, t.MinCycleTime)
	AppTaskInfoAddCycleCount(builder, t.CycleCount)
	AppTaskInfoAddWatchdogSensitivity(builder, t.WatchdogSensitivity)
	AppTaskInfoAddInterval(builder, t.Interval)
	AppTaskInfoAddTaskType(builder, t.TaskType)
	AppTaskInfoAddOsHandle(builder, t.OsHandle)
	return AppTaskInfoEnd(builder)
}

func (rcv *AppTaskInfo) UnPackTo(t *AppTaskInfoT) {
	t.Name = string(rcv.Name())
	t.Priority = rcv.Priority()
	t.Watchdog = rcv.Watchdog()
	t.WatchdogTime = rcv.WatchdogTime()
	t.CycleTime = rcv.CycleTime()
	t.AverageCycleTime = rcv.AverageCycleTime()
	t.MaxCycleTime = rcv.MaxCycleTime()
	t.MinCycleTime = rcv.MinCycleTime()
	t.CycleCount = rcv.CycleCount()
	t.WatchdogSensitivity = rcv.WatchdogSensitivity()
	t.Interval = rcv.Interval()
	t.TaskType = rcv.TaskType()
	t.OsHandle = rcv.OsHandle()
}

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

type AppTaskInfo struct {
	_tab flatbuffers.Table
}

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

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

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

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

func (rcv *AppTaskInfo) Name() []byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		return rcv._tab.ByteVector(o + rcv._tab.Pos)
	}
	return nil
}

func (rcv *AppTaskInfo) Priority() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutatePriority(n uint32) bool {
	return rcv._tab.MutateUint32Slot(6, n)
}

func (rcv *AppTaskInfo) Watchdog() bool {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
	if o != 0 {
		return rcv._tab.GetBool(o + rcv._tab.Pos)
	}
	return false
}

func (rcv *AppTaskInfo) MutateWatchdog(n bool) bool {
	return rcv._tab.MutateBoolSlot(8, n)
}

func (rcv *AppTaskInfo) WatchdogTime() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateWatchdogTime(n uint32) bool {
	return rcv._tab.MutateUint32Slot(10, n)
}

func (rcv *AppTaskInfo) CycleTime() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateCycleTime(n uint32) bool {
	return rcv._tab.MutateUint32Slot(12, n)
}

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

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

func (rcv *AppTaskInfo) MaxCycleTime() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateMaxCycleTime(n uint32) bool {
	return rcv._tab.MutateUint32Slot(16, n)
}

func (rcv *AppTaskInfo) MinCycleTime() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateMinCycleTime(n uint32) bool {
	return rcv._tab.MutateUint32Slot(18, n)
}

func (rcv *AppTaskInfo) CycleCount() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateCycleCount(n uint32) bool {
	return rcv._tab.MutateUint32Slot(20, n)
}

func (rcv *AppTaskInfo) WatchdogSensitivity() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateWatchdogSensitivity(n uint32) bool {
	return rcv._tab.MutateUint32Slot(22, n)
}

func (rcv *AppTaskInfo) Interval() uint32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
	if o != 0 {
		return rcv._tab.GetUint32(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateInterval(n uint32) bool {
	return rcv._tab.MutateUint32Slot(24, n)
}

func (rcv *AppTaskInfo) TaskType() TaskType {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
	if o != 0 {
		return TaskType(rcv._tab.GetUint32(o + rcv._tab.Pos))
	}
	return 255
}

func (rcv *AppTaskInfo) MutateTaskType(n TaskType) bool {
	return rcv._tab.MutateUint32Slot(26, uint32(n))
}

func (rcv *AppTaskInfo) OsHandle() uint64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
	if o != 0 {
		return rcv._tab.GetUint64(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *AppTaskInfo) MutateOsHandle(n uint64) bool {
	return rcv._tab.MutateUint64Slot(28, n)
}

func AppTaskInfoStart(builder *flatbuffers.Builder) {
	builder.StartObject(13)
}
func AppTaskInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
}
func AppTaskInfoAddPriority(builder *flatbuffers.Builder, priority uint32) {
	builder.PrependUint32Slot(1, priority, 0)
}
func AppTaskInfoAddWatchdog(builder *flatbuffers.Builder, watchdog bool) {
	builder.PrependBoolSlot(2, watchdog, false)
}
func AppTaskInfoAddWatchdogTime(builder *flatbuffers.Builder, watchdogTime uint32) {
	builder.PrependUint32Slot(3, watchdogTime, 0)
}
func AppTaskInfoAddCycleTime(builder *flatbuffers.Builder, cycleTime uint32) {
	builder.PrependUint32Slot(4, cycleTime, 0)
}
func AppTaskInfoAddAverageCycleTime(builder *flatbuffers.Builder, averageCycleTime uint32) {
	builder.PrependUint32Slot(5, averageCycleTime, 0)
}
func AppTaskInfoAddMaxCycleTime(builder *flatbuffers.Builder, maxCycleTime uint32) {
	builder.PrependUint32Slot(6, maxCycleTime, 0)
}
func AppTaskInfoAddMinCycleTime(builder *flatbuffers.Builder, minCycleTime uint32) {
	builder.PrependUint32Slot(7, minCycleTime, 0)
}
func AppTaskInfoAddCycleCount(builder *flatbuffers.Builder, cycleCount uint32) {
	builder.PrependUint32Slot(8, cycleCount, 0)
}
func AppTaskInfoAddWatchdogSensitivity(builder *flatbuffers.Builder, watchdogSensitivity uint32) {
	builder.PrependUint32Slot(9, watchdogSensitivity, 0)
}
func AppTaskInfoAddInterval(builder *flatbuffers.Builder, interval uint32) {
	builder.PrependUint32Slot(10, interval, 0)
}
func AppTaskInfoAddTaskType(builder *flatbuffers.Builder, taskType TaskType) {
	builder.PrependUint32Slot(11, uint32(taskType), 255)
}
func AppTaskInfoAddOsHandle(builder *flatbuffers.Builder, osHandle uint64) {
	builder.PrependUint64Slot(12, osHandle, 0)
}
func AppTaskInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	return builder.EndObject()
}