From 0fb1be12c9bcfee92b9db3f5cc50f11bcee8ee1a Mon Sep 17 00:00:00 2001 From: guidfort Date: Tue, 26 Jul 2022 11:42:26 +0000 Subject: [PATCH 1/5] update ctrlx Data Layer sources --- Makefile | 4 +- README.md | 7 +- pkg/datalayer/client.go | 2 +- pkg/datalayer/doc_test.go | 42 +++++ pkg/datalayer/metadatabuilder.go | 239 ++++++++++++++++++++++++++++ pkg/datalayer/system.go | 1 - pkg/datalayer/variant.go | 152 ++++++++++++++---- pkg/datalayer/variant_64_linux.go | 9 ++ pkg/datalayer/variant_64_windows.go | 9 ++ 9 files changed, 431 insertions(+), 34 deletions(-) create mode 100644 pkg/datalayer/doc_test.go create mode 100644 pkg/datalayer/metadatabuilder.go diff --git a/Makefile b/Makefile index 2eb402f..54c7d5d 100644 --- a/Makefile +++ b/Makefile @@ -7,8 +7,8 @@ GOOS := $(shell go env GOOS) GOARCH := $(shell go env GOARCH) BUILD := build/public/$(GOOS)_$(GOARCH) -DATALAYER_DEB_VERSION := 1.12.1 -DATALAYER_DEB_FILE_VERSION := 1.7.5 +DATALAYER_DEB_VERSION := 1.16.0-prerelease +DATALAYER_DEB_FILE_VERSION := 1.8.6 .PHONY: all go-dep apt-dep lint vet test test-coverage build clean diff --git a/README.md b/README.md index 4364df3..1224f1b 100644 --- a/README.md +++ b/README.md @@ -3,10 +3,11 @@ This project provides ctrlX Data Layer access via Golang. It wraps the original ctrlX Data Layer written in C++. -Documentation and examples you find here [ctrlX Software Development Kit](https://boschrexroth.github.io/ctrlx-automation-sdk/). +Documentation and examples you can find here [ctrlX Software Development Kit](https://boschrexroth.github.io/ctrlx-automation-sdk/) and [GoDoc ](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/pkg/datalayer). ## Status + ![Make Test](https://github.com/boschrexroth/ctrlx-datalayer-golang/actions/workflows/main.yml/badge.svg) ## Usage @@ -22,8 +23,8 @@ sudo apt-get install libsystemd-dev libsystemd-dev:arm64 libzmq3-dev libzmq3-dev Check the current [ctrlx Data Layer](https://github.com/boschrexroth/ctrlx-automation-sdk/releases) debian package, download and install this, see example. ```bash -wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.12.1/ctrlx-datalayer-1.7.5.deb -sudo dpkg -i ctrlx-datalayer-1.7.5.deb +wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.16.0-prerelease/ctrlx-datalayer-1.8.6.deb +sudo dpkg -i ctrlx-datalayer-1.8.6.deb ``` ### Integrate in you project diff --git a/pkg/datalayer/client.go b/pkg/datalayer/client.go index bab8e3f..9ebe324 100755 --- a/pkg/datalayer/client.go +++ b/pkg/datalayer/client.go @@ -23,7 +23,7 @@ package datalayer /* -#cgo linux pkg-config: libsystemd libzmq +#cgo linux pkg-config: libsystemd libzmq ctrlx-datalayer #cgo CFLAGS: -I./headers -I/usr/include/comm/datalayer/c #cgo linux LDFLAGS: -lcomm_datalayer -lzmq #cgo windows,amd64 LDFLAGS: -lcomm_datalayer diff --git a/pkg/datalayer/doc_test.go b/pkg/datalayer/doc_test.go new file mode 100644 index 0000000..d5818b6 --- /dev/null +++ b/pkg/datalayer/doc_test.go @@ -0,0 +1,42 @@ +/** + * MIT License + * + * Copyright (c) 2021-2022 Bosch Rexroth AG + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package datalayer_test + +import ( + "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/datalayer" + fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/comm/datalayer" +) + +func ExampleMetaDataBuilder() { + m := datalayer.NewMetaDataBuilder(datalayer.AllowedOperationRead|datalayer.AllowedOperationWrite, "simple description", "") + m.DisplayName("myexample").NodeClass(fbs.NodeClassVariable) + + m.AddReference(datalayer.ReferenceTypeWrite, "type/myexample/write") + m.AddReference(datalayer.ReferenceTypeRead, "type/myexample/read") + + m.AddExtension("key", "value") + + v := m.Build() + defer datalayer.DeleteVariant(v) +} diff --git a/pkg/datalayer/metadatabuilder.go b/pkg/datalayer/metadatabuilder.go new file mode 100644 index 0000000..1ef6f5e --- /dev/null +++ b/pkg/datalayer/metadatabuilder.go @@ -0,0 +1,239 @@ +/** + * MIT License + * + * Copyright (c) 2021-2022 Bosch Rexroth AG + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package datalayer + +import ( + "sort" + + fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/comm/datalayer" + flatbuffers "github.com/google/flatbuffers/go" +) + +// AllowedOperation enum +type AllowedOperation uint + +// AllowedOperation enum defintion +const ( + AllowedOperationNone AllowedOperation = 0x00000 + AllowedOperationRead AllowedOperation = 0x00001 + AllowedOperationWrite AllowedOperation = 0x00010 + AllowedOperationCreate AllowedOperation = 0x00100 + AllowedOperationDelete AllowedOperation = 0x01000 + AllowedOperationBrowse AllowedOperation = 0x10000 + AllowedOperationAll AllowedOperation = AllowedOperationRead | AllowedOperationWrite | AllowedOperationCreate | AllowedOperationDelete | AllowedOperationBrowse +) + +// ReferenceType enum +type ReferenceType uint8 + +// ReferenceType enum defintion +const ( + ReferenceTypeRead ReferenceType = 0 + ReferenceTypeReadIn ReferenceType = 1 + ReferenceTypeReadOut ReferenceType = 2 + ReferenceTypeWrite ReferenceType = 3 + ReferenceTypeWriteIn ReferenceType = 4 + ReferenceTypeWriteOut ReferenceType = 5 + ReferenceTypeCreate ReferenceType = 6 + ReferenceTypeUses ReferenceType = 7 + ReferenceTypeHasSave ReferenceType = 8 +) + +// EnumNamesReferenceType enum defintion +var EnumNamesReferenceType = map[ReferenceType]string{ + ReferenceTypeRead: "readType", + ReferenceTypeReadIn: "readInType", + ReferenceTypeReadOut: "readOutType", + ReferenceTypeWrite: "writeType", + ReferenceTypeWriteIn: "writeInType", + ReferenceTypeWriteOut: "writeOutType", + ReferenceTypeCreate: "createType", + ReferenceTypeUses: "uses", + ReferenceTypeHasSave: "hasSave", +} + +// MetaDataBuilder struct +type MetaDataBuilder struct { + name string + description string + descriptionurl string + unit string + allowed AllowedOperation + nodeclass fbs.NodeClass + displayformat fbs.DisplayFormat + refers map[string]string + extensions map[string]string +} + +// NewMetaDataBuilder generates MetaDataBuilder instance +func NewMetaDataBuilder(a AllowedOperation, desc string, descurl string) *MetaDataBuilder { + m := &MetaDataBuilder{description: desc, descriptionurl: descurl} + m.name = "" + m.unit = "" + m.nodeclass = fbs.NodeClassNode + m.displayformat = fbs.DisplayFormatAuto + m.refers = make(map[string]string) + m.extensions = make(map[string]string) + m.Operations(a) + return m +} + +// Build this instance +func (m *MetaDataBuilder) Build() *Variant { + builder := flatbuffers.NewBuilder(1024) + + //Serialize References data + references := m.buildreferences() + + //Serialize Extensions data + extensions := m.buildextensions() + + //Serialize AllowedOperations data + operations := m.operations() + + meta := fbs.MetadataT{} + meta.Description = m.description + meta.DescriptionUrl = m.descriptionurl + meta.DisplayName = m.name + meta.Unit = m.unit + meta.DisplayFormat = m.displayformat + + meta.NodeClass = m.nodeclass + meta.Operations = operations + meta.References = references + meta.Extensions = extensions + mi := meta.Pack(builder) + builder.Finish(mi) + v := NewVariant() + v.SetFlatbuffers(builder.FinishedBytes()) + return v +} + +func (m *MetaDataBuilder) buildextensions() []*fbs.ExtensionT { + + extensions := []*fbs.ExtensionT{} + keys := sortkeys(m.extensions) + + for _, k := range keys { + re := m.addExt(k, m.extensions[k]) + extensions = append(extensions, re) + } + + return extensions +} + +func (m *MetaDataBuilder) addExt(key, val string) *fbs.ExtensionT { + ext := &fbs.ExtensionT{Key: key, Value: val} + return ext +} + +func sortkeys(m map[string]string) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} + +func (m *MetaDataBuilder) buildreferences() []*fbs.ReferenceT { + + references := []*fbs.ReferenceT{} + keys := sortkeys(m.refers) + for _, k := range keys { + //fmt.Println("refs: ", k, m.refers[k]) + re := m.addRef(k, m.refers[k]) + references = append(references, re) + } + + return references +} + +func (m *MetaDataBuilder) addRef(ty, addr string) *fbs.ReferenceT { + ref := &fbs.ReferenceT{Type: ty, TargetAddress: addr} + return ref +} + +func (m *MetaDataBuilder) operations() *fbs.AllowedOperationsT { + ops := &fbs.AllowedOperationsT{} + ops.Read = m.isallowed(AllowedOperationRead) + ops.Browse = m.isallowed(AllowedOperationBrowse) + ops.Create = m.isallowed(AllowedOperationCreate) + ops.Delete = m.isallowed(AllowedOperationDelete) + ops.Write = m.isallowed(AllowedOperationWrite) + return ops +} + +// Operations set the allowed operations +func (m *MetaDataBuilder) Operations(a AllowedOperation) *MetaDataBuilder { + m.allowed = a + return m +} + +func (m *MetaDataBuilder) isallowed(a AllowedOperation) bool { + return m.allowed&a == a +} + +// Unit sets the unit +func (m *MetaDataBuilder) Unit(u string) *MetaDataBuilder { + m.unit = u + return m +} + +// DisplayName sets the display name +func (m *MetaDataBuilder) DisplayName(n string) *MetaDataBuilder { + m.name = n + return m +} + +// NodeClass sets the node class +func (m *MetaDataBuilder) NodeClass(nc fbs.NodeClass) *MetaDataBuilder { + m.nodeclass = nc + return m +} + +// DisplayFormat sets the display format +func (m *MetaDataBuilder) DisplayFormat(df fbs.DisplayFormat) *MetaDataBuilder { + m.displayformat = df + return m +} + +// AddReference adds the reference +func (m *MetaDataBuilder) AddReference(r ReferenceType, t string) *MetaDataBuilder { + m.refers[ref2name(r)] = t + return m +} + +// AddExtension adds the extension +func (m *MetaDataBuilder) AddExtension(key string, val string) *MetaDataBuilder { + m.extensions[key] = val + return m +} + +func ref2name(r ReferenceType) string { + if s, ok := EnumNamesReferenceType[r]; ok { + return s + } + return "" +} diff --git a/pkg/datalayer/system.go b/pkg/datalayer/system.go index 897d4c5..b1b5a3f 100755 --- a/pkg/datalayer/system.go +++ b/pkg/datalayer/system.go @@ -64,7 +64,6 @@ func (d *System) Start(boStartBroker bool) { // Stop breaks a ctrlX Data Layer system. // Parameter boForceProviderStop forces stop off all created providers for this ctrlX Data Layer system. -// It returns false if there is a client or provider active. func (d *System) Stop(boForceProviderStop bool) { C.DLR_systemStop(d.this, C.bool(boForceProviderStop)) } diff --git a/pkg/datalayer/variant.go b/pkg/datalayer/variant.go index 25c20d6..3b69bfc 100755 --- a/pkg/datalayer/variant.go +++ b/pkg/datalayer/variant.go @@ -26,39 +26,45 @@ package datalayer //#include //#include import "C" -import "unsafe" +import ( + "math" + "time" + "unsafe" +) // VariantType enum type VariantType C.enum_DLR_VARIANT_TYPE // VariantType enum definition const ( - VariantTypeUnknown VariantType = C.DLR_VARIANT_TYPE_UNKNOWN - VariantTypeBool8 VariantType = C.DLR_VARIANT_TYPE_BOOL8 - VariantTypeInt8 VariantType = C.DLR_VARIANT_TYPE_INT8 - VariantTypeUint8 VariantType = C.DLR_VARIANT_TYPE_UINT8 - VariantTypeInt16 VariantType = C.DLR_VARIANT_TYPE_INT16 - VariantTypeUint16 VariantType = C.DLR_VARIANT_TYPE_UINT16 - VariantTypeInt32 VariantType = C.DLR_VARIANT_TYPE_INT32 - VariantTypeUint32 VariantType = C.DLR_VARIANT_TYPE_UINT32 - VariantTypeInt64 VariantType = C.DLR_VARIANT_TYPE_INT64 - VariantTypeUint64 VariantType = C.DLR_VARIANT_TYPE_UINT64 - VariantTypeFloat32 VariantType = C.DLR_VARIANT_TYPE_FLOAT32 - VariantTypeFloat64 VariantType = C.DLR_VARIANT_TYPE_FLOAT64 - VariantTypeString VariantType = C.DLR_VARIANT_TYPE_STRING - - VariantTypeArrayBool8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_BOOL8 - VariantTypeArrayInt8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT8 - VariantTypeArrayUint8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT8 - VariantTypeArrayInt16 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT16 - VariantTypeArrayUint16 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT16 - VariantTypeArrayInt32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT32 - VariantTypeArrayUint32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT32 - VariantTypeArrayInt64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT64 - VariantTypeArrayUint64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT64 - VariantTypeArrayFloat32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT32 - VariantTypeArrayFloat64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT64 - VariantTypeArrayString VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_STRING + VariantTypeUnknown VariantType = C.DLR_VARIANT_TYPE_UNKNOWN + VariantTypeBool8 VariantType = C.DLR_VARIANT_TYPE_BOOL8 + VariantTypeInt8 VariantType = C.DLR_VARIANT_TYPE_INT8 + VariantTypeUint8 VariantType = C.DLR_VARIANT_TYPE_UINT8 + VariantTypeInt16 VariantType = C.DLR_VARIANT_TYPE_INT16 + VariantTypeUint16 VariantType = C.DLR_VARIANT_TYPE_UINT16 + VariantTypeInt32 VariantType = C.DLR_VARIANT_TYPE_INT32 + VariantTypeUint32 VariantType = C.DLR_VARIANT_TYPE_UINT32 + VariantTypeInt64 VariantType = C.DLR_VARIANT_TYPE_INT64 + VariantTypeUint64 VariantType = C.DLR_VARIANT_TYPE_UINT64 + VariantTypeFloat32 VariantType = C.DLR_VARIANT_TYPE_FLOAT32 + VariantTypeFloat64 VariantType = C.DLR_VARIANT_TYPE_FLOAT64 + VariantTypeString VariantType = C.DLR_VARIANT_TYPE_STRING + VariantTypeTimestamp VariantType = C.DLR_VARIANT_TIMESTAMP + + VariantTypeArrayBool8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_BOOL8 + VariantTypeArrayInt8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT8 + VariantTypeArrayUint8 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT8 + VariantTypeArrayInt16 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT16 + VariantTypeArrayUint16 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT16 + VariantTypeArrayInt32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT32 + VariantTypeArrayUint32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT32 + VariantTypeArrayInt64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_INT64 + VariantTypeArrayUint64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_UINT64 + VariantTypeArrayFloat32 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT32 + VariantTypeArrayFloat64 VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT64 + VariantTypeArrayString VariantType = C.DLR_VARIANT_TYPE_ARRAY_OF_STRING + VariantTypeArrayTimestamp VariantType = C.DLR_VARIANT_ARRAY_OF_TIMESTAMP VariantTypeRaw VariantType = C.DLR_VARIANT_TYPE_RAW VariantTypeFlatbuffers VariantType = C.DLR_VARIANT_TYPE_FLATBUFFERS @@ -80,12 +86,18 @@ func DeleteVariant(v *Variant) { if v == nil { return } + if v.this == nil { + return + } C.DLR_variantDelete(v.this) } // GetType returns the type of the variant instance. // It returns the variant type. func (v *Variant) GetType() VariantType { + if v.this == nil { + return VariantTypeUnknown + } t := C.DLR_variantGetType(v.this) ty := VariantType(t) return ty @@ -94,30 +106,51 @@ func (v *Variant) GetType() VariantType { // GetData takes the pointer to the data of the variant instance. // It returns the array of bytes. func (v *Variant) GetData() unsafe.Pointer { + if v.this == nil { + return unsafe.Pointer(nil) + } return unsafe.Pointer(C.DLR_variantGetData(v.this)) } // GetSize gets the size of the type in bytes. // It returns the size of the type in bytes. func (v *Variant) GetSize() uint64 { + if v.this == nil { + return uint64(0) + } return uint64(C.DLR_variantGetSize(v.this)) } // GetCount returns the count of elements in the variant (scalar data types = 1, array = count of elements in array). // It returns the count of a type. func (v *Variant) GetCount() uint64 { + if v.this == nil { + return uint64(0) + } return uint64(C.DLR_variantGetCount(v.this)) } // CheckConvert checks whether the variant can be converted to another type. // It returns the status of function call. func (v *Variant) CheckConvert(ty VariantType) Result { + if v.this == nil { + return ResultNotInitialized + } return Result(C.DLR_variantCheckConvert(v.this, C.DLR_VARIANT_TYPE(ty))) } // Copy copies the content of a variant to another variant. // It returns the status of function call or the copy of variant or a tuple. func (v *Variant) Copy(dest *Variant) Result { + if dest == nil { + return ResultNotInitialized + } + if dest.this == nil { + return ResultNotInitialized + } + if v.this == nil { + return ResultNotInitialized + } return Result(C.DLR_variantCopy(dest.this, v.this)) } @@ -385,3 +418,68 @@ func (v *Variant) SetString(data string) { defer C.free(unsafe.Pointer(cdata)) C.DLR_variantSetSTRING(v.this, cdata) } + +// SetTimestamp sets a timestamp value as (FILETIME) 64 bit 100ns since 1.1.1601 (UTC) +// It returns the status of function call. +func (v *Variant) SetTimestamp(ft uint64) { + C.DLR_variantSetTimestamp(v.this, C.ulong(ft)) +} + +func convertUnixTime2FileTime(input int64) int64 { + temp := input / 100 + temp = temp + 116444736000000000 + return temp +} + +// GetTime returns the value of the variant as a time.Time since January 1, 1970 UTC. +// It returns >= January 1, 1970 UTC +func (v *Variant) GetTime() time.Time { + t := v.GetUint64() + return getTime(int64(t)) +} + +// SetTime sets a time.Time value since January 1, 1970 UTC +// It returns the status of function call. +func (v *Variant) SetTime(df time.Time) { + ns := df.UTC().UnixNano() + ft := convertUnixTime2FileTime(ns) + v.SetTimestamp(uint64(ft)) +} + +// see. https://stackoverflow.com/questions/57901280/calculate-time-time-from-timestamp-starting-from-1601-01-01-in-go +func getTime(input int64) time.Time { + maxd := time.Duration(math.MaxInt64).Truncate(100 * time.Nanosecond) + maxdUnits := int64(maxd / 100) // number of 100-ns units + + t := time.Date(1601, 1, 1, 0, 0, 0, 0, time.UTC) + for input > maxdUnits { + t = t.Add(maxd) + input -= maxdUnits + } + if input != 0 { + t = t.Add(time.Duration(input * 100)) + } + return t +} + +// GetArrayTime returns the value of the variant as an array of time.Time since January 1, 1970 UTC. +// It returns >= January 1, 1970 UTC +func (v *Variant) GetArrayTime() []time.Time { + t := v.GetArrayUint64() + vals := []time.Time{} + for _, ft := range t { + vals = append(vals, getTime(int64(ft))) + } + return vals +} + +// SetArrayTime sets an array of time.Time value since January 1, 1970 UTC +// It returns the status of function call. +func (v *Variant) SetArrayTime(dfs []time.Time) { + fts := []uint64{} + for _, df := range dfs { + ns := df.UTC().UnixNano() + fts = append(fts, uint64(convertUnixTime2FileTime(ns))) + } + v.SetArrayTimestamp(fts) +} diff --git a/pkg/datalayer/variant_64_linux.go b/pkg/datalayer/variant_64_linux.go index 68a6a8a..932a084 100644 --- a/pkg/datalayer/variant_64_linux.go +++ b/pkg/datalayer/variant_64_linux.go @@ -186,3 +186,12 @@ func (v *Variant) SetFlatbuffers(data []byte) { C.DLR_variantSetFlatbuffers(v.this, (*C.schar)(unsafe.Pointer(&data[0])), C.ulong(len(data))) } } + +// SetArrayTimestamp function +func (v *Variant) SetArrayTimestamp(data []uint64) { + if len(data) == 0 { + C.DLR_variantSetARRAY_OF_TIMESTAMP(v.this, nil, C.ulong(0)) + } else { + C.DLR_variantSetARRAY_OF_TIMESTAMP(v.this, (*C.ulong)(unsafe.Pointer(&data[0])), C.ulong(len(data))) + } +} diff --git a/pkg/datalayer/variant_64_windows.go b/pkg/datalayer/variant_64_windows.go index cfca10b..988bed8 100644 --- a/pkg/datalayer/variant_64_windows.go +++ b/pkg/datalayer/variant_64_windows.go @@ -185,3 +185,12 @@ func (v *Variant) SetFlatbuffers(data []byte) { C.DLR_variantSetFlatbuffers(v.this, (*C.schar)(unsafe.Pointer(&data[0])), C.ulonglong(len(data))) } } + +// SetArrayTimestamp function +func (v *Variant) SetArrayTimestamp(data []uint64) { + if len(data) == 0 { + C.DLR_variantSetARRAY_OF_TIMESTAMP(v.this, nil, C.ulonglong(0)) + } else { + C.DLR_variantSetARRAY_OF_TIMESTAMP(v.this, (*C.ulonglong)(unsafe.Pointer(&data[0])), C.ulonglong(len(data))) + } +} From a7f6822c8046baea18436fa27d0d05d37007d3ec Mon Sep 17 00:00:00 2001 From: guidfort Date: Tue, 26 Jul 2022 11:44:25 +0000 Subject: [PATCH 2/5] update fbs sources --- .../comm/axisprofile/fbtypes/APRBootState.go | 29 ++ .../axisprofile/fbtypes/ScalingStrategy.go | 35 ++ .../axisprofile/fbtypes/deviceScalingType.go | 35 ++ pkg/fbs/comm/axisprofile/fbtypes/dummyFbs.go | 48 ++ .../comm/axisprofile/fbtypes/mappingEntry.go | 27 ++ pkg/fbs/comm/axisprofile/fbtypes/profile.go | 26 + .../comm/axisprofile/fbtypes/profileConfig.go | 64 ++- .../axisprofile/fbtypes/profileConfigInfo.go | 68 ++- .../fbtypes/profileDeviceScalingType.go | 78 +++ .../axisprofile/fbtypes/profileScalingCfg.go | 154 ++++++ .../fbtypes/profileScalingStrategy.go | 78 +++ .../axisprofile/fbtypes/profileTypeData.go | 22 + .../comm/axisprofile/fbtypes/valueMapping.go | 41 ++ pkg/fbs/comm/datalayer/AccessType.go | 35 ++ pkg/fbs/comm/datalayer/AllowedOperations.go | 34 ++ pkg/fbs/comm/datalayer/ArrayOfBool8.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfFloat32.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfFloat64.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfInt16.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfInt32.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfInt64.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfInt8.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfString.go | 39 ++ pkg/fbs/comm/datalayer/ArrayOfTimestamp.go | 108 +++++ pkg/fbs/comm/datalayer/ArrayOfUInt16.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfUInt32.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfUInt64.go | 35 ++ pkg/fbs/comm/datalayer/ArrayOfUInt8.go | 26 + pkg/fbs/comm/datalayer/Bool8.go | 22 + pkg/fbs/comm/datalayer/ChangeEvents.go | 28 ++ pkg/fbs/comm/datalayer/CheckOperations.go | 27 ++ pkg/fbs/comm/datalayer/Claim.go | 27 ++ pkg/fbs/comm/datalayer/Counting.go | 22 + pkg/fbs/comm/datalayer/DataChangeFilter.go | 22 + pkg/fbs/comm/datalayer/DebugChannel.go | 30 ++ pkg/fbs/comm/datalayer/DiagMoreInfo.go | 90 ++++ pkg/fbs/comm/datalayer/Diagnosis.go | 131 ++++- pkg/fbs/comm/datalayer/Extension.go | 27 ++ pkg/fbs/comm/datalayer/FactoryStats.go | 31 ++ pkg/fbs/comm/datalayer/Float32.go | 22 + pkg/fbs/comm/datalayer/Float64.go | 22 + pkg/fbs/comm/datalayer/Int16.go | 22 + pkg/fbs/comm/datalayer/Int32.go | 22 + pkg/fbs/comm/datalayer/Int64.go | 22 + pkg/fbs/comm/datalayer/Int8.go | 22 + pkg/fbs/comm/datalayer/LocaleText.go | 27 ++ pkg/fbs/comm/datalayer/Memory.go | 49 +- pkg/fbs/comm/datalayer/MemoryMap.go | 44 ++ pkg/fbs/comm/datalayer/MessageDetail.go | 22 + pkg/fbs/comm/datalayer/Metadata.go | 133 ++++++ pkg/fbs/comm/datalayer/MetadataDB.go | 53 +++ pkg/fbs/comm/datalayer/NTelBufferConfig.go | 78 +++ pkg/fbs/comm/datalayer/NotifyInfo.go | 29 ++ pkg/fbs/comm/datalayer/PersistenceParam.go | 31 ++ pkg/fbs/comm/datalayer/Problem.go | 174 ++++++- pkg/fbs/comm/datalayer/ProgramTask.go | 50 +- pkg/fbs/comm/datalayer/ProgramTaskAll.go | 41 ++ pkg/fbs/comm/datalayer/Properties.go | 51 +- pkg/fbs/comm/datalayer/Property.go | 30 ++ pkg/fbs/comm/datalayer/Queueing.go | 25 + pkg/fbs/comm/datalayer/Raw.go | 35 ++ pkg/fbs/comm/datalayer/RealtimeConfig.go | 98 ++++ pkg/fbs/comm/datalayer/Reference.go | 27 ++ pkg/fbs/comm/datalayer/RetainStats.go | 41 ++ pkg/fbs/comm/datalayer/Sampling.go | 22 + pkg/fbs/comm/datalayer/Scope.go | 192 +++++++- pkg/fbs/comm/datalayer/Scopes.go | 41 ++ pkg/fbs/comm/datalayer/ServerSettings.go | 45 +- pkg/fbs/comm/datalayer/String.go | 23 + pkg/fbs/comm/datalayer/SubscriptionData.go | 43 ++ .../comm/datalayer/SubscriptionProperties.go | 54 +++ .../comm/datalayer/SubscriptionSettings.go | 31 ++ pkg/fbs/comm/datalayer/Timestamp.go | 78 +++ pkg/fbs/comm/datalayer/Token.go | 78 +++ pkg/fbs/comm/datalayer/UInt16.go | 22 + pkg/fbs/comm/datalayer/UInt32.go | 22 + pkg/fbs/comm/datalayer/UInt64.go | 22 + pkg/fbs/comm/datalayer/UInt8.go | 22 + pkg/fbs/comm/datalayer/Variable.go | 33 ++ pkg/fbs/comm/datalayer/Watchlist.go | 43 ++ pkg/fbs/comm/datalayer/Watchlists.go | 41 ++ pkg/fbs/comm/datalayer/framework/Bundle.go | 66 +++ .../comm/datalayer/framework/BundleList.go | 41 ++ pkg/fbs/comm/datalayer/framework/Component.go | 78 +++ .../comm/datalayer/framework/ComponentList.go | 41 ++ .../comm/datalayer/framework/Dependency.go | 33 ++ .../datalayer/framework/DependencyList.go | 41 ++ pkg/fbs/comm/datalayer/framework/Exception.go | 188 ++++++++ .../comm/datalayer/framework/Exceptions.go | 108 +++++ .../datalayer/framework/InterfaceList_.go | 41 ++ .../comm/datalayer/framework/Interface_.go | 53 +++ pkg/fbs/comm/datalayer/framework/Property.go | 27 ++ .../comm/datalayer/framework/PropertyList.go | 41 ++ pkg/fbs/comm/datalayer/framework/Register.go | 105 ++++ .../comm/datalayer/framework/Stackentry.go | 93 ++++ pkg/fbs/comm/datalayer/remote/ConfigItem.go | 27 ++ pkg/fbs/comm/datalayer/remote/RemoteConfig.go | 108 +++++ .../ethercat/master/fbs/AddressedRequest.go | 25 + .../comm/ethercat/master/fbs/AoeConfigInfo.go | 27 ++ .../master/fbs/AoeConfigInfoResponse.go | 26 + .../comm/ethercat/master/fbs/AoeControl.go | 27 ++ .../ethercat/master/fbs/AoeControlRequest.go | 48 ++ .../ethercat/master/fbs/AoeControlResponse.go | 25 + pkg/fbs/comm/ethercat/master/fbs/AoeData.go | 27 ++ .../ethercat/master/fbs/AoeDataRequest.go | 51 ++ .../ethercat/master/fbs/AoeDataResponse.go | 32 ++ .../master/fbs/BusLoadStatisticCounters.go | 80 ++++ .../fbs/BusLoadStatisticCountersResponse.go | 100 ++++ .../comm/ethercat/master/fbs/Capability.go | 27 ++ .../ethercat/master/fbs/CapableInterfaces.go | 41 ++ pkg/fbs/comm/ethercat/master/fbs/Checksum.go | 23 + .../ethercat/master/fbs/ChecksumElement.go | 30 ++ .../ethercat/master/fbs/ChecksumResponse.go | 41 ++ .../comm/ethercat/master/fbs/CommDirection.go | 32 ++ .../comm/ethercat/master/fbs/DcConfigInfo.go | 80 ++++ .../master/fbs/DcConfigInfoResponse.go | 168 +++++++ .../comm/ethercat/master/fbs/DcOnlineInfo.go | 80 ++++ .../master/fbs/DcOnlineInfoResponse.go | 186 ++++++++ .../ethercat/master/fbs/EntryDescription.go | 27 ++ .../master/fbs/EntryDescriptionRequest.go | 37 ++ .../master/fbs/EntryDescriptionResponse.go | 26 + .../comm/ethercat/master/fbs/EoeConfigInfo.go | 27 ++ .../master/fbs/EoeConfigInfoResponse.go | 58 +++ .../master/fbs/EthercatIdentityInfo.go | 25 + .../master/fbs/EthercatMailboxInfo.go | 21 + .../ethercat/master/fbs/EthercatMemoryInfo.go | 21 + .../ethercat/master/fbs/FieldbusConfig.go | 27 ++ .../master/fbs/FieldbusConfigRequest.go | 33 ++ .../master/fbs/FieldbusConfigResponse.go | 33 ++ pkg/fbs/comm/ethercat/master/fbs/Foe.go | 100 ++++ .../comm/ethercat/master/fbs/FoeRequest.go | 212 +++++++++ .../comm/ethercat/master/fbs/FoeResponse.go | 107 +++++ .../master/fbs/FrameStatisticCounters.go | 80 ++++ .../fbs/FrameStatisticCountersResponse.go | 222 +++++++++ .../master/fbs/FrameStatisticReset.go | 80 ++++ .../master/fbs/FrameStatisticResetRequest.go | 186 ++++++++ .../comm/ethercat/master/fbs/InhibitTime.go | 80 ++++ .../master/fbs/InhibitTimeResponse.go | 78 +++ .../ethercat/master/fbs/InstancesCreate.go | 23 + .../master/fbs/InstancesCreateRequest.go | 35 ++ pkg/fbs/comm/ethercat/master/fbs/Interface.go | 53 +++ .../master/fbs/LinkLayerConfigInfo.go | 80 ++++ .../master/fbs/LinkLayerConfigInfoResponse.go | 105 ++++ .../master/fbs/LinkLayerOnlineInfo.go | 80 ++++ .../master/fbs/LinkLayerOnlineInfoResponse.go | 311 ++++++++++++ pkg/fbs/comm/ethercat/master/fbs/LinkMode.go | 32 ++ .../comm/ethercat/master/fbs/LinkStatus.go | 35 ++ .../master/fbs/MailboxStatisticCounters.go | 80 ++++ .../fbs/MailboxStatisticCountersResponse.go | 200 ++++++++ .../master/fbs/MailboxStatisticReset.go | 100 ++++ .../fbs/MailboxStatisticResetRequest.go | 200 ++++++++ .../fbs/MailboxStatisticResetResponse.go | 60 +++ .../comm/ethercat/master/fbs/MasterInfo.go | 80 ++++ .../ethercat/master/fbs/MasterInfoResponse.go | 254 ++++++++++ .../comm/ethercat/master/fbs/MasterState.go | 27 ++ .../ethercat/master/fbs/MasterStateRequest.go | 22 + .../master/fbs/MasterStateResponse.go | 25 + .../comm/ethercat/master/fbs/MasterStatus.go | 23 + .../master/fbs/MasterStatusResponse.go | 22 + .../ethercat/master/fbs/MinActMaxValues.go | 72 +++ .../master/fbs/NumConfiguredSlaves.go | 23 + .../master/fbs/NumConfiguredSlavesResponse.go | 22 + .../ethercat/master/fbs/NumConnectedSlaves.go | 23 + .../master/fbs/NumConnectedSlavesResponse.go | 22 + .../ethercat/master/fbs/ObjectDescription.go | 27 ++ .../master/fbs/ObjectDescriptionRequest.go | 31 ++ .../master/fbs/ObjectDescriptionResponse.go | 26 + .../master/fbs/ObjectDictionaryList.go | 27 ++ .../master/fbs/ObjectDictionaryListRequest.go | 31 ++ .../fbs/ObjectDictionaryListResponse.go | 35 ++ pkg/fbs/comm/ethercat/master/fbs/Parameter.go | 27 ++ .../ethercat/master/fbs/ParameterRequest.go | 44 ++ .../ethercat/master/fbs/ParameterResponse.go | 29 ++ .../ethercat/master/fbs/PortErrorCounters.go | 25 + .../ethercat/master/fbs/ProfileChannelInfo.go | 100 ++++ .../master/fbs/ProfileChannelInfoRequest.go | 114 +++++ .../master/fbs/ProfileChannelInfoResponse.go | 111 +++++ .../ethercat/master/fbs/ProtocolStatistic.go | 75 +++ .../master/fbs/ProtocolStatisticCounters.go | 62 +++ .../fbs/ProtocolStatisticPeriodCounters.go | 67 +++ .../fbs/ProtocolStatisticPeriodReset.go | 67 +++ .../master/fbs/ProtocolStatisticReset.go | 75 +++ .../master/fbs/ProtocolStatisticResetFlags.go | 62 +++ pkg/fbs/comm/ethercat/master/fbs/SDO.go | 27 ++ .../comm/ethercat/master/fbs/SDORequest.go | 44 ++ .../comm/ethercat/master/fbs/SDOResponse.go | 26 + .../ethercat/master/fbs/SlaveConfigInfo.go | 27 ++ .../master/fbs/SlaveConfigInfoResponse.go | 171 +++++++ .../comm/ethercat/master/fbs/SlaveEeprom.go | 27 ++ .../ethercat/master/fbs/SlaveEepromRequest.go | 47 ++ .../master/fbs/SlaveEepromResponse.go | 35 ++ .../ethercat/master/fbs/SlaveOnlineInfo.go | 27 ++ .../master/fbs/SlaveOnlineInfoResponse.go | 127 +++++ .../comm/ethercat/master/fbs/SlaveRegister.go | 27 ++ .../master/fbs/SlaveRegisterRequest.go | 38 ++ .../master/fbs/SlaveRegisterResponse.go | 26 + .../comm/ethercat/master/fbs/SlaveState.go | 27 ++ .../ethercat/master/fbs/SlaveStateRequest.go | 28 ++ .../ethercat/master/fbs/SlaveStateResponse.go | 25 + .../master/fbs/SlaveStatisticCounters.go | 27 ++ .../fbs/SlaveStatisticCountersResponse.go | 46 ++ .../master/fbs/SlaveStatisticModeAuto.go | 27 ++ .../fbs/SlaveStatisticModeAutoRequest.go | 25 + .../fbs/SlaveStatisticModeAutoResponse.go | 25 + .../SlaveStatisticModeSingleShotTrigger.go | 27 ++ ...veStatisticModeSingleShotTriggerRequest.go | 22 + ...eStatisticModeSingleShotTriggerResponse.go | 25 + pkg/fbs/comm/ethercat/master/fbs/SyncMode.go | 44 ++ .../comm/ethercat/master/fbs/TopologyState.go | 32 ++ .../ethercat/master/fbs/TopologyStatus.go | 80 ++++ .../master/fbs/TopologyStatusResponse.go | 96 ++++ pkg/fbs/comm/ethercat/master/fbs/taskInfo.go | 100 ++++ .../comm/opcua/client/ClientConfiguration.go | 55 ++- .../opcua/client/DlResultToUaStatusCode.go | 33 ++ pkg/fbs/comm/opcua/client/ErrorCodeMapping.go | 41 ++ .../comm/opcua/client/MessageSecurityMode.go | 22 + pkg/fbs/comm/opcua/client/SecurityPolicy.go | 22 + .../comm/opcua/client/SessionConfiguration.go | 51 ++ pkg/fbs/comm/opcua/client/State.go | 22 + .../comm/opcua/client/TimeoutConfiguration.go | 60 ++- pkg/fbs/comm/opcua/client/TokenAnonymous.go | 19 + pkg/fbs/comm/opcua/client/TokenCert.go | 27 ++ .../comm/opcua/client/TokenUserPassword.go | 27 ++ .../comm/opcua/client/UserIdentityToken.go | 30 ++ .../opcua/client/UserIdentityTokenUnion.go | 41 +- .../server/ArrayOfCertificateConfigType.go | 108 +++++ .../opcua/server/ArrayOfObjectPoolDiagType.go | 108 +++++ .../comm/opcua/server/ArrayOfSecConfigType.go | 108 +++++ .../comm/opcua/server/ArrayOfUserTokenType.go | 108 +++++ pkg/fbs/comm/opcua/server/BuildInfoType.go | 153 ++++++ .../opcua/server/CertificateConfigType.go | 210 ++++++++ pkg/fbs/comm/opcua/server/EnumServerState.go | 50 ++ pkg/fbs/comm/opcua/server/HeapDiagType.go | 96 ++++ .../comm/opcua/server/ObjectPoolDiagType.go | 129 +++++ pkg/fbs/comm/opcua/server/SecConfigType.go | 132 ++++++ .../server/ServerDiagnosticsSummaryType.go | 276 +++++++++++ pkg/fbs/comm/opcua/server/ServerStateType.go | 78 +++ pkg/fbs/comm/opcua/server/ServerStatusType.go | 167 +++++++ pkg/fbs/comm/opcua/server/UserTokenType.go | 25 + .../common/log/diagnosis/fbs/ClassConfig.go | 22 + .../log/diagnosis/fbs/DetailedDiagnostic.go | 30 ++ .../log/diagnosis/fbs/DiagnosisElement.go | 29 ++ .../log/diagnosis/fbs/DiagnosisElements.go | 41 ++ .../diagnosis/fbs/DiagnosisIdentification.go | 31 ++ .../DiagnosisIdentificationWithTimestamp.go | 27 ++ .../common/log/diagnosis/fbs/EventType1.go | 22 + .../common/log/diagnosis/fbs/EventType2.go | 22 + .../diagnosis/fbs/GetDetailedDiagnosisText.go | 27 ++ .../log/diagnosis/fbs/GetMainDiagnosisText.go | 23 + ...istDiagnosisIdentificationWithTimestamp.go | 41 ++ .../common/log/diagnosis/fbs/LogParameters.go | 58 +++ .../log/diagnosis/fbs/MainDiagnostic.go | 52 ++ .../diagnosis/fbs/PendingDiagnosticState.go | 78 +++ .../log/diagnosis/fbs/RegistrationFile.go | 53 +++ pkg/fbs/common/log/diagnosis/fbs/State.go | 32 ++ pkg/fbs/common/log/trace/fbs/EnablingState.go | 32 ++ .../common/log/trace/fbs/EnablingStates.go | 45 ++ .../scheduler/controls/fbs/AdminControls.go | 30 ++ .../common/scheduler/controls/fbs/Controls.go | 31 +- .../common/scheduler/controls/fbs/Debug.go | 23 + pkg/fbs/common/scheduler/fbs/Admin.go | 48 +- pkg/fbs/common/scheduler/fbs/Callable.go | 119 ++++- .../scheduler/fbs/CallableConfiguration.go | 186 ++++++++ .../scheduler/fbs/CallableConfigurations.go | 110 +++++ .../common/scheduler/fbs/CallableWdgConfig.go | 39 ++ pkg/fbs/common/scheduler/fbs/CpuInfo.go | 117 +++++ pkg/fbs/common/scheduler/fbs/DataRt.go | 25 + pkg/fbs/common/scheduler/fbs/Duration.go | 31 ++ pkg/fbs/common/scheduler/fbs/DurationRt.go | 60 ++- pkg/fbs/common/scheduler/fbs/DurationTimer.go | 22 + pkg/fbs/common/scheduler/fbs/Histogram.go | 38 ++ pkg/fbs/common/scheduler/fbs/Program.go | 51 +- pkg/fbs/common/scheduler/fbs/Programs.go | 41 ++ .../scheduler/fbs/StartupErrorReaction.go | 22 + pkg/fbs/common/scheduler/fbs/State.go | 22 + pkg/fbs/common/scheduler/fbs/SyncPoints.go | 152 ++++++ pkg/fbs/common/scheduler/fbs/Task.go | 39 ++ pkg/fbs/common/scheduler/fbs/TaskSpecs.go | 111 +++++ pkg/fbs/common/scheduler/fbs/Timer.go | 3 + pkg/fbs/common/scheduler/fbs/Trigger.go | 22 + pkg/fbs/common/scheduler/fbs2/Admin.go | 233 +++++++++ pkg/fbs/common/scheduler/fbs2/CpuInfo.go | 447 ++++++++++++++++++ pkg/fbs/common/scheduler/fbs2/CurrentState.go | 35 ++ pkg/fbs/common/scheduler/fbs2/Program.go | 194 ++++++++ pkg/fbs/common/scheduler/fbs2/Programs.go | 151 ++++++ pkg/fbs/common/scheduler/fbs2/State.go | 78 +++ .../watchdog/errorreaction/fbs/Class.go | 22 + .../errorreaction/fbs/Configuration.go | 22 + .../scheduler/watchdog/fbs/CurrentType.go | 3 + .../common/scheduler/watchdog/fbs/Cyclic.go | 29 ++ .../common/scheduler/watchdog/fbs/Duration.go | 32 ++ .../scheduler/watchdog/fbs/ErrorReaction.go | 32 +- pkg/fbs/common/scheduler/watchdog/fbs/Type.go | 22 + .../common/scheduler/watchdog/fbs/Watchdog.go | 38 ++ .../scheduler/watchdog/fbs/WatchdogVariant.go | 36 +- .../licenseproxy/LicenseCapabilities.go | 41 ++ .../licenseproxy/LicenseCapability.go | 41 ++ .../systemcore/licenseproxy/LicenseRequest.go | 27 ++ .../licenseproxy/LicenseResponse.go | 45 ++ .../common/systemhandler/fbs/CurrentState.go | 54 ++- pkg/fbs/common/systemhandler/fbs/State.go | 22 + pkg/fbs/common/testbuddy/Data.go | 93 ++++ pkg/fbs/common/testbuddy/Log.go | 111 +++++ pkg/fbs/common/testbuddy/LogType.go | 32 ++ pkg/fbs/common/testbuddy/TestResult.go | 192 ++++++++ .../fbtypes/CollisionAvoidance.go | 114 +++++ .../fbtypes/CollisionGuardState.go | 45 ++ .../fbtypes/GetCollisionGuardStateParams.go | 277 +++++++++++ .../motion/core/fbtypes/AcquiredLicenses.go | 41 ++ .../motion/core/fbtypes/AxsActualValues.go | 54 +++ .../core/fbtypes/AxsBrakingDistanceEx.go | 172 +++++++ pkg/fbs/motion/core/fbtypes/AxsCfg.go | 75 ++- pkg/fbs/motion/core/fbtypes/AxsCfgCoupling.go | 23 + .../core/fbtypes/AxsCfgDeviceErrorReaction.go | 27 ++ .../core/fbtypes/AxsCfgEstopDynamicLimits.go | 33 ++ .../core/fbtypes/AxsCfgEstopSettings.go | 37 ++ .../motion/core/fbtypes/AxsCfgFunctions.go | 77 ++- pkg/fbs/motion/core/fbtypes/AxsCfgGantry.go | 28 ++ .../core/fbtypes/AxsCfgKinProperties.go | 25 + pkg/fbs/motion/core/fbtypes/AxsCfgLimits.go | 75 +++ .../motion/core/fbtypes/AxsCfgProperties.go | 33 ++ .../motion/core/fbtypes/AxsCmdAbortData.go | 25 + .../core/fbtypes/AxsCmdAddToGantryData.go | 26 + .../motion/core/fbtypes/AxsCmdAddToKinData.go | 26 + pkg/fbs/motion/core/fbtypes/AxsCmdJogData.go | 30 ++ pkg/fbs/motion/core/fbtypes/AxsCmdPosData.go | 29 ++ pkg/fbs/motion/core/fbtypes/AxsCmdValues.go | 51 ++ pkg/fbs/motion/core/fbtypes/AxsCmdVelData.go | 143 ++++++ pkg/fbs/motion/core/fbtypes/AxsIpoValues.go | 47 ++ pkg/fbs/motion/core/fbtypes/BootState.go | 29 ++ pkg/fbs/motion/core/fbtypes/BrakeLimit.go | 36 ++ .../core/fbtypes/BrakingDistanceType.go | 36 ++ pkg/fbs/motion/core/fbtypes/Capability.go | 138 ++++++ pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go | 23 + pkg/fbs/motion/core/fbtypes/CmdSource.go | 30 ++ pkg/fbs/motion/core/fbtypes/DiagInfo.go | 55 +++ pkg/fbs/motion/core/fbtypes/DynamicLimits.go | 34 ++ .../motion/core/fbtypes/DynamicLimitsState.go | 54 +++ pkg/fbs/motion/core/fbtypes/IpoAddData.go | 47 ++ .../motion/core/fbtypes/KinActualValues.go | 76 +++ pkg/fbs/motion/core/fbtypes/KinAxsAll.go | 41 ++ pkg/fbs/motion/core/fbtypes/KinAxsSingle.go | 31 ++ pkg/fbs/motion/core/fbtypes/KinCfg.go | 85 +++- pkg/fbs/motion/core/fbtypes/KinCfgAxs.go | 31 ++ .../core/fbtypes/KinCfgAxsTrafoAllParam.go | 114 +++-- .../core/fbtypes/KinCfgAxsTrafoAllSets.go | 41 ++ .../fbtypes/KinCfgAxsTrafoAxisAssignment.go | 41 ++ .../motion/core/fbtypes/KinCfgAxsTrafoData.go | 43 +- .../fbtypes/KinCfgAxsTrafoDataAllParam.go | 156 ++++++ .../core/fbtypes/KinCfgAxsTrafoDataParam.go | 228 +++++++++ .../core/fbtypes/KinCfgAxsTrafoDataSingle.go | 52 +- .../core/fbtypes/KinCfgAxsTrafoParamGroup.go | 45 ++ .../motion/core/fbtypes/KinCfgAxsTrafoSet.go | 31 ++ .../KinCfgAxsTrafoSingleAxisAssignment.go | 26 + .../core/fbtypes/KinCfgAxsTrafoSingleParam.go | 33 ++ pkg/fbs/motion/core/fbtypes/KinCfgLimits.go | 54 +++ .../motion/core/fbtypes/KinCfgPrepLimits.go | 22 + .../motion/core/fbtypes/KinCmdAbortData.go | 81 ++++ .../motion/core/fbtypes/KinCmdContourData.go | 101 ++++ pkg/fbs/motion/core/fbtypes/KinCmdJogData.go | 46 ++ pkg/fbs/motion/core/fbtypes/KinCmdMoveData.go | 46 ++ .../core/fbtypes/KinCmdMoveDirectAsyncData.go | 46 ++ .../core/fbtypes/KinCmdMoveDirectData.go | 42 ++ .../core/fbtypes/KinCmdOptAxsDynLimData.go | 27 ++ .../motion/core/fbtypes/KinCmdOptBlendData.go | 29 ++ .../motion/core/fbtypes/KinCmdOptMCSData.go | 27 ++ .../motion/core/fbtypes/KinCmdOptPCSData.go | 27 ++ .../core/fbtypes/KinCmdOptPolyTransData.go | 32 ++ .../core/fbtypes/KinCmdOptSafeAreaData.go | 27 ++ pkg/fbs/motion/core/fbtypes/KinCmdValues.go | 50 ++ .../motion/core/fbtypes/KinCoordTransform.go | 59 +++ pkg/fbs/motion/core/fbtypes/KinIpoValues.go | 76 +++ pkg/fbs/motion/core/fbtypes/KinPosValues.go | 55 +++ pkg/fbs/motion/core/fbtypes/RTInputsCfg.go | 101 ++++ pkg/fbs/motion/core/fbtypes/SingleLicense.go | 27 ++ pkg/fbs/motion/core/fbtypes/SysCfg.go | 59 ++- pkg/fbs/motion/core/fbtypes/SysCfgFunction.go | 22 + pkg/fbs/motion/core/fbtypes/SysCfgInternal.go | 28 ++ pkg/fbs/motion/core/fbtypes/SysCfgPcsAll.go | 63 +++ pkg/fbs/motion/core/fbtypes/SysCfgPcsGroup.go | 43 ++ pkg/fbs/motion/core/fbtypes/SysCfgPcsSet.go | 134 ++++++ pkg/fbs/motion/core/fbtypes/SysCfgSafeArea.go | 52 ++ .../motion/core/fbtypes/SysCfgSafeAreaAll.go | 41 ++ .../motion/core/fbtypes/SysCfgSafeAreaBox.go | 32 ++ pkg/fbs/motion/core/fbtypes/SysCmdReset.go | 22 + pkg/fbs/motion/core/fbtypes/UnitCfgKin.go | 61 +++ pkg/fbs/motion/core/fbtypes/UnitCfgObj.go | 41 ++ .../motion/core/fbtypes/UnitCfgObjSingle.go | 27 ++ pkg/fbs/motion/core/fbtypes/UnitDataAll.go | 41 ++ pkg/fbs/motion/core/fbtypes/UnitDataSingle.go | 42 ++ .../motion/core/fbtypes/actCmdJobObjects.go | 43 ++ .../core/fbtypes/allActCmdJobObjects.go | 41 ++ .../motion/core/fbtypes/allDebugCmdInfo.go | 63 +++ pkg/fbs/motion/core/fbtypes/debugCmdInfo.go | 54 +++ pkg/fbs/motion/core/fbtypes/dummyFbs.go | 48 ++ .../AxsCmdCtrlBasedHomingGantryData.go | 105 ++++ .../motion/ext/fbtypes/AxsCmdFixedstopData.go | 145 ++++++ .../motion/ext/fbtypes/AxsCmdHomingData.go | 101 ++++ .../motion/ext/fbtypes/AxsCmdSetAbsPosData.go | 101 ++++ pkg/fbs/motion/ext/fbtypes/CmdBufferType.go | 81 ++++ pkg/fbs/motion/ext/fbtypes/HomingParam.go | 184 +++++++ .../motion/ext/fbtypes/HomingSlaveParamAll.go | 111 +++++ .../ext/fbtypes/HomingSlaveParamSingle.go | 121 +++++ pkg/fbs/motion/ext/fbtypes/RefMarkerSel.go | 29 ++ pkg/fbs/motion/ext/fbtypes/RefType.go | 29 ++ .../sync/fbtypes/AxsCmdGearInPosData.go | 198 ++++++++ .../sync/fbtypes/AxsCmdSyncGenericData.go | 135 ++++++ .../sync/fbtypes/AxsStateCalcPipelines.go | 111 +++++ .../fbtypes/AxsStateCalcSinglePipeline.go | 218 +++++++++ .../sync/fbtypes/AxsStateCalcSingleStep.go | 238 ++++++++++ .../fbtypes/AxsStateCalcStepSingleParam.go | 152 ++++++ .../motion/sync/fbtypes/CalcPipelineCfg.go | 148 ++++++ pkg/fbs/motion/sync/fbtypes/CalcStepCfg.go | 193 ++++++++ .../sync/fbtypes/CalcStepCfgSingleParam.go | 135 ++++++ pkg/fbs/motion/sync/fbtypes/DataID.go | 56 +++ .../motion/sync/fbtypes/MutexGroupPart1.go | 104 ++++ .../motion/sync/fbtypes/MutexGroupPart2.go | 109 +++++ pkg/fbs/motion/sync/fbtypes/ParameterType.go | 36 ++ pkg/fbs/motion/sync/fbtypes/PipelineState.go | 40 ++ .../motion/sync/fbtypes/PipelineValidation.go | 135 ++++++ .../sync/fbtypes/StateCalcSingleStep.go | 284 +++++++++++ .../sync/fbtypes/StateCalcStepMutexParam.go | 108 +++++ .../sync/fbtypes/StateCalcStepSingleParam.go | 135 ++++++ pkg/fbs/motion/sync/fbtypes/StateCalcSteps.go | 111 +++++ pkg/fbs/motion/sync/fbtypes/SyncCmdMode.go | 40 ++ .../addbundle/fbtypes/KinCmdCircularData.go | 60 ++- .../manager/fbtypes/BrakingDistanceTypeReq.go | 32 ++ .../fbtypes/BrakingDistanceTypeResp.go | 32 ++ pkg/fbs/script/manager/fbtypes/CfgGlobal.go | 23 + .../script/manager/fbtypes/CfgInitScript.go | 47 ++ pkg/fbs/script/manager/fbtypes/CmdOpt_Base.go | 95 ++++ .../manager/fbtypes/CmdOpt_KinAxsDynLim.go | 115 +++++ .../script/manager/fbtypes/CmdOpt_KinBlend.go | 116 +++++ .../manager/fbtypes/CmdOpt_KinPolyTrans.go | 134 ++++++ .../manager/fbtypes/CmdOpt_KinSetMCS.go | 95 ++++ .../manager/fbtypes/CmdOpt_KinSetPCS.go | 95 ++++ .../manager/fbtypes/CmdOpt_KinSetSafeArea.go | 95 ++++ .../fbtypes/CmdType_CmdOptionInfoReq.go | 32 ++ .../CmdType_ListRegisteredCmdsOptions.go | 32 ++ .../script/manager/fbtypes/Cmd_AxsAbort.go | 116 +++++ .../manager/fbtypes/Cmd_AxsAddToGantry.go | 113 +++++ .../script/manager/fbtypes/Cmd_AxsAddToKin.go | 113 +++++ pkg/fbs/script/manager/fbtypes/Cmd_AxsJog.go | 133 ++++++ pkg/fbs/script/manager/fbtypes/Cmd_AxsPos.go | 136 ++++++ .../script/manager/fbtypes/Cmd_AxsPower.go | 98 ++++ .../script/manager/fbtypes/Cmd_AxsVelocity.go | 154 ++++++ pkg/fbs/script/manager/fbtypes/Cmd_Base.go | 30 ++ .../script/manager/fbtypes/Cmd_DynLimits.go | 150 ++++++ .../manager/fbtypes/Cmd_GenCmdOption.go | 160 +++++++ .../script/manager/fbtypes/Cmd_KinAbort.go | 95 ++++ .../script/manager/fbtypes/Cmd_KinContour.go | 116 +++++ pkg/fbs/script/manager/fbtypes/Cmd_KinJog.go | 181 +++++++ .../manager/fbtypes/Cmd_KinMoveDirect.go | 161 +++++++ .../manager/fbtypes/Cmd_KinMoveDirectAsync.go | 181 +++++++ .../script/manager/fbtypes/Cmd_KinMoveLin.go | 181 +++++++ pkg/fbs/script/manager/fbtypes/DL_Write.go | 39 ++ pkg/fbs/script/manager/fbtypes/DiagInfo.go | 49 ++ pkg/fbs/script/manager/fbtypes/GlobalCfg.go | 43 ++ .../script/manager/fbtypes/Misc_ActCmdData.go | 108 +++++ .../manager/fbtypes/Misc_CmdOptionInfoReq.go | 111 +++++ .../manager/fbtypes/Misc_CmdOptionInfoResp.go | 90 ++++ .../fbtypes/Misc_ListRegisteredCmdsOptions.go | 96 ++++ .../manager/fbtypes/Misc_SetErrLevel.go | 95 ++++ .../manager/fbtypes/Misc_SetOverride.go | 98 ++++ .../fbtypes/ObjectType_CmdOptionInfoReq.go | 32 ++ .../fbtypes/ObjectType_GenCmdOption.go | 32 ++ .../ObjectType_ListRegisteredCmdsOptions.go | 32 ++ pkg/fbs/script/manager/fbtypes/Resp_Error.go | 49 ++ .../manager/fbtypes/ScriptDescription.go | 55 +++ .../manager/fbtypes/State_AxsActValues.go | 150 ++++++ .../fbtypes/State_AxsBrakingDistanceExReq.go | 123 +++++ .../fbtypes/State_AxsBrakingDistanceExResp.go | 96 ++++ .../manager/fbtypes/State_AxsIpoValues.go | 132 ++++++ .../script/manager/fbtypes/State_CmdState.go | 93 ++++ .../fbtypes/State_KinCoordTransform.go | 153 ++++++ .../script/manager/fbtypes/State_KinGetPos.go | 90 ++++ .../manager/fbtypes/State_KinIpoValues.go | 162 +++++++ .../script/manager/fbtypes/Task_RunScript.go | 43 ++ .../script/manager/fbtypes/script_Instance.go | 27 ++ 479 files changed, 31801 insertions(+), 81 deletions(-) create mode 100644 pkg/fbs/comm/axisprofile/fbtypes/ScalingStrategy.go create mode 100644 pkg/fbs/comm/axisprofile/fbtypes/deviceScalingType.go create mode 100644 pkg/fbs/comm/axisprofile/fbtypes/profileDeviceScalingType.go create mode 100644 pkg/fbs/comm/axisprofile/fbtypes/profileScalingCfg.go create mode 100644 pkg/fbs/comm/axisprofile/fbtypes/profileScalingStrategy.go create mode 100644 pkg/fbs/comm/datalayer/AccessType.go create mode 100644 pkg/fbs/comm/datalayer/ArrayOfTimestamp.go create mode 100644 pkg/fbs/comm/datalayer/DiagMoreInfo.go create mode 100644 pkg/fbs/comm/datalayer/NTelBufferConfig.go create mode 100644 pkg/fbs/comm/datalayer/RealtimeConfig.go create mode 100644 pkg/fbs/comm/datalayer/Timestamp.go create mode 100644 pkg/fbs/comm/datalayer/framework/Exception.go create mode 100644 pkg/fbs/comm/datalayer/framework/Exceptions.go create mode 100644 pkg/fbs/comm/datalayer/framework/Register.go create mode 100644 pkg/fbs/comm/datalayer/framework/Stackentry.go create mode 100644 pkg/fbs/comm/datalayer/remote/RemoteConfig.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCounters.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCountersResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/CommDirection.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/DcConfigInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/Foe.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FoeRequest.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FoeResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCounters.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCountersResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FrameStatisticReset.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/FrameStatisticResetRequest.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/InhibitTime.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/InhibitTimeResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkMode.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/LinkStatus.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCounters.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCountersResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticReset.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetRequest.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MasterInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MasterInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/MinActMaxValues.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfo.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoRequest.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatistic.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticCounters.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodCounters.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodReset.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticReset.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticResetFlags.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/SyncMode.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/TopologyState.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/TopologyStatus.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/TopologyStatusResponse.go create mode 100644 pkg/fbs/comm/ethercat/master/fbs/taskInfo.go create mode 100644 pkg/fbs/comm/opcua/server/ArrayOfCertificateConfigType.go create mode 100644 pkg/fbs/comm/opcua/server/ArrayOfObjectPoolDiagType.go create mode 100644 pkg/fbs/comm/opcua/server/ArrayOfSecConfigType.go create mode 100644 pkg/fbs/comm/opcua/server/ArrayOfUserTokenType.go create mode 100644 pkg/fbs/comm/opcua/server/BuildInfoType.go create mode 100644 pkg/fbs/comm/opcua/server/CertificateConfigType.go create mode 100644 pkg/fbs/comm/opcua/server/EnumServerState.go create mode 100644 pkg/fbs/comm/opcua/server/HeapDiagType.go create mode 100644 pkg/fbs/comm/opcua/server/ObjectPoolDiagType.go create mode 100644 pkg/fbs/comm/opcua/server/SecConfigType.go create mode 100644 pkg/fbs/comm/opcua/server/ServerDiagnosticsSummaryType.go create mode 100644 pkg/fbs/comm/opcua/server/ServerStateType.go create mode 100644 pkg/fbs/comm/opcua/server/ServerStatusType.go create mode 100644 pkg/fbs/common/log/diagnosis/fbs/PendingDiagnosticState.go create mode 100644 pkg/fbs/common/log/diagnosis/fbs/State.go create mode 100644 pkg/fbs/common/scheduler/fbs/CallableConfiguration.go create mode 100644 pkg/fbs/common/scheduler/fbs/CallableConfigurations.go create mode 100644 pkg/fbs/common/scheduler/fbs/CallableWdgConfig.go create mode 100644 pkg/fbs/common/scheduler/fbs/SyncPoints.go create mode 100644 pkg/fbs/common/scheduler/fbs/TaskSpecs.go create mode 100644 pkg/fbs/common/scheduler/fbs2/Admin.go create mode 100644 pkg/fbs/common/scheduler/fbs2/CpuInfo.go create mode 100644 pkg/fbs/common/scheduler/fbs2/CurrentState.go create mode 100644 pkg/fbs/common/scheduler/fbs2/Program.go create mode 100644 pkg/fbs/common/scheduler/fbs2/Programs.go create mode 100644 pkg/fbs/common/scheduler/fbs2/State.go create mode 100644 pkg/fbs/common/testbuddy/Data.go create mode 100644 pkg/fbs/common/testbuddy/Log.go create mode 100644 pkg/fbs/common/testbuddy/LogType.go create mode 100644 pkg/fbs/common/testbuddy/TestResult.go create mode 100644 pkg/fbs/motion/collision_avoidance/fbtypes/CollisionAvoidance.go create mode 100644 pkg/fbs/motion/collision_avoidance/fbtypes/CollisionGuardState.go create mode 100644 pkg/fbs/motion/collision_avoidance/fbtypes/GetCollisionGuardStateParams.go create mode 100644 pkg/fbs/motion/core/fbtypes/AxsBrakingDistanceEx.go create mode 100644 pkg/fbs/motion/core/fbtypes/AxsCmdVelData.go create mode 100644 pkg/fbs/motion/core/fbtypes/BrakeLimit.go create mode 100644 pkg/fbs/motion/core/fbtypes/BrakingDistanceType.go create mode 100644 pkg/fbs/motion/core/fbtypes/Capability.go create mode 100644 pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataAllParam.go create mode 100644 pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataParam.go create mode 100644 pkg/fbs/motion/core/fbtypes/KinCmdAbortData.go create mode 100644 pkg/fbs/motion/core/fbtypes/KinCmdContourData.go create mode 100644 pkg/fbs/motion/core/fbtypes/RTInputsCfg.go create mode 100644 pkg/fbs/motion/ext/fbtypes/AxsCmdCtrlBasedHomingGantryData.go create mode 100644 pkg/fbs/motion/ext/fbtypes/AxsCmdFixedstopData.go create mode 100644 pkg/fbs/motion/ext/fbtypes/AxsCmdHomingData.go create mode 100644 pkg/fbs/motion/ext/fbtypes/AxsCmdSetAbsPosData.go create mode 100644 pkg/fbs/motion/ext/fbtypes/CmdBufferType.go create mode 100644 pkg/fbs/motion/ext/fbtypes/HomingParam.go create mode 100644 pkg/fbs/motion/ext/fbtypes/HomingSlaveParamAll.go create mode 100644 pkg/fbs/motion/ext/fbtypes/HomingSlaveParamSingle.go create mode 100644 pkg/fbs/motion/ext/fbtypes/RefMarkerSel.go create mode 100644 pkg/fbs/motion/ext/fbtypes/RefType.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsCmdGearInPosData.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsCmdSyncGenericData.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsStateCalcPipelines.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsStateCalcSinglePipeline.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsStateCalcSingleStep.go create mode 100644 pkg/fbs/motion/sync/fbtypes/AxsStateCalcStepSingleParam.go create mode 100644 pkg/fbs/motion/sync/fbtypes/CalcPipelineCfg.go create mode 100644 pkg/fbs/motion/sync/fbtypes/CalcStepCfg.go create mode 100644 pkg/fbs/motion/sync/fbtypes/CalcStepCfgSingleParam.go create mode 100644 pkg/fbs/motion/sync/fbtypes/DataID.go create mode 100644 pkg/fbs/motion/sync/fbtypes/MutexGroupPart1.go create mode 100644 pkg/fbs/motion/sync/fbtypes/MutexGroupPart2.go create mode 100644 pkg/fbs/motion/sync/fbtypes/ParameterType.go create mode 100644 pkg/fbs/motion/sync/fbtypes/PipelineState.go create mode 100644 pkg/fbs/motion/sync/fbtypes/PipelineValidation.go create mode 100644 pkg/fbs/motion/sync/fbtypes/StateCalcSingleStep.go create mode 100644 pkg/fbs/motion/sync/fbtypes/StateCalcStepMutexParam.go create mode 100644 pkg/fbs/motion/sync/fbtypes/StateCalcStepSingleParam.go create mode 100644 pkg/fbs/motion/sync/fbtypes/StateCalcSteps.go create mode 100644 pkg/fbs/motion/sync/fbtypes/SyncCmdMode.go create mode 100644 pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeReq.go create mode 100644 pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeResp.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_Base.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinAxsDynLim.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinBlend.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinPolyTrans.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetMCS.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetPCS.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetSafeArea.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go create mode 100644 pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsAbort.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToGantry.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToKin.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsJog.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsPos.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsPower.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_AxsVelocity.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_DynLimits.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_GenCmdOption.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinAbort.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinContour.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinJog.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirect.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirectAsync.go create mode 100644 pkg/fbs/script/manager/fbtypes/Cmd_KinMoveLin.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_ActCmdData.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoReq.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoResp.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_ListRegisteredCmdsOptions.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_SetErrLevel.go create mode 100644 pkg/fbs/script/manager/fbtypes/Misc_SetOverride.go create mode 100644 pkg/fbs/script/manager/fbtypes/ObjectType_CmdOptionInfoReq.go create mode 100644 pkg/fbs/script/manager/fbtypes/ObjectType_GenCmdOption.go create mode 100644 pkg/fbs/script/manager/fbtypes/ObjectType_ListRegisteredCmdsOptions.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_AxsActValues.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExReq.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExResp.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_AxsIpoValues.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_CmdState.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_KinCoordTransform.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_KinGetPos.go create mode 100644 pkg/fbs/script/manager/fbtypes/State_KinIpoValues.go diff --git a/pkg/fbs/comm/axisprofile/fbtypes/APRBootState.go b/pkg/fbs/comm/axisprofile/fbtypes/APRBootState.go index 9f9fef4..97b69ed 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/APRBootState.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/APRBootState.go @@ -7,6 +7,35 @@ import ( ) /// return type of requests of the current boot state +type APRBootStateT struct { + Text string + ActStep uint32 + MaxSteps uint32 +} + +func (t *APRBootStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + textOffset := builder.CreateString(t.Text) + APRBootStateStart(builder) + APRBootStateAddText(builder, textOffset) + APRBootStateAddActStep(builder, t.ActStep) + APRBootStateAddMaxSteps(builder, t.MaxSteps) + return APRBootStateEnd(builder) +} + +func (rcv *APRBootState) UnPackTo(t *APRBootStateT) { + t.Text = string(rcv.Text()) + t.ActStep = rcv.ActStep() + t.MaxSteps = rcv.MaxSteps() +} + +func (rcv *APRBootState) UnPack() *APRBootStateT { + if rcv == nil { return nil } + t := &APRBootStateT{} + rcv.UnPackTo(t) + return t +} + type APRBootState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/ScalingStrategy.go b/pkg/fbs/comm/axisprofile/fbtypes/ScalingStrategy.go new file mode 100644 index 0000000..aaee32e --- /dev/null +++ b/pkg/fbs/comm/axisprofile/fbtypes/ScalingStrategy.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type ScalingStrategy uint32 + +const ( + ScalingStrategyUNKNOWN ScalingStrategy = 0 + ScalingStrategySOE_STANDARD ScalingStrategy = 1 + ScalingStrategyCOE_CALC_DRIVE ScalingStrategy = 2 + ScalingStrategyCOE_CALC_CONTROL ScalingStrategy = 3 +) + +var EnumNamesScalingStrategy = map[ScalingStrategy]string{ + ScalingStrategyUNKNOWN: "UNKNOWN", + ScalingStrategySOE_STANDARD: "SOE_STANDARD", + ScalingStrategyCOE_CALC_DRIVE: "COE_CALC_DRIVE", + ScalingStrategyCOE_CALC_CONTROL: "COE_CALC_CONTROL", +} + +var EnumValuesScalingStrategy = map[string]ScalingStrategy{ + "UNKNOWN": ScalingStrategyUNKNOWN, + "SOE_STANDARD": ScalingStrategySOE_STANDARD, + "COE_CALC_DRIVE": ScalingStrategyCOE_CALC_DRIVE, + "COE_CALC_CONTROL": ScalingStrategyCOE_CALC_CONTROL, +} + +func (v ScalingStrategy) String() string { + if s, ok := EnumNamesScalingStrategy[v]; ok { + return s + } + return "ScalingStrategy(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/deviceScalingType.go b/pkg/fbs/comm/axisprofile/fbtypes/deviceScalingType.go new file mode 100644 index 0000000..76d123c --- /dev/null +++ b/pkg/fbs/comm/axisprofile/fbtypes/deviceScalingType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type deviceScalingType int32 + +const ( + deviceScalingTypeUNDEFINED deviceScalingType = -1 + deviceScalingTypeROTARY deviceScalingType = 0 + deviceScalingTypePERCENTAGE deviceScalingType = 1 + deviceScalingTypeLINEAR deviceScalingType = 2 +) + +var EnumNamesdeviceScalingType = map[deviceScalingType]string{ + deviceScalingTypeUNDEFINED: "UNDEFINED", + deviceScalingTypeROTARY: "ROTARY", + deviceScalingTypePERCENTAGE: "PERCENTAGE", + deviceScalingTypeLINEAR: "LINEAR", +} + +var EnumValuesdeviceScalingType = map[string]deviceScalingType{ + "UNDEFINED": deviceScalingTypeUNDEFINED, + "ROTARY": deviceScalingTypeROTARY, + "PERCENTAGE": deviceScalingTypePERCENTAGE, + "LINEAR": deviceScalingTypeLINEAR, +} + +func (v deviceScalingType) String() string { + if s, ok := EnumNamesdeviceScalingType[v]; ok { + return s + } + return "deviceScalingType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/dummyFbs.go b/pkg/fbs/comm/axisprofile/fbtypes/dummyFbs.go index 2a4a633..64f7550 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/dummyFbs.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/dummyFbs.go @@ -6,6 +6,54 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type dummyFbsT struct { + DummyByte int8 + DummyStr string + DummyInt int32 + DummyDouble float64 + DummyDoublePtr []float64 +} + +func (t *dummyFbsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dummyStrOffset := builder.CreateString(t.DummyStr) + dummyDoublePtrOffset := flatbuffers.UOffsetT(0) + if t.DummyDoublePtr != nil { + dummyDoublePtrLength := len(t.DummyDoublePtr) + dummyFbsStartDummyDoublePtrVector(builder, dummyDoublePtrLength) + for j := dummyDoublePtrLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.DummyDoublePtr[j]) + } + dummyDoublePtrOffset = builder.EndVector(dummyDoublePtrLength) + } + dummyFbsStart(builder) + dummyFbsAddDummyByte(builder, t.DummyByte) + dummyFbsAddDummyStr(builder, dummyStrOffset) + dummyFbsAddDummyInt(builder, t.DummyInt) + dummyFbsAddDummyDouble(builder, t.DummyDouble) + dummyFbsAddDummyDoublePtr(builder, dummyDoublePtrOffset) + return dummyFbsEnd(builder) +} + +func (rcv *dummyFbs) UnPackTo(t *dummyFbsT) { + t.DummyByte = rcv.DummyByte() + t.DummyStr = string(rcv.DummyStr()) + t.DummyInt = rcv.DummyInt() + t.DummyDouble = rcv.DummyDouble() + dummyDoublePtrLength := rcv.DummyDoublePtrLength() + t.DummyDoublePtr = make([]float64, dummyDoublePtrLength) + for j := 0; j < dummyDoublePtrLength; j++ { + t.DummyDoublePtr[j] = rcv.DummyDoublePtr(j) + } +} + +func (rcv *dummyFbs) UnPack() *dummyFbsT { + if rcv == nil { return nil } + t := &dummyFbsT{} + rcv.UnPackTo(t) + return t +} + type dummyFbs struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/mappingEntry.go b/pkg/fbs/comm/axisprofile/fbtypes/mappingEntry.go index da2916b..e5fe368 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/mappingEntry.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/mappingEntry.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type mappingEntryT struct { + ValueID string + DatalayerURI string +} + +func (t *mappingEntryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueIDOffset := builder.CreateString(t.ValueID) + datalayerURIOffset := builder.CreateString(t.DatalayerURI) + mappingEntryStart(builder) + mappingEntryAddValueID(builder, valueIDOffset) + mappingEntryAddDatalayerURI(builder, datalayerURIOffset) + return mappingEntryEnd(builder) +} + +func (rcv *mappingEntry) UnPackTo(t *mappingEntryT) { + t.ValueID = string(rcv.ValueID()) + t.DatalayerURI = string(rcv.DatalayerURI()) +} + +func (rcv *mappingEntry) UnPack() *mappingEntryT { + if rcv == nil { return nil } + t := &mappingEntryT{} + rcv.UnPackTo(t) + return t +} + type mappingEntry struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profile.go b/pkg/fbs/comm/axisprofile/fbtypes/profile.go index 3dfbc5d..712cc16 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/profile.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/profile.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type profileT struct { + Name string + Type ProfileType +} + +func (t *profileT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + profileStart(builder) + profileAddName(builder, nameOffset) + profileAddType(builder, t.Type) + return profileEnd(builder) +} + +func (rcv *profile) UnPackTo(t *profileT) { + t.Name = string(rcv.Name()) + t.Type = rcv.Type() +} + +func (rcv *profile) UnPack() *profileT { + if rcv == nil { return nil } + t := &profileT{} + rcv.UnPackTo(t) + return t +} + type profile struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileConfig.go b/pkg/fbs/comm/axisprofile/fbtypes/profileConfig.go index a581aa6..a26b40a 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/profileConfig.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileConfig.go @@ -6,6 +6,52 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type profileConfigT struct { + DeviceAddress uint32 + InputBuffer string + OutputBuffer string + ProfileBasicData *profileT + InputMapping *valueMappingT + OutputMapping *valueMappingT + ScalingInfo *profileScalingCfgT +} + +func (t *profileConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + inputBufferOffset := builder.CreateString(t.InputBuffer) + outputBufferOffset := builder.CreateString(t.OutputBuffer) + profileBasicDataOffset := t.ProfileBasicData.Pack(builder) + inputMappingOffset := t.InputMapping.Pack(builder) + outputMappingOffset := t.OutputMapping.Pack(builder) + scalingInfoOffset := t.ScalingInfo.Pack(builder) + profileConfigStart(builder) + profileConfigAddDeviceAddress(builder, t.DeviceAddress) + profileConfigAddInputBuffer(builder, inputBufferOffset) + profileConfigAddOutputBuffer(builder, outputBufferOffset) + profileConfigAddProfileBasicData(builder, profileBasicDataOffset) + profileConfigAddInputMapping(builder, inputMappingOffset) + profileConfigAddOutputMapping(builder, outputMappingOffset) + profileConfigAddScalingInfo(builder, scalingInfoOffset) + return profileConfigEnd(builder) +} + +func (rcv *profileConfig) UnPackTo(t *profileConfigT) { + t.DeviceAddress = rcv.DeviceAddress() + t.InputBuffer = string(rcv.InputBuffer()) + t.OutputBuffer = string(rcv.OutputBuffer()) + t.ProfileBasicData = rcv.ProfileBasicData(nil).UnPack() + t.InputMapping = rcv.InputMapping(nil).UnPack() + t.OutputMapping = rcv.OutputMapping(nil).UnPack() + t.ScalingInfo = rcv.ScalingInfo(nil).UnPack() +} + +func (rcv *profileConfig) UnPack() *profileConfigT { + if rcv == nil { return nil } + t := &profileConfigT{} + rcv.UnPackTo(t) + return t +} + type profileConfig struct { _tab flatbuffers.Table } @@ -100,8 +146,21 @@ func (rcv *profileConfig) OutputMapping(obj *valueMapping) *valueMapping { return nil } +func (rcv *profileConfig) ScalingInfo(obj *profileScalingCfg) *profileScalingCfg { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(profileScalingCfg) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + func profileConfigStart(builder *flatbuffers.Builder) { - builder.StartObject(6) + builder.StartObject(7) } func profileConfigAddDeviceAddress(builder *flatbuffers.Builder, deviceAddress uint32) { builder.PrependUint32Slot(0, deviceAddress, 0) @@ -121,6 +180,9 @@ func profileConfigAddInputMapping(builder *flatbuffers.Builder, inputMapping fla func profileConfigAddOutputMapping(builder *flatbuffers.Builder, outputMapping flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(outputMapping), 0) } +func profileConfigAddScalingInfo(builder *flatbuffers.Builder, scalingInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(scalingInfo), 0) +} func profileConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileConfigInfo.go b/pkg/fbs/comm/axisprofile/fbtypes/profileConfigInfo.go index 669bf99..bac0eea 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/profileConfigInfo.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileConfigInfo.go @@ -6,6 +6,56 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type profileConfigInfoT struct { + DeviceAddress uint32 + InputBuffer string + OutputBuffer string + ProfileType *profileTypeDataT + ProfileName string + InputMapping *valueMappingT + OutputMapping *valueMappingT + ScalingInfo *profileScalingCfgT +} + +func (t *profileConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + inputBufferOffset := builder.CreateString(t.InputBuffer) + outputBufferOffset := builder.CreateString(t.OutputBuffer) + profileTypeOffset := t.ProfileType.Pack(builder) + profileNameOffset := builder.CreateString(t.ProfileName) + inputMappingOffset := t.InputMapping.Pack(builder) + outputMappingOffset := t.OutputMapping.Pack(builder) + scalingInfoOffset := t.ScalingInfo.Pack(builder) + profileConfigInfoStart(builder) + profileConfigInfoAddDeviceAddress(builder, t.DeviceAddress) + profileConfigInfoAddInputBuffer(builder, inputBufferOffset) + profileConfigInfoAddOutputBuffer(builder, outputBufferOffset) + profileConfigInfoAddProfileType(builder, profileTypeOffset) + profileConfigInfoAddProfileName(builder, profileNameOffset) + profileConfigInfoAddInputMapping(builder, inputMappingOffset) + profileConfigInfoAddOutputMapping(builder, outputMappingOffset) + profileConfigInfoAddScalingInfo(builder, scalingInfoOffset) + return profileConfigInfoEnd(builder) +} + +func (rcv *profileConfigInfo) UnPackTo(t *profileConfigInfoT) { + t.DeviceAddress = rcv.DeviceAddress() + t.InputBuffer = string(rcv.InputBuffer()) + t.OutputBuffer = string(rcv.OutputBuffer()) + t.ProfileType = rcv.ProfileType(nil).UnPack() + t.ProfileName = string(rcv.ProfileName()) + t.InputMapping = rcv.InputMapping(nil).UnPack() + t.OutputMapping = rcv.OutputMapping(nil).UnPack() + t.ScalingInfo = rcv.ScalingInfo(nil).UnPack() +} + +func (rcv *profileConfigInfo) UnPack() *profileConfigInfoT { + if rcv == nil { return nil } + t := &profileConfigInfoT{} + rcv.UnPackTo(t) + return t +} + type profileConfigInfo struct { _tab flatbuffers.Table } @@ -108,8 +158,21 @@ func (rcv *profileConfigInfo) OutputMapping(obj *valueMapping) *valueMapping { return nil } +func (rcv *profileConfigInfo) ScalingInfo(obj *profileScalingCfg) *profileScalingCfg { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(profileScalingCfg) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + func profileConfigInfoStart(builder *flatbuffers.Builder) { - builder.StartObject(7) + builder.StartObject(8) } func profileConfigInfoAddDeviceAddress(builder *flatbuffers.Builder, deviceAddress uint32) { builder.PrependUint32Slot(0, deviceAddress, 0) @@ -132,6 +195,9 @@ func profileConfigInfoAddInputMapping(builder *flatbuffers.Builder, inputMapping func profileConfigInfoAddOutputMapping(builder *flatbuffers.Builder, outputMapping flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(outputMapping), 0) } +func profileConfigInfoAddScalingInfo(builder *flatbuffers.Builder, scalingInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(scalingInfo), 0) +} func profileConfigInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileDeviceScalingType.go b/pkg/fbs/comm/axisprofile/fbtypes/profileDeviceScalingType.go new file mode 100644 index 0000000..f5cec45 --- /dev/null +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileDeviceScalingType.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type profileDeviceScalingTypeT struct { + ScalingType deviceScalingType +} + +func (t *profileDeviceScalingTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + profileDeviceScalingTypeStart(builder) + profileDeviceScalingTypeAddScalingType(builder, t.ScalingType) + return profileDeviceScalingTypeEnd(builder) +} + +func (rcv *profileDeviceScalingType) UnPackTo(t *profileDeviceScalingTypeT) { + t.ScalingType = rcv.ScalingType() +} + +func (rcv *profileDeviceScalingType) UnPack() *profileDeviceScalingTypeT { + if rcv == nil { return nil } + t := &profileDeviceScalingTypeT{} + rcv.UnPackTo(t) + return t +} + +type profileDeviceScalingType struct { + _tab flatbuffers.Table +} + +func GetRootAsprofileDeviceScalingType(buf []byte, offset flatbuffers.UOffsetT) *profileDeviceScalingType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &profileDeviceScalingType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsprofileDeviceScalingType(buf []byte, offset flatbuffers.UOffsetT) *profileDeviceScalingType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &profileDeviceScalingType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *profileDeviceScalingType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *profileDeviceScalingType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *profileDeviceScalingType) ScalingType() deviceScalingType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return deviceScalingType(rcv._tab.GetInt32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *profileDeviceScalingType) MutateScalingType(n deviceScalingType) bool { + return rcv._tab.MutateInt32Slot(4, int32(n)) +} + +func profileDeviceScalingTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func profileDeviceScalingTypeAddScalingType(builder *flatbuffers.Builder, scalingType deviceScalingType) { + builder.PrependInt32Slot(0, int32(scalingType), 0) +} +func profileDeviceScalingTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileScalingCfg.go b/pkg/fbs/comm/axisprofile/fbtypes/profileScalingCfg.go new file mode 100644 index 0000000..a6a406d --- /dev/null +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileScalingCfg.go @@ -0,0 +1,154 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type profileScalingCfgT struct { + ScalingStrategy *profileScalingStrategyT + ScalingType *profileDeviceScalingTypeT + Numerator uint32 + Denominator uint32 + Resolution uint32 +} + +func (t *profileScalingCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + scalingStrategyOffset := t.ScalingStrategy.Pack(builder) + scalingTypeOffset := t.ScalingType.Pack(builder) + profileScalingCfgStart(builder) + profileScalingCfgAddScalingStrategy(builder, scalingStrategyOffset) + profileScalingCfgAddScalingType(builder, scalingTypeOffset) + profileScalingCfgAddNumerator(builder, t.Numerator) + profileScalingCfgAddDenominator(builder, t.Denominator) + profileScalingCfgAddResolution(builder, t.Resolution) + return profileScalingCfgEnd(builder) +} + +func (rcv *profileScalingCfg) UnPackTo(t *profileScalingCfgT) { + t.ScalingStrategy = rcv.ScalingStrategy(nil).UnPack() + t.ScalingType = rcv.ScalingType(nil).UnPack() + t.Numerator = rcv.Numerator() + t.Denominator = rcv.Denominator() + t.Resolution = rcv.Resolution() +} + +func (rcv *profileScalingCfg) UnPack() *profileScalingCfgT { + if rcv == nil { return nil } + t := &profileScalingCfgT{} + rcv.UnPackTo(t) + return t +} + +type profileScalingCfg struct { + _tab flatbuffers.Table +} + +func GetRootAsprofileScalingCfg(buf []byte, offset flatbuffers.UOffsetT) *profileScalingCfg { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &profileScalingCfg{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsprofileScalingCfg(buf []byte, offset flatbuffers.UOffsetT) *profileScalingCfg { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &profileScalingCfg{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *profileScalingCfg) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *profileScalingCfg) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *profileScalingCfg) ScalingStrategy(obj *profileScalingStrategy) *profileScalingStrategy { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(profileScalingStrategy) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *profileScalingCfg) ScalingType(obj *profileDeviceScalingType) *profileDeviceScalingType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(profileDeviceScalingType) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *profileScalingCfg) Numerator() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *profileScalingCfg) MutateNumerator(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *profileScalingCfg) Denominator() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *profileScalingCfg) MutateDenominator(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func (rcv *profileScalingCfg) Resolution() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *profileScalingCfg) MutateResolution(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func profileScalingCfgStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func profileScalingCfgAddScalingStrategy(builder *flatbuffers.Builder, scalingStrategy flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(scalingStrategy), 0) +} +func profileScalingCfgAddScalingType(builder *flatbuffers.Builder, scalingType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(scalingType), 0) +} +func profileScalingCfgAddNumerator(builder *flatbuffers.Builder, numerator uint32) { + builder.PrependUint32Slot(2, numerator, 0) +} +func profileScalingCfgAddDenominator(builder *flatbuffers.Builder, denominator uint32) { + builder.PrependUint32Slot(3, denominator, 0) +} +func profileScalingCfgAddResolution(builder *flatbuffers.Builder, resolution uint32) { + builder.PrependUint32Slot(4, resolution, 0) +} +func profileScalingCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileScalingStrategy.go b/pkg/fbs/comm/axisprofile/fbtypes/profileScalingStrategy.go new file mode 100644 index 0000000..cfe3d95 --- /dev/null +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileScalingStrategy.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type profileScalingStrategyT struct { + Strategy ScalingStrategy +} + +func (t *profileScalingStrategyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + profileScalingStrategyStart(builder) + profileScalingStrategyAddStrategy(builder, t.Strategy) + return profileScalingStrategyEnd(builder) +} + +func (rcv *profileScalingStrategy) UnPackTo(t *profileScalingStrategyT) { + t.Strategy = rcv.Strategy() +} + +func (rcv *profileScalingStrategy) UnPack() *profileScalingStrategyT { + if rcv == nil { return nil } + t := &profileScalingStrategyT{} + rcv.UnPackTo(t) + return t +} + +type profileScalingStrategy struct { + _tab flatbuffers.Table +} + +func GetRootAsprofileScalingStrategy(buf []byte, offset flatbuffers.UOffsetT) *profileScalingStrategy { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &profileScalingStrategy{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsprofileScalingStrategy(buf []byte, offset flatbuffers.UOffsetT) *profileScalingStrategy { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &profileScalingStrategy{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *profileScalingStrategy) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *profileScalingStrategy) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *profileScalingStrategy) Strategy() ScalingStrategy { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return ScalingStrategy(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *profileScalingStrategy) MutateStrategy(n ScalingStrategy) bool { + return rcv._tab.MutateUint32Slot(4, uint32(n)) +} + +func profileScalingStrategyStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func profileScalingStrategyAddStrategy(builder *flatbuffers.Builder, strategy ScalingStrategy) { + builder.PrependUint32Slot(0, uint32(strategy), 0) +} +func profileScalingStrategyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/profileTypeData.go b/pkg/fbs/comm/axisprofile/fbtypes/profileTypeData.go index cf83590..09dbcf7 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/profileTypeData.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/profileTypeData.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type profileTypeDataT struct { + Type ProfileType +} + +func (t *profileTypeDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + profileTypeDataStart(builder) + profileTypeDataAddType(builder, t.Type) + return profileTypeDataEnd(builder) +} + +func (rcv *profileTypeData) UnPackTo(t *profileTypeDataT) { + t.Type = rcv.Type() +} + +func (rcv *profileTypeData) UnPack() *profileTypeDataT { + if rcv == nil { return nil } + t := &profileTypeDataT{} + rcv.UnPackTo(t) + return t +} + type profileTypeData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/axisprofile/fbtypes/valueMapping.go b/pkg/fbs/comm/axisprofile/fbtypes/valueMapping.go index f58fd85..d6b0faa 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/valueMapping.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/valueMapping.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type valueMappingT struct { + Mapping []*mappingEntryT +} + +func (t *valueMappingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mappingOffset := flatbuffers.UOffsetT(0) + if t.Mapping != nil { + mappingLength := len(t.Mapping) + mappingOffsets := make([]flatbuffers.UOffsetT, mappingLength) + for j := 0; j < mappingLength; j++ { + mappingOffsets[j] = t.Mapping[j].Pack(builder) + } + valueMappingStartMappingVector(builder, mappingLength) + for j := mappingLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(mappingOffsets[j]) + } + mappingOffset = builder.EndVector(mappingLength) + } + valueMappingStart(builder) + valueMappingAddMapping(builder, mappingOffset) + return valueMappingEnd(builder) +} + +func (rcv *valueMapping) UnPackTo(t *valueMappingT) { + mappingLength := rcv.MappingLength() + t.Mapping = make([]*mappingEntryT, mappingLength) + for j := 0; j < mappingLength; j++ { + x := mappingEntry{} + rcv.Mapping(&x, j) + t.Mapping[j] = x.UnPack() + } +} + +func (rcv *valueMapping) UnPack() *valueMappingT { + if rcv == nil { return nil } + t := &valueMappingT{} + rcv.UnPackTo(t) + return t +} + type valueMapping struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/AccessType.go b/pkg/fbs/comm/datalayer/AccessType.go new file mode 100644 index 0000000..edbd098 --- /dev/null +++ b/pkg/fbs/comm/datalayer/AccessType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import "strconv" + +type AccessType int8 + +const ( + AccessTypeUnknown AccessType = 0 + AccessTypeRaw AccessType = 1 + AccessTypeTripleBuffer AccessType = 2 + AccessTypeNTelBuf AccessType = 3 +) + +var EnumNamesAccessType = map[AccessType]string{ + AccessTypeUnknown: "Unknown", + AccessTypeRaw: "Raw", + AccessTypeTripleBuffer: "TripleBuffer", + AccessTypeNTelBuf: "NTelBuf", +} + +var EnumValuesAccessType = map[string]AccessType{ + "Unknown": AccessTypeUnknown, + "Raw": AccessTypeRaw, + "TripleBuffer": AccessTypeTripleBuffer, + "NTelBuf": AccessTypeNTelBuf, +} + +func (v AccessType) String() string { + if s, ok := EnumNamesAccessType[v]; ok { + return s + } + return "AccessType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/datalayer/AllowedOperations.go b/pkg/fbs/comm/datalayer/AllowedOperations.go index ca6d172..cf2b181 100644 --- a/pkg/fbs/comm/datalayer/AllowedOperations.go +++ b/pkg/fbs/comm/datalayer/AllowedOperations.go @@ -6,6 +6,40 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AllowedOperationsT struct { + Read bool + Write bool + Create bool + Delete bool + Browse bool +} + +func (t *AllowedOperationsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AllowedOperationsStart(builder) + AllowedOperationsAddRead(builder, t.Read) + AllowedOperationsAddWrite(builder, t.Write) + AllowedOperationsAddCreate(builder, t.Create) + AllowedOperationsAddDelete(builder, t.Delete) + AllowedOperationsAddBrowse(builder, t.Browse) + return AllowedOperationsEnd(builder) +} + +func (rcv *AllowedOperations) UnPackTo(t *AllowedOperationsT) { + t.Read = rcv.Read() + t.Write = rcv.Write() + t.Create = rcv.Create() + t.Delete = rcv.Delete() + t.Browse = rcv.Browse() +} + +func (rcv *AllowedOperations) UnPack() *AllowedOperationsT { + if rcv == nil { return nil } + t := &AllowedOperationsT{} + rcv.UnPackTo(t) + return t +} + type AllowedOperations struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfBool8.go b/pkg/fbs/comm/datalayer/ArrayOfBool8.go index e0cf981..22f3cc2 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfBool8.go +++ b/pkg/fbs/comm/datalayer/ArrayOfBool8.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfBool8T struct { + Value []bool +} + +func (t *ArrayOfBool8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfBool8StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependBool(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfBool8Start(builder) + ArrayOfBool8AddValue(builder, valueOffset) + return ArrayOfBool8End(builder) +} + +func (rcv *ArrayOfBool8) UnPackTo(t *ArrayOfBool8T) { + valueLength := rcv.ValueLength() + t.Value = make([]bool, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfBool8) UnPack() *ArrayOfBool8T { + if rcv == nil { return nil } + t := &ArrayOfBool8T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfBool8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfFloat32.go b/pkg/fbs/comm/datalayer/ArrayOfFloat32.go index f89d467..dc450ad 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfFloat32.go +++ b/pkg/fbs/comm/datalayer/ArrayOfFloat32.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfFloat32T struct { + Value []float32 +} + +func (t *ArrayOfFloat32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfFloat32StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependFloat32(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfFloat32Start(builder) + ArrayOfFloat32AddValue(builder, valueOffset) + return ArrayOfFloat32End(builder) +} + +func (rcv *ArrayOfFloat32) UnPackTo(t *ArrayOfFloat32T) { + valueLength := rcv.ValueLength() + t.Value = make([]float32, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfFloat32) UnPack() *ArrayOfFloat32T { + if rcv == nil { return nil } + t := &ArrayOfFloat32T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfFloat32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfFloat64.go b/pkg/fbs/comm/datalayer/ArrayOfFloat64.go index aa7126e..4a9d3a2 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfFloat64.go +++ b/pkg/fbs/comm/datalayer/ArrayOfFloat64.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfFloat64T struct { + Value []float64 +} + +func (t *ArrayOfFloat64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfFloat64StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfFloat64Start(builder) + ArrayOfFloat64AddValue(builder, valueOffset) + return ArrayOfFloat64End(builder) +} + +func (rcv *ArrayOfFloat64) UnPackTo(t *ArrayOfFloat64T) { + valueLength := rcv.ValueLength() + t.Value = make([]float64, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfFloat64) UnPack() *ArrayOfFloat64T { + if rcv == nil { return nil } + t := &ArrayOfFloat64T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfFloat64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfInt16.go b/pkg/fbs/comm/datalayer/ArrayOfInt16.go index 500f822..862bfdd 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfInt16.go +++ b/pkg/fbs/comm/datalayer/ArrayOfInt16.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfInt16T struct { + Value []int16 +} + +func (t *ArrayOfInt16T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfInt16StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependInt16(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfInt16Start(builder) + ArrayOfInt16AddValue(builder, valueOffset) + return ArrayOfInt16End(builder) +} + +func (rcv *ArrayOfInt16) UnPackTo(t *ArrayOfInt16T) { + valueLength := rcv.ValueLength() + t.Value = make([]int16, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfInt16) UnPack() *ArrayOfInt16T { + if rcv == nil { return nil } + t := &ArrayOfInt16T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfInt16 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfInt32.go b/pkg/fbs/comm/datalayer/ArrayOfInt32.go index 1676502..c5356ea 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfInt32.go +++ b/pkg/fbs/comm/datalayer/ArrayOfInt32.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfInt32T struct { + Value []int32 +} + +func (t *ArrayOfInt32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfInt32StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependInt32(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfInt32Start(builder) + ArrayOfInt32AddValue(builder, valueOffset) + return ArrayOfInt32End(builder) +} + +func (rcv *ArrayOfInt32) UnPackTo(t *ArrayOfInt32T) { + valueLength := rcv.ValueLength() + t.Value = make([]int32, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfInt32) UnPack() *ArrayOfInt32T { + if rcv == nil { return nil } + t := &ArrayOfInt32T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfInt32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfInt64.go b/pkg/fbs/comm/datalayer/ArrayOfInt64.go index be89459..cbb5d63 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfInt64.go +++ b/pkg/fbs/comm/datalayer/ArrayOfInt64.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfInt64T struct { + Value []int64 +} + +func (t *ArrayOfInt64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfInt64StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependInt64(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfInt64Start(builder) + ArrayOfInt64AddValue(builder, valueOffset) + return ArrayOfInt64End(builder) +} + +func (rcv *ArrayOfInt64) UnPackTo(t *ArrayOfInt64T) { + valueLength := rcv.ValueLength() + t.Value = make([]int64, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfInt64) UnPack() *ArrayOfInt64T { + if rcv == nil { return nil } + t := &ArrayOfInt64T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfInt64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfInt8.go b/pkg/fbs/comm/datalayer/ArrayOfInt8.go index 463a4de..8811d07 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfInt8.go +++ b/pkg/fbs/comm/datalayer/ArrayOfInt8.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfInt8T struct { + Value []int8 +} + +func (t *ArrayOfInt8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfInt8StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependInt8(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfInt8Start(builder) + ArrayOfInt8AddValue(builder, valueOffset) + return ArrayOfInt8End(builder) +} + +func (rcv *ArrayOfInt8) UnPackTo(t *ArrayOfInt8T) { + valueLength := rcv.ValueLength() + t.Value = make([]int8, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfInt8) UnPack() *ArrayOfInt8T { + if rcv == nil { return nil } + t := &ArrayOfInt8T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfInt8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfString.go b/pkg/fbs/comm/datalayer/ArrayOfString.go index b0a0275..36fd68f 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfString.go +++ b/pkg/fbs/comm/datalayer/ArrayOfString.go @@ -6,6 +6,45 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfStringT struct { + Value []string +} + +func (t *ArrayOfStringT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + valueOffsets := make([]flatbuffers.UOffsetT, valueLength) + for j := 0; j < valueLength; j++ { + valueOffsets[j] = builder.CreateString(t.Value[j]) + } + ArrayOfStringStartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(valueOffsets[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfStringStart(builder) + ArrayOfStringAddValue(builder, valueOffset) + return ArrayOfStringEnd(builder) +} + +func (rcv *ArrayOfString) UnPackTo(t *ArrayOfStringT) { + valueLength := rcv.ValueLength() + t.Value = make([]string, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = string(rcv.Value(j)) + } +} + +func (rcv *ArrayOfString) UnPack() *ArrayOfStringT { + if rcv == nil { return nil } + t := &ArrayOfStringT{} + rcv.UnPackTo(t) + return t +} + type ArrayOfString struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfTimestamp.go b/pkg/fbs/comm/datalayer/ArrayOfTimestamp.go new file mode 100644 index 0000000..46c828b --- /dev/null +++ b/pkg/fbs/comm/datalayer/ArrayOfTimestamp.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfTimestampT struct { + Value []uint64 +} + +func (t *ArrayOfTimestampT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfTimestampStartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependUint64(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfTimestampStart(builder) + ArrayOfTimestampAddValue(builder, valueOffset) + return ArrayOfTimestampEnd(builder) +} + +func (rcv *ArrayOfTimestamp) UnPackTo(t *ArrayOfTimestampT) { + valueLength := rcv.ValueLength() + t.Value = make([]uint64, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfTimestamp) UnPack() *ArrayOfTimestampT { + if rcv == nil { return nil } + t := &ArrayOfTimestampT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfTimestamp struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfTimestamp(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfTimestamp { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfTimestamp{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfTimestamp(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfTimestamp { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfTimestamp{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfTimestamp) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfTimestamp) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfTimestamp) Value(j int) uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *ArrayOfTimestamp) ValueLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *ArrayOfTimestamp) MutateValue(j int, n uint64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func ArrayOfTimestampStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfTimestampAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(value), 0) +} +func ArrayOfTimestampStartValueVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func ArrayOfTimestampEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/ArrayOfUInt16.go b/pkg/fbs/comm/datalayer/ArrayOfUInt16.go index b524dd7..7953f11 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfUInt16.go +++ b/pkg/fbs/comm/datalayer/ArrayOfUInt16.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfUInt16T struct { + Value []uint16 +} + +func (t *ArrayOfUInt16T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfUInt16StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependUint16(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfUInt16Start(builder) + ArrayOfUInt16AddValue(builder, valueOffset) + return ArrayOfUInt16End(builder) +} + +func (rcv *ArrayOfUInt16) UnPackTo(t *ArrayOfUInt16T) { + valueLength := rcv.ValueLength() + t.Value = make([]uint16, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfUInt16) UnPack() *ArrayOfUInt16T { + if rcv == nil { return nil } + t := &ArrayOfUInt16T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfUInt16 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfUInt32.go b/pkg/fbs/comm/datalayer/ArrayOfUInt32.go index 6a659ae..6ece5ed 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfUInt32.go +++ b/pkg/fbs/comm/datalayer/ArrayOfUInt32.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfUInt32T struct { + Value []uint32 +} + +func (t *ArrayOfUInt32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfUInt32StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependUint32(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfUInt32Start(builder) + ArrayOfUInt32AddValue(builder, valueOffset) + return ArrayOfUInt32End(builder) +} + +func (rcv *ArrayOfUInt32) UnPackTo(t *ArrayOfUInt32T) { + valueLength := rcv.ValueLength() + t.Value = make([]uint32, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfUInt32) UnPack() *ArrayOfUInt32T { + if rcv == nil { return nil } + t := &ArrayOfUInt32T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfUInt32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfUInt64.go b/pkg/fbs/comm/datalayer/ArrayOfUInt64.go index 59d4baf..ca0eb81 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfUInt64.go +++ b/pkg/fbs/comm/datalayer/ArrayOfUInt64.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfUInt64T struct { + Value []uint64 +} + +func (t *ArrayOfUInt64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + ArrayOfUInt64StartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependUint64(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + ArrayOfUInt64Start(builder) + ArrayOfUInt64AddValue(builder, valueOffset) + return ArrayOfUInt64End(builder) +} + +func (rcv *ArrayOfUInt64) UnPackTo(t *ArrayOfUInt64T) { + valueLength := rcv.ValueLength() + t.Value = make([]uint64, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *ArrayOfUInt64) UnPack() *ArrayOfUInt64T { + if rcv == nil { return nil } + t := &ArrayOfUInt64T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfUInt64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ArrayOfUInt8.go b/pkg/fbs/comm/datalayer/ArrayOfUInt8.go index fd3a0c1..df2964c 100644 --- a/pkg/fbs/comm/datalayer/ArrayOfUInt8.go +++ b/pkg/fbs/comm/datalayer/ArrayOfUInt8.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ArrayOfUInt8T struct { + Value []byte +} + +func (t *ArrayOfUInt8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueOffset = builder.CreateByteString(t.Value) + } + ArrayOfUInt8Start(builder) + ArrayOfUInt8AddValue(builder, valueOffset) + return ArrayOfUInt8End(builder) +} + +func (rcv *ArrayOfUInt8) UnPackTo(t *ArrayOfUInt8T) { + t.Value = rcv.ValueBytes() +} + +func (rcv *ArrayOfUInt8) UnPack() *ArrayOfUInt8T { + if rcv == nil { return nil } + t := &ArrayOfUInt8T{} + rcv.UnPackTo(t) + return t +} + type ArrayOfUInt8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Bool8.go b/pkg/fbs/comm/datalayer/Bool8.go index dbe3e5a..6260ee2 100644 --- a/pkg/fbs/comm/datalayer/Bool8.go +++ b/pkg/fbs/comm/datalayer/Bool8.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Bool8T struct { + Value bool +} + +func (t *Bool8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Bool8Start(builder) + Bool8AddValue(builder, t.Value) + return Bool8End(builder) +} + +func (rcv *Bool8) UnPackTo(t *Bool8T) { + t.Value = rcv.Value() +} + +func (rcv *Bool8) UnPack() *Bool8T { + if rcv == nil { return nil } + t := &Bool8T{} + rcv.UnPackTo(t) + return t +} + type Bool8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ChangeEvents.go b/pkg/fbs/comm/datalayer/ChangeEvents.go index b5edf99..f4dcc52 100644 --- a/pkg/fbs/comm/datalayer/ChangeEvents.go +++ b/pkg/fbs/comm/datalayer/ChangeEvents.go @@ -6,6 +6,34 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ChangeEventsT struct { + ValueChange DataChangeTrigger + BrowselistChange bool + MetadataChange bool +} + +func (t *ChangeEventsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ChangeEventsStart(builder) + ChangeEventsAddValueChange(builder, t.ValueChange) + ChangeEventsAddBrowselistChange(builder, t.BrowselistChange) + ChangeEventsAddMetadataChange(builder, t.MetadataChange) + return ChangeEventsEnd(builder) +} + +func (rcv *ChangeEvents) UnPackTo(t *ChangeEventsT) { + t.ValueChange = rcv.ValueChange() + t.BrowselistChange = rcv.BrowselistChange() + t.MetadataChange = rcv.MetadataChange() +} + +func (rcv *ChangeEvents) UnPack() *ChangeEventsT { + if rcv == nil { return nil } + t := &ChangeEventsT{} + rcv.UnPackTo(t) + return t +} + type ChangeEvents struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/CheckOperations.go b/pkg/fbs/comm/datalayer/CheckOperations.go index 5190917..7cebd12 100644 --- a/pkg/fbs/comm/datalayer/CheckOperations.go +++ b/pkg/fbs/comm/datalayer/CheckOperations.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CheckOperationsT struct { + Address string + Token string +} + +func (t *CheckOperationsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + addressOffset := builder.CreateString(t.Address) + tokenOffset := builder.CreateString(t.Token) + CheckOperationsStart(builder) + CheckOperationsAddAddress(builder, addressOffset) + CheckOperationsAddToken(builder, tokenOffset) + return CheckOperationsEnd(builder) +} + +func (rcv *CheckOperations) UnPackTo(t *CheckOperationsT) { + t.Address = string(rcv.Address()) + t.Token = string(rcv.Token()) +} + +func (rcv *CheckOperations) UnPack() *CheckOperationsT { + if rcv == nil { return nil } + t := &CheckOperationsT{} + rcv.UnPackTo(t) + return t +} + type CheckOperations struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Claim.go b/pkg/fbs/comm/datalayer/Claim.go index 22f773c..1785c75 100644 --- a/pkg/fbs/comm/datalayer/Claim.go +++ b/pkg/fbs/comm/datalayer/Claim.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ClaimT struct { + Claim string + Value string +} + +func (t *ClaimT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + claimOffset := builder.CreateString(t.Claim) + valueOffset := builder.CreateString(t.Value) + ClaimStart(builder) + ClaimAddClaim(builder, claimOffset) + ClaimAddValue(builder, valueOffset) + return ClaimEnd(builder) +} + +func (rcv *Claim) UnPackTo(t *ClaimT) { + t.Claim = string(rcv.Claim()) + t.Value = string(rcv.Value()) +} + +func (rcv *Claim) UnPack() *ClaimT { + if rcv == nil { return nil } + t := &ClaimT{} + rcv.UnPackTo(t) + return t +} + type Claim struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Counting.go b/pkg/fbs/comm/datalayer/Counting.go index aac466f..51c6d4f 100644 --- a/pkg/fbs/comm/datalayer/Counting.go +++ b/pkg/fbs/comm/datalayer/Counting.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CountingT struct { + CountSubscriptions bool +} + +func (t *CountingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + CountingStart(builder) + CountingAddCountSubscriptions(builder, t.CountSubscriptions) + return CountingEnd(builder) +} + +func (rcv *Counting) UnPackTo(t *CountingT) { + t.CountSubscriptions = rcv.CountSubscriptions() +} + +func (rcv *Counting) UnPack() *CountingT { + if rcv == nil { return nil } + t := &CountingT{} + rcv.UnPackTo(t) + return t +} + type Counting struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/DataChangeFilter.go b/pkg/fbs/comm/datalayer/DataChangeFilter.go index b0ea4ab..d63267e 100644 --- a/pkg/fbs/comm/datalayer/DataChangeFilter.go +++ b/pkg/fbs/comm/datalayer/DataChangeFilter.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DataChangeFilterT struct { + DeadBandValue float32 +} + +func (t *DataChangeFilterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DataChangeFilterStart(builder) + DataChangeFilterAddDeadBandValue(builder, t.DeadBandValue) + return DataChangeFilterEnd(builder) +} + +func (rcv *DataChangeFilter) UnPackTo(t *DataChangeFilterT) { + t.DeadBandValue = rcv.DeadBandValue() +} + +func (rcv *DataChangeFilter) UnPack() *DataChangeFilterT { + if rcv == nil { return nil } + t := &DataChangeFilterT{} + rcv.UnPackTo(t) + return t +} + type DataChangeFilter struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/DebugChannel.go b/pkg/fbs/comm/datalayer/DebugChannel.go index 235733d..6d7829a 100644 --- a/pkg/fbs/comm/datalayer/DebugChannel.go +++ b/pkg/fbs/comm/datalayer/DebugChannel.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DebugChannelT struct { + Name string + Address string + IsTrigger bool +} + +func (t *DebugChannelT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + addressOffset := builder.CreateString(t.Address) + DebugChannelStart(builder) + DebugChannelAddName(builder, nameOffset) + DebugChannelAddAddress(builder, addressOffset) + DebugChannelAddIsTrigger(builder, t.IsTrigger) + return DebugChannelEnd(builder) +} + +func (rcv *DebugChannel) UnPackTo(t *DebugChannelT) { + t.Name = string(rcv.Name()) + t.Address = string(rcv.Address()) + t.IsTrigger = rcv.IsTrigger() +} + +func (rcv *DebugChannel) UnPack() *DebugChannelT { + if rcv == nil { return nil } + t := &DebugChannelT{} + rcv.UnPackTo(t) + return t +} + type DebugChannel struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/DiagMoreInfo.go b/pkg/fbs/comm/datalayer/DiagMoreInfo.go new file mode 100644 index 0000000..5f08e93 --- /dev/null +++ b/pkg/fbs/comm/datalayer/DiagMoreInfo.go @@ -0,0 +1,90 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DiagMoreInfoT struct { + Key string + Value string +} + +func (t *DiagMoreInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + keyOffset := builder.CreateString(t.Key) + valueOffset := builder.CreateString(t.Value) + DiagMoreInfoStart(builder) + DiagMoreInfoAddKey(builder, keyOffset) + DiagMoreInfoAddValue(builder, valueOffset) + return DiagMoreInfoEnd(builder) +} + +func (rcv *DiagMoreInfo) UnPackTo(t *DiagMoreInfoT) { + t.Key = string(rcv.Key()) + t.Value = string(rcv.Value()) +} + +func (rcv *DiagMoreInfo) UnPack() *DiagMoreInfoT { + if rcv == nil { return nil } + t := &DiagMoreInfoT{} + rcv.UnPackTo(t) + return t +} + +type DiagMoreInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsDiagMoreInfo(buf []byte, offset flatbuffers.UOffsetT) *DiagMoreInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DiagMoreInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDiagMoreInfo(buf []byte, offset flatbuffers.UOffsetT) *DiagMoreInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DiagMoreInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DiagMoreInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DiagMoreInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DiagMoreInfo) Key() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *DiagMoreInfo) Value() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func DiagMoreInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func DiagMoreInfoAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(key), 0) +} +func DiagMoreInfoAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(value), 0) +} +func DiagMoreInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/Diagnosis.go b/pkg/fbs/comm/datalayer/Diagnosis.go index d00ee0a..bb0f52e 100644 --- a/pkg/fbs/comm/datalayer/Diagnosis.go +++ b/pkg/fbs/comm/datalayer/Diagnosis.go @@ -6,6 +6,83 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagnosisT struct { + MainDiagnosisCode uint32 + DetailedDiagnosisCode uint32 + DynamicDescription string + Entity string + MoreInfo []*DiagMoreInfoT + Cause []*DiagnosisT +} + +func (t *DiagnosisT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dynamicDescriptionOffset := builder.CreateString(t.DynamicDescription) + entityOffset := builder.CreateString(t.Entity) + moreInfoOffset := flatbuffers.UOffsetT(0) + if t.MoreInfo != nil { + moreInfoLength := len(t.MoreInfo) + moreInfoOffsets := make([]flatbuffers.UOffsetT, moreInfoLength) + for j := 0; j < moreInfoLength; j++ { + moreInfoOffsets[j] = t.MoreInfo[j].Pack(builder) + } + DiagnosisStartMoreInfoVector(builder, moreInfoLength) + for j := moreInfoLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(moreInfoOffsets[j]) + } + moreInfoOffset = builder.EndVector(moreInfoLength) + } + causeOffset := flatbuffers.UOffsetT(0) + if t.Cause != nil { + causeLength := len(t.Cause) + causeOffsets := make([]flatbuffers.UOffsetT, causeLength) + for j := 0; j < causeLength; j++ { + causeOffsets[j] = t.Cause[j].Pack(builder) + } + DiagnosisStartCauseVector(builder, causeLength) + for j := causeLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(causeOffsets[j]) + } + causeOffset = builder.EndVector(causeLength) + } + DiagnosisStart(builder) + DiagnosisAddMainDiagnosisCode(builder, t.MainDiagnosisCode) + DiagnosisAddDetailedDiagnosisCode(builder, t.DetailedDiagnosisCode) + DiagnosisAddDynamicDescription(builder, dynamicDescriptionOffset) + DiagnosisAddEntity(builder, entityOffset) + DiagnosisAddMoreInfo(builder, moreInfoOffset) + DiagnosisAddCause(builder, causeOffset) + return DiagnosisEnd(builder) +} + +func (rcv *Diagnosis) UnPackTo(t *DiagnosisT) { + t.MainDiagnosisCode = rcv.MainDiagnosisCode() + t.DetailedDiagnosisCode = rcv.DetailedDiagnosisCode() + t.DynamicDescription = string(rcv.DynamicDescription()) + t.Entity = string(rcv.Entity()) + moreInfoLength := rcv.MoreInfoLength() + t.MoreInfo = make([]*DiagMoreInfoT, moreInfoLength) + for j := 0; j < moreInfoLength; j++ { + x := DiagMoreInfo{} + rcv.MoreInfo(&x, j) + t.MoreInfo[j] = x.UnPack() + } + causeLength := rcv.CauseLength() + t.Cause = make([]*DiagnosisT, causeLength) + for j := 0; j < causeLength; j++ { + x := Diagnosis{} + rcv.Cause(&x, j) + t.Cause[j] = x.UnPack() + } +} + +func (rcv *Diagnosis) UnPack() *DiagnosisT { + if rcv == nil { return nil } + t := &DiagnosisT{} + rcv.UnPackTo(t) + return t +} + type Diagnosis struct { _tab flatbuffers.Table } @@ -73,8 +150,48 @@ func (rcv *Diagnosis) Entity() []byte { return nil } +func (rcv *Diagnosis) MoreInfo(obj *DiagMoreInfo, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + 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 *Diagnosis) MoreInfoLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Diagnosis) Cause(obj *Diagnosis, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + 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 *Diagnosis) CauseLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + func DiagnosisStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(6) } func DiagnosisAddMainDiagnosisCode(builder *flatbuffers.Builder, mainDiagnosisCode uint32) { builder.PrependUint32Slot(0, mainDiagnosisCode, 0) @@ -88,6 +205,18 @@ func DiagnosisAddDynamicDescription(builder *flatbuffers.Builder, dynamicDescrip func DiagnosisAddEntity(builder *flatbuffers.Builder, entity flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(entity), 0) } +func DiagnosisAddMoreInfo(builder *flatbuffers.Builder, moreInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(moreInfo), 0) +} +func DiagnosisStartMoreInfoVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func DiagnosisAddCause(builder *flatbuffers.Builder, cause flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(cause), 0) +} +func DiagnosisStartCauseVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} func DiagnosisEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/Extension.go b/pkg/fbs/comm/datalayer/Extension.go index 8224d93..ee410bc 100644 --- a/pkg/fbs/comm/datalayer/Extension.go +++ b/pkg/fbs/comm/datalayer/Extension.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ExtensionT struct { + Key string + Value string +} + +func (t *ExtensionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + keyOffset := builder.CreateString(t.Key) + valueOffset := builder.CreateString(t.Value) + ExtensionStart(builder) + ExtensionAddKey(builder, keyOffset) + ExtensionAddValue(builder, valueOffset) + return ExtensionEnd(builder) +} + +func (rcv *Extension) UnPackTo(t *ExtensionT) { + t.Key = string(rcv.Key()) + t.Value = string(rcv.Value()) +} + +func (rcv *Extension) UnPack() *ExtensionT { + if rcv == nil { return nil } + t := &ExtensionT{} + rcv.UnPackTo(t) + return t +} + type Extension struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/FactoryStats.go b/pkg/fbs/comm/datalayer/FactoryStats.go index 5b8ff21..5b1d63f 100644 --- a/pkg/fbs/comm/datalayer/FactoryStats.go +++ b/pkg/fbs/comm/datalayer/FactoryStats.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type FactoryStatsT struct { + NumClients uint32 + NumProviders uint32 + OpenClientRequests uint32 + OpenProviderRequests uint32 +} + +func (t *FactoryStatsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + FactoryStatsStart(builder) + FactoryStatsAddNumClients(builder, t.NumClients) + FactoryStatsAddNumProviders(builder, t.NumProviders) + FactoryStatsAddOpenClientRequests(builder, t.OpenClientRequests) + FactoryStatsAddOpenProviderRequests(builder, t.OpenProviderRequests) + return FactoryStatsEnd(builder) +} + +func (rcv *FactoryStats) UnPackTo(t *FactoryStatsT) { + t.NumClients = rcv.NumClients() + t.NumProviders = rcv.NumProviders() + t.OpenClientRequests = rcv.OpenClientRequests() + t.OpenProviderRequests = rcv.OpenProviderRequests() +} + +func (rcv *FactoryStats) UnPack() *FactoryStatsT { + if rcv == nil { return nil } + t := &FactoryStatsT{} + rcv.UnPackTo(t) + return t +} + type FactoryStats struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Float32.go b/pkg/fbs/comm/datalayer/Float32.go index 69c2dce..ed5c4f5 100644 --- a/pkg/fbs/comm/datalayer/Float32.go +++ b/pkg/fbs/comm/datalayer/Float32.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Float32T struct { + Value float32 +} + +func (t *Float32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Float32Start(builder) + Float32AddValue(builder, t.Value) + return Float32End(builder) +} + +func (rcv *Float32) UnPackTo(t *Float32T) { + t.Value = rcv.Value() +} + +func (rcv *Float32) UnPack() *Float32T { + if rcv == nil { return nil } + t := &Float32T{} + rcv.UnPackTo(t) + return t +} + type Float32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Float64.go b/pkg/fbs/comm/datalayer/Float64.go index f0f0f11..90ed264 100644 --- a/pkg/fbs/comm/datalayer/Float64.go +++ b/pkg/fbs/comm/datalayer/Float64.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Float64T struct { + Value float64 +} + +func (t *Float64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Float64Start(builder) + Float64AddValue(builder, t.Value) + return Float64End(builder) +} + +func (rcv *Float64) UnPackTo(t *Float64T) { + t.Value = rcv.Value() +} + +func (rcv *Float64) UnPack() *Float64T { + if rcv == nil { return nil } + t := &Float64T{} + rcv.UnPackTo(t) + return t +} + type Float64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Int16.go b/pkg/fbs/comm/datalayer/Int16.go index d7a1608..b2ac256 100644 --- a/pkg/fbs/comm/datalayer/Int16.go +++ b/pkg/fbs/comm/datalayer/Int16.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Int16T struct { + Value int16 +} + +func (t *Int16T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int16Start(builder) + Int16AddValue(builder, t.Value) + return Int16End(builder) +} + +func (rcv *Int16) UnPackTo(t *Int16T) { + t.Value = rcv.Value() +} + +func (rcv *Int16) UnPack() *Int16T { + if rcv == nil { return nil } + t := &Int16T{} + rcv.UnPackTo(t) + return t +} + type Int16 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Int32.go b/pkg/fbs/comm/datalayer/Int32.go index a0f4d25..d086d3d 100644 --- a/pkg/fbs/comm/datalayer/Int32.go +++ b/pkg/fbs/comm/datalayer/Int32.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Int32T struct { + Value int32 +} + +func (t *Int32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int32Start(builder) + Int32AddValue(builder, t.Value) + return Int32End(builder) +} + +func (rcv *Int32) UnPackTo(t *Int32T) { + t.Value = rcv.Value() +} + +func (rcv *Int32) UnPack() *Int32T { + if rcv == nil { return nil } + t := &Int32T{} + rcv.UnPackTo(t) + return t +} + type Int32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Int64.go b/pkg/fbs/comm/datalayer/Int64.go index 86899f1..8a52354 100644 --- a/pkg/fbs/comm/datalayer/Int64.go +++ b/pkg/fbs/comm/datalayer/Int64.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Int64T struct { + Value int64 +} + +func (t *Int64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int64Start(builder) + Int64AddValue(builder, t.Value) + return Int64End(builder) +} + +func (rcv *Int64) UnPackTo(t *Int64T) { + t.Value = rcv.Value() +} + +func (rcv *Int64) UnPack() *Int64T { + if rcv == nil { return nil } + t := &Int64T{} + rcv.UnPackTo(t) + return t +} + type Int64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Int8.go b/pkg/fbs/comm/datalayer/Int8.go index 564140c..766e588 100644 --- a/pkg/fbs/comm/datalayer/Int8.go +++ b/pkg/fbs/comm/datalayer/Int8.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Int8T struct { + Value int8 +} + +func (t *Int8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int8Start(builder) + Int8AddValue(builder, t.Value) + return Int8End(builder) +} + +func (rcv *Int8) UnPackTo(t *Int8T) { + t.Value = rcv.Value() +} + +func (rcv *Int8) UnPack() *Int8T { + if rcv == nil { return nil } + t := &Int8T{} + rcv.UnPackTo(t) + return t +} + type Int8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/LocaleText.go b/pkg/fbs/comm/datalayer/LocaleText.go index 46082f8..0125615 100644 --- a/pkg/fbs/comm/datalayer/LocaleText.go +++ b/pkg/fbs/comm/datalayer/LocaleText.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LocaleTextT struct { + Id string + Text string +} + +func (t *LocaleTextT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idOffset := builder.CreateString(t.Id) + textOffset := builder.CreateString(t.Text) + LocaleTextStart(builder) + LocaleTextAddId(builder, idOffset) + LocaleTextAddText(builder, textOffset) + return LocaleTextEnd(builder) +} + +func (rcv *LocaleText) UnPackTo(t *LocaleTextT) { + t.Id = string(rcv.Id()) + t.Text = string(rcv.Text()) +} + +func (rcv *LocaleText) UnPack() *LocaleTextT { + if rcv == nil { return nil } + t := &LocaleTextT{} + rcv.UnPackTo(t) + return t +} + type LocaleText struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Memory.go b/pkg/fbs/comm/datalayer/Memory.go index 9e75531..4f3dc9f 100644 --- a/pkg/fbs/comm/datalayer/Memory.go +++ b/pkg/fbs/comm/datalayer/Memory.go @@ -6,6 +6,38 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MemoryT struct { + Type MemoryType + Id string + SizeBytes uint32 + AccessType AccessType +} + +func (t *MemoryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idOffset := builder.CreateString(t.Id) + MemoryStart(builder) + MemoryAddType(builder, t.Type) + MemoryAddId(builder, idOffset) + MemoryAddSizeBytes(builder, t.SizeBytes) + MemoryAddAccessType(builder, t.AccessType) + return MemoryEnd(builder) +} + +func (rcv *Memory) UnPackTo(t *MemoryT) { + t.Type = rcv.Type() + t.Id = string(rcv.Id()) + t.SizeBytes = rcv.SizeBytes() + t.AccessType = rcv.AccessType() +} + +func (rcv *Memory) UnPack() *MemoryT { + if rcv == nil { return nil } + t := &MemoryT{} + rcv.UnPackTo(t) + return t +} + type Memory struct { _tab flatbuffers.Table } @@ -65,8 +97,20 @@ func (rcv *Memory) MutateSizeBytes(n uint32) bool { return rcv._tab.MutateUint32Slot(8, n) } +func (rcv *Memory) AccessType() AccessType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return AccessType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Memory) MutateAccessType(n AccessType) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + func MemoryStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(4) } func MemoryAddType(builder *flatbuffers.Builder, type_ MemoryType) { builder.PrependInt8Slot(0, int8(type_), 0) @@ -77,6 +121,9 @@ func MemoryAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) { func MemoryAddSizeBytes(builder *flatbuffers.Builder, sizeBytes uint32) { builder.PrependUint32Slot(2, sizeBytes, 0) } +func MemoryAddAccessType(builder *flatbuffers.Builder, accessType AccessType) { + builder.PrependInt8Slot(3, int8(accessType), 0) +} func MemoryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/MemoryMap.go b/pkg/fbs/comm/datalayer/MemoryMap.go index d5b5353..7895b8e 100644 --- a/pkg/fbs/comm/datalayer/MemoryMap.go +++ b/pkg/fbs/comm/datalayer/MemoryMap.go @@ -6,6 +6,50 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MemoryMapT struct { + Variables []*VariableT + Revision uint32 +} + +func (t *MemoryMapT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + variablesOffset := flatbuffers.UOffsetT(0) + if t.Variables != nil { + variablesLength := len(t.Variables) + variablesOffsets := make([]flatbuffers.UOffsetT, variablesLength) + for j := 0; j < variablesLength; j++ { + variablesOffsets[j] = t.Variables[j].Pack(builder) + } + MemoryMapStartVariablesVector(builder, variablesLength) + for j := variablesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(variablesOffsets[j]) + } + variablesOffset = builder.EndVector(variablesLength) + } + MemoryMapStart(builder) + MemoryMapAddVariables(builder, variablesOffset) + MemoryMapAddRevision(builder, t.Revision) + return MemoryMapEnd(builder) +} + +func (rcv *MemoryMap) UnPackTo(t *MemoryMapT) { + variablesLength := rcv.VariablesLength() + t.Variables = make([]*VariableT, variablesLength) + for j := 0; j < variablesLength; j++ { + x := Variable{} + rcv.Variables(&x, j) + t.Variables[j] = x.UnPack() + } + t.Revision = rcv.Revision() +} + +func (rcv *MemoryMap) UnPack() *MemoryMapT { + if rcv == nil { return nil } + t := &MemoryMapT{} + rcv.UnPackTo(t) + return t +} + type MemoryMap struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/MessageDetail.go b/pkg/fbs/comm/datalayer/MessageDetail.go index 7381cec..ca12a7e 100644 --- a/pkg/fbs/comm/datalayer/MessageDetail.go +++ b/pkg/fbs/comm/datalayer/MessageDetail.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MessageDetailT struct { + Timestamp uint64 +} + +func (t *MessageDetailT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MessageDetailStart(builder) + MessageDetailAddTimestamp(builder, t.Timestamp) + return MessageDetailEnd(builder) +} + +func (rcv *MessageDetail) UnPackTo(t *MessageDetailT) { + t.Timestamp = rcv.Timestamp() +} + +func (rcv *MessageDetail) UnPack() *MessageDetailT { + if rcv == nil { return nil } + t := &MessageDetailT{} + rcv.UnPackTo(t) + return t +} + type MessageDetail struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Metadata.go b/pkg/fbs/comm/datalayer/Metadata.go index db6db04..644a020 100644 --- a/pkg/fbs/comm/datalayer/Metadata.go +++ b/pkg/fbs/comm/datalayer/Metadata.go @@ -6,6 +6,139 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MetadataT struct { + NodeClass NodeClass + Operations *AllowedOperationsT + Description string + DescriptionUrl string + DisplayName string + DisplayFormat DisplayFormat + Unit string + Extensions []*ExtensionT + References []*ReferenceT + Descriptions []*LocaleTextT + DisplayNames []*LocaleTextT +} + +func (t *MetadataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + operationsOffset := t.Operations.Pack(builder) + descriptionOffset := builder.CreateString(t.Description) + descriptionUrlOffset := builder.CreateString(t.DescriptionUrl) + displayNameOffset := builder.CreateString(t.DisplayName) + unitOffset := builder.CreateString(t.Unit) + extensionsOffset := flatbuffers.UOffsetT(0) + if t.Extensions != nil { + extensionsLength := len(t.Extensions) + extensionsOffsets := make([]flatbuffers.UOffsetT, extensionsLength) + for j := 0; j < extensionsLength; j++ { + extensionsOffsets[j] = t.Extensions[j].Pack(builder) + } + MetadataStartExtensionsVector(builder, extensionsLength) + for j := extensionsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(extensionsOffsets[j]) + } + extensionsOffset = builder.EndVector(extensionsLength) + } + referencesOffset := flatbuffers.UOffsetT(0) + if t.References != nil { + referencesLength := len(t.References) + referencesOffsets := make([]flatbuffers.UOffsetT, referencesLength) + for j := 0; j < referencesLength; j++ { + referencesOffsets[j] = t.References[j].Pack(builder) + } + MetadataStartReferencesVector(builder, referencesLength) + for j := referencesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(referencesOffsets[j]) + } + referencesOffset = builder.EndVector(referencesLength) + } + descriptionsOffset := flatbuffers.UOffsetT(0) + if t.Descriptions != nil { + descriptionsLength := len(t.Descriptions) + descriptionsOffsets := make([]flatbuffers.UOffsetT, descriptionsLength) + for j := 0; j < descriptionsLength; j++ { + descriptionsOffsets[j] = t.Descriptions[j].Pack(builder) + } + MetadataStartDescriptionsVector(builder, descriptionsLength) + for j := descriptionsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(descriptionsOffsets[j]) + } + descriptionsOffset = builder.EndVector(descriptionsLength) + } + displayNamesOffset := flatbuffers.UOffsetT(0) + if t.DisplayNames != nil { + displayNamesLength := len(t.DisplayNames) + displayNamesOffsets := make([]flatbuffers.UOffsetT, displayNamesLength) + for j := 0; j < displayNamesLength; j++ { + displayNamesOffsets[j] = t.DisplayNames[j].Pack(builder) + } + MetadataStartDisplayNamesVector(builder, displayNamesLength) + for j := displayNamesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(displayNamesOffsets[j]) + } + displayNamesOffset = builder.EndVector(displayNamesLength) + } + MetadataStart(builder) + MetadataAddNodeClass(builder, t.NodeClass) + MetadataAddOperations(builder, operationsOffset) + MetadataAddDescription(builder, descriptionOffset) + MetadataAddDescriptionUrl(builder, descriptionUrlOffset) + MetadataAddDisplayName(builder, displayNameOffset) + MetadataAddDisplayFormat(builder, t.DisplayFormat) + MetadataAddUnit(builder, unitOffset) + MetadataAddExtensions(builder, extensionsOffset) + MetadataAddReferences(builder, referencesOffset) + MetadataAddDescriptions(builder, descriptionsOffset) + MetadataAddDisplayNames(builder, displayNamesOffset) + return MetadataEnd(builder) +} + +func (rcv *Metadata) UnPackTo(t *MetadataT) { + t.NodeClass = rcv.NodeClass() + t.Operations = rcv.Operations(nil).UnPack() + t.Description = string(rcv.Description()) + t.DescriptionUrl = string(rcv.DescriptionUrl()) + t.DisplayName = string(rcv.DisplayName()) + t.DisplayFormat = rcv.DisplayFormat() + t.Unit = string(rcv.Unit()) + extensionsLength := rcv.ExtensionsLength() + t.Extensions = make([]*ExtensionT, extensionsLength) + for j := 0; j < extensionsLength; j++ { + x := Extension{} + rcv.Extensions(&x, j) + t.Extensions[j] = x.UnPack() + } + referencesLength := rcv.ReferencesLength() + t.References = make([]*ReferenceT, referencesLength) + for j := 0; j < referencesLength; j++ { + x := Reference{} + rcv.References(&x, j) + t.References[j] = x.UnPack() + } + descriptionsLength := rcv.DescriptionsLength() + t.Descriptions = make([]*LocaleTextT, descriptionsLength) + for j := 0; j < descriptionsLength; j++ { + x := LocaleText{} + rcv.Descriptions(&x, j) + t.Descriptions[j] = x.UnPack() + } + displayNamesLength := rcv.DisplayNamesLength() + t.DisplayNames = make([]*LocaleTextT, displayNamesLength) + for j := 0; j < displayNamesLength; j++ { + x := LocaleText{} + rcv.DisplayNames(&x, j) + t.DisplayNames[j] = x.UnPack() + } +} + +func (rcv *Metadata) UnPack() *MetadataT { + if rcv == nil { return nil } + t := &MetadataT{} + rcv.UnPackTo(t) + return t +} + type Metadata struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/MetadataDB.go b/pkg/fbs/comm/datalayer/MetadataDB.go index 55cb5a5..9a2d18d 100644 --- a/pkg/fbs/comm/datalayer/MetadataDB.go +++ b/pkg/fbs/comm/datalayer/MetadataDB.go @@ -6,6 +6,59 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MetadataDBT struct { + Address string + Childs []*MetadataDBT + Asterisk *MetadataDBT + Metadata *MetadataT +} + +func (t *MetadataDBT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + addressOffset := builder.CreateString(t.Address) + childsOffset := flatbuffers.UOffsetT(0) + if t.Childs != nil { + childsLength := len(t.Childs) + childsOffsets := make([]flatbuffers.UOffsetT, childsLength) + for j := 0; j < childsLength; j++ { + childsOffsets[j] = t.Childs[j].Pack(builder) + } + MetadataDBStartChildsVector(builder, childsLength) + for j := childsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(childsOffsets[j]) + } + childsOffset = builder.EndVector(childsLength) + } + asteriskOffset := t.Asterisk.Pack(builder) + metadataOffset := t.Metadata.Pack(builder) + MetadataDBStart(builder) + MetadataDBAddAddress(builder, addressOffset) + MetadataDBAddChilds(builder, childsOffset) + MetadataDBAddAsterisk(builder, asteriskOffset) + MetadataDBAddMetadata(builder, metadataOffset) + return MetadataDBEnd(builder) +} + +func (rcv *MetadataDB) UnPackTo(t *MetadataDBT) { + t.Address = string(rcv.Address()) + childsLength := rcv.ChildsLength() + t.Childs = make([]*MetadataDBT, childsLength) + for j := 0; j < childsLength; j++ { + x := MetadataDB{} + rcv.Childs(&x, j) + t.Childs[j] = x.UnPack() + } + t.Asterisk = rcv.Asterisk(nil).UnPack() + t.Metadata = rcv.Metadata(nil).UnPack() +} + +func (rcv *MetadataDB) UnPack() *MetadataDBT { + if rcv == nil { return nil } + t := &MetadataDBT{} + rcv.UnPackTo(t) + return t +} + type MetadataDB struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/NTelBufferConfig.go b/pkg/fbs/comm/datalayer/NTelBufferConfig.go new file mode 100644 index 0000000..a31a4ca --- /dev/null +++ b/pkg/fbs/comm/datalayer/NTelBufferConfig.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type NTelBufferConfigT struct { + DefaultN uint16 +} + +func (t *NTelBufferConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + NTelBufferConfigStart(builder) + NTelBufferConfigAddDefaultN(builder, t.DefaultN) + return NTelBufferConfigEnd(builder) +} + +func (rcv *NTelBufferConfig) UnPackTo(t *NTelBufferConfigT) { + t.DefaultN = rcv.DefaultN() +} + +func (rcv *NTelBufferConfig) UnPack() *NTelBufferConfigT { + if rcv == nil { return nil } + t := &NTelBufferConfigT{} + rcv.UnPackTo(t) + return t +} + +type NTelBufferConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsNTelBufferConfig(buf []byte, offset flatbuffers.UOffsetT) *NTelBufferConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &NTelBufferConfig{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsNTelBufferConfig(buf []byte, offset flatbuffers.UOffsetT) *NTelBufferConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &NTelBufferConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *NTelBufferConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *NTelBufferConfig) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *NTelBufferConfig) DefaultN() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 6 +} + +func (rcv *NTelBufferConfig) MutateDefaultN(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func NTelBufferConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func NTelBufferConfigAddDefaultN(builder *flatbuffers.Builder, defaultN uint16) { + builder.PrependUint16Slot(0, defaultN, 6) +} +func NTelBufferConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/NotifyInfo.go b/pkg/fbs/comm/datalayer/NotifyInfo.go index 8f0cb99..4485dd5 100644 --- a/pkg/fbs/comm/datalayer/NotifyInfo.go +++ b/pkg/fbs/comm/datalayer/NotifyInfo.go @@ -6,6 +6,35 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type NotifyInfoT struct { + Node string + Timestamp uint64 + NotifyType NotifyType +} + +func (t *NotifyInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nodeOffset := builder.CreateString(t.Node) + NotifyInfoStart(builder) + NotifyInfoAddNode(builder, nodeOffset) + NotifyInfoAddTimestamp(builder, t.Timestamp) + NotifyInfoAddNotifyType(builder, t.NotifyType) + return NotifyInfoEnd(builder) +} + +func (rcv *NotifyInfo) UnPackTo(t *NotifyInfoT) { + t.Node = string(rcv.Node()) + t.Timestamp = rcv.Timestamp() + t.NotifyType = rcv.NotifyType() +} + +func (rcv *NotifyInfo) UnPack() *NotifyInfoT { + if rcv == nil { return nil } + t := &NotifyInfoT{} + rcv.UnPackTo(t) + return t +} + type NotifyInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/PersistenceParam.go b/pkg/fbs/comm/datalayer/PersistenceParam.go index 8572196..4cf0e69 100644 --- a/pkg/fbs/comm/datalayer/PersistenceParam.go +++ b/pkg/fbs/comm/datalayer/PersistenceParam.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type PersistenceParamT struct { + ConfigurationPath string + Id string + Phase string +} + +func (t *PersistenceParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + configurationPathOffset := builder.CreateString(t.ConfigurationPath) + idOffset := builder.CreateString(t.Id) + phaseOffset := builder.CreateString(t.Phase) + PersistenceParamStart(builder) + PersistenceParamAddConfigurationPath(builder, configurationPathOffset) + PersistenceParamAddId(builder, idOffset) + PersistenceParamAddPhase(builder, phaseOffset) + return PersistenceParamEnd(builder) +} + +func (rcv *PersistenceParam) UnPackTo(t *PersistenceParamT) { + t.ConfigurationPath = string(rcv.ConfigurationPath()) + t.Id = string(rcv.Id()) + t.Phase = string(rcv.Phase()) +} + +func (rcv *PersistenceParam) UnPack() *PersistenceParamT { + if rcv == nil { return nil } + t := &PersistenceParamT{} + rcv.UnPackTo(t) + return t +} + type PersistenceParam struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Problem.go b/pkg/fbs/comm/datalayer/Problem.go index 0a52752..76ba20a 100644 --- a/pkg/fbs/comm/datalayer/Problem.go +++ b/pkg/fbs/comm/datalayer/Problem.go @@ -6,6 +6,112 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ProblemT struct { + Type string + Title string + Status int32 + Detail string + Instance string + MainDiagnosisCode string + DetailedDiagnosisCode string + DynamicDescription string + Severity Severity + Links []string + Entity string + MoreInfo []byte + Cause []*ProblemT +} + +func (t *ProblemT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + typeOffset := builder.CreateString(t.Type) + titleOffset := builder.CreateString(t.Title) + detailOffset := builder.CreateString(t.Detail) + instanceOffset := builder.CreateString(t.Instance) + mainDiagnosisCodeOffset := builder.CreateString(t.MainDiagnosisCode) + detailedDiagnosisCodeOffset := builder.CreateString(t.DetailedDiagnosisCode) + dynamicDescriptionOffset := builder.CreateString(t.DynamicDescription) + linksOffset := flatbuffers.UOffsetT(0) + if t.Links != nil { + linksLength := len(t.Links) + linksOffsets := make([]flatbuffers.UOffsetT, linksLength) + for j := 0; j < linksLength; j++ { + linksOffsets[j] = builder.CreateString(t.Links[j]) + } + ProblemStartLinksVector(builder, linksLength) + for j := linksLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(linksOffsets[j]) + } + linksOffset = builder.EndVector(linksLength) + } + entityOffset := builder.CreateString(t.Entity) + moreInfoOffset := flatbuffers.UOffsetT(0) + if t.MoreInfo != nil { + moreInfoOffset = builder.CreateByteString(t.MoreInfo) + } + causeOffset := flatbuffers.UOffsetT(0) + if t.Cause != nil { + causeLength := len(t.Cause) + causeOffsets := make([]flatbuffers.UOffsetT, causeLength) + for j := 0; j < causeLength; j++ { + causeOffsets[j] = t.Cause[j].Pack(builder) + } + ProblemStartCauseVector(builder, causeLength) + for j := causeLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(causeOffsets[j]) + } + causeOffset = builder.EndVector(causeLength) + } + ProblemStart(builder) + ProblemAddType(builder, typeOffset) + ProblemAddTitle(builder, titleOffset) + ProblemAddStatus(builder, t.Status) + ProblemAddDetail(builder, detailOffset) + ProblemAddInstance(builder, instanceOffset) + ProblemAddMainDiagnosisCode(builder, mainDiagnosisCodeOffset) + ProblemAddDetailedDiagnosisCode(builder, detailedDiagnosisCodeOffset) + ProblemAddDynamicDescription(builder, dynamicDescriptionOffset) + ProblemAddSeverity(builder, t.Severity) + ProblemAddLinks(builder, linksOffset) + ProblemAddEntity(builder, entityOffset) + ProblemAddMoreInfo(builder, moreInfoOffset) + ProblemAddCause(builder, causeOffset) + return ProblemEnd(builder) +} + +func (rcv *Problem) UnPackTo(t *ProblemT) { + t.Type = string(rcv.Type()) + t.Title = string(rcv.Title()) + t.Status = rcv.Status() + t.Detail = string(rcv.Detail()) + t.Instance = string(rcv.Instance()) + t.MainDiagnosisCode = string(rcv.MainDiagnosisCode()) + t.DetailedDiagnosisCode = string(rcv.DetailedDiagnosisCode()) + t.DynamicDescription = string(rcv.DynamicDescription()) + t.Severity = rcv.Severity() + linksLength := rcv.LinksLength() + t.Links = make([]string, linksLength) + for j := 0; j < linksLength; j++ { + t.Links[j] = string(rcv.Links(j)) + } + t.Entity = string(rcv.Entity()) + t.MoreInfo = rcv.MoreInfoBytes() + causeLength := rcv.CauseLength() + t.Cause = make([]*ProblemT, causeLength) + for j := 0; j < causeLength; j++ { + x := Problem{} + rcv.Cause(&x, j) + t.Cause[j] = x.UnPack() + } +} + +func (rcv *Problem) UnPack() *ProblemT { + if rcv == nil { return nil } + t := &ProblemT{} + rcv.UnPackTo(t) + return t +} + type Problem struct { _tab flatbuffers.Table } @@ -138,8 +244,62 @@ func (rcv *Problem) Entity() []byte { return nil } +func (rcv *Problem) MoreInfo(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *Problem) MoreInfoLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Problem) MoreInfoBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Problem) MutateMoreInfo(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func (rcv *Problem) Cause(obj *Problem, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + 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 *Problem) CauseLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + func ProblemStart(builder *flatbuffers.Builder) { - builder.StartObject(11) + builder.StartObject(13) } func ProblemAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(type_), 0) @@ -177,6 +337,18 @@ func ProblemStartLinksVector(builder *flatbuffers.Builder, numElems int) flatbuf func ProblemAddEntity(builder *flatbuffers.Builder, entity flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(entity), 0) } +func ProblemAddMoreInfo(builder *flatbuffers.Builder, moreInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(moreInfo), 0) +} +func ProblemStartMoreInfoVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func ProblemAddCause(builder *flatbuffers.Builder, cause flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(cause), 0) +} +func ProblemStartCauseVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} func ProblemEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/ProgramTask.go b/pkg/fbs/comm/datalayer/ProgramTask.go index 661ad2b..464b228 100644 --- a/pkg/fbs/comm/datalayer/ProgramTask.go +++ b/pkg/fbs/comm/datalayer/ProgramTask.go @@ -6,6 +6,43 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ProgramTaskT struct { + Id string + State ProgramTaskState + Progress uint32 + Result *DiagnosisT + ProgressInfo string +} + +func (t *ProgramTaskT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idOffset := builder.CreateString(t.Id) + resultOffset := t.Result.Pack(builder) + progressInfoOffset := builder.CreateString(t.ProgressInfo) + ProgramTaskStart(builder) + ProgramTaskAddId(builder, idOffset) + ProgramTaskAddState(builder, t.State) + ProgramTaskAddProgress(builder, t.Progress) + ProgramTaskAddResult(builder, resultOffset) + ProgramTaskAddProgressInfo(builder, progressInfoOffset) + return ProgramTaskEnd(builder) +} + +func (rcv *ProgramTask) UnPackTo(t *ProgramTaskT) { + t.Id = string(rcv.Id()) + t.State = rcv.State() + t.Progress = rcv.Progress() + t.Result = rcv.Result(nil).UnPack() + t.ProgressInfo = string(rcv.ProgressInfo()) +} + +func (rcv *ProgramTask) UnPack() *ProgramTaskT { + if rcv == nil { return nil } + t := &ProgramTaskT{} + rcv.UnPackTo(t) + return t +} + type ProgramTask struct { _tab flatbuffers.Table } @@ -78,8 +115,16 @@ func (rcv *ProgramTask) Result(obj *Diagnosis) *Diagnosis { return nil } +func (rcv *ProgramTask) ProgressInfo() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + func ProgramTaskStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(5) } func ProgramTaskAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0) @@ -93,6 +138,9 @@ func ProgramTaskAddProgress(builder *flatbuffers.Builder, progress uint32) { func ProgramTaskAddResult(builder *flatbuffers.Builder, result flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(result), 0) } +func ProgramTaskAddProgressInfo(builder *flatbuffers.Builder, progressInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(progressInfo), 0) +} func ProgramTaskEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/ProgramTaskAll.go b/pkg/fbs/comm/datalayer/ProgramTaskAll.go index ba24f27..508f320 100644 --- a/pkg/fbs/comm/datalayer/ProgramTaskAll.go +++ b/pkg/fbs/comm/datalayer/ProgramTaskAll.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ProgramTaskAllT struct { + Tasks []*ProgramTaskT +} + +func (t *ProgramTaskAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TasksOffset := flatbuffers.UOffsetT(0) + if t.Tasks != nil { + TasksLength := len(t.Tasks) + TasksOffsets := make([]flatbuffers.UOffsetT, TasksLength) + for j := 0; j < TasksLength; j++ { + TasksOffsets[j] = t.Tasks[j].Pack(builder) + } + ProgramTaskAllStartTasksVector(builder, TasksLength) + for j := TasksLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(TasksOffsets[j]) + } + TasksOffset = builder.EndVector(TasksLength) + } + ProgramTaskAllStart(builder) + ProgramTaskAllAddTasks(builder, TasksOffset) + return ProgramTaskAllEnd(builder) +} + +func (rcv *ProgramTaskAll) UnPackTo(t *ProgramTaskAllT) { + TasksLength := rcv.TasksLength() + t.Tasks = make([]*ProgramTaskT, TasksLength) + for j := 0; j < TasksLength; j++ { + x := ProgramTask{} + rcv.Tasks(&x, j) + t.Tasks[j] = x.UnPack() + } +} + +func (rcv *ProgramTaskAll) UnPack() *ProgramTaskAllT { + if rcv == nil { return nil } + t := &ProgramTaskAllT{} + rcv.UnPackTo(t) + return t +} + type ProgramTaskAll struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Properties.go b/pkg/fbs/comm/datalayer/Properties.go index 0b8ed12..500ca41 100644 --- a/pkg/fbs/comm/datalayer/Properties.go +++ b/pkg/fbs/comm/datalayer/Properties.go @@ -2,7 +2,11 @@ package datalayer -import "strconv" +import ( + "strconv" + + flatbuffers "github.com/google/flatbuffers/go" +) type Properties byte @@ -39,3 +43,48 @@ func (v Properties) String() string { } return "Properties(" + strconv.FormatInt(int64(v), 10) + ")" } + +type PropertiesT struct { + Type Properties + Value interface{} +} + +func (t *PropertiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case PropertiesSampling: + return t.Value.(*SamplingT).Pack(builder) + case PropertiesQueueing: + return t.Value.(*QueueingT).Pack(builder) + case PropertiesDataChangeFilter: + return t.Value.(*DataChangeFilterT).Pack(builder) + case PropertiesChangeEvents: + return t.Value.(*ChangeEventsT).Pack(builder) + case PropertiesCounting: + return t.Value.(*CountingT).Pack(builder) + } + return 0 +} + +func (rcv Properties) UnPack(table flatbuffers.Table) *PropertiesT { + switch rcv { + case PropertiesSampling: + x := Sampling{_tab: table} + return &PropertiesT{ Type: PropertiesSampling, Value: x.UnPack() } + case PropertiesQueueing: + x := Queueing{_tab: table} + return &PropertiesT{ Type: PropertiesQueueing, Value: x.UnPack() } + case PropertiesDataChangeFilter: + x := DataChangeFilter{_tab: table} + return &PropertiesT{ Type: PropertiesDataChangeFilter, Value: x.UnPack() } + case PropertiesChangeEvents: + x := ChangeEvents{_tab: table} + return &PropertiesT{ Type: PropertiesChangeEvents, Value: x.UnPack() } + case PropertiesCounting: + x := Counting{_tab: table} + return &PropertiesT{ Type: PropertiesCounting, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/comm/datalayer/Property.go b/pkg/fbs/comm/datalayer/Property.go index 092766e..7523118 100644 --- a/pkg/fbs/comm/datalayer/Property.go +++ b/pkg/fbs/comm/datalayer/Property.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type PropertyT struct { + Rule *PropertiesT +} + +func (t *PropertyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ruleOffset := t.Rule.Pack(builder) + + PropertyStart(builder) + if t.Rule != nil { + PropertyAddRuleType(builder, t.Rule.Type) + } + PropertyAddRule(builder, ruleOffset) + return PropertyEnd(builder) +} + +func (rcv *Property) UnPackTo(t *PropertyT) { + ruleTable := flatbuffers.Table{} + if rcv.Rule(&ruleTable) { + t.Rule = rcv.RuleType().UnPack(ruleTable) + } +} + +func (rcv *Property) UnPack() *PropertyT { + if rcv == nil { return nil } + t := &PropertyT{} + rcv.UnPackTo(t) + return t +} + type Property struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Queueing.go b/pkg/fbs/comm/datalayer/Queueing.go index 55898e6..0b523a2 100644 --- a/pkg/fbs/comm/datalayer/Queueing.go +++ b/pkg/fbs/comm/datalayer/Queueing.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type QueueingT struct { + QueueSize uint32 + Behaviour QueueBehaviour +} + +func (t *QueueingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + QueueingStart(builder) + QueueingAddQueueSize(builder, t.QueueSize) + QueueingAddBehaviour(builder, t.Behaviour) + return QueueingEnd(builder) +} + +func (rcv *Queueing) UnPackTo(t *QueueingT) { + t.QueueSize = rcv.QueueSize() + t.Behaviour = rcv.Behaviour() +} + +func (rcv *Queueing) UnPack() *QueueingT { + if rcv == nil { return nil } + t := &QueueingT{} + rcv.UnPackTo(t) + return t +} + type Queueing struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Raw.go b/pkg/fbs/comm/datalayer/Raw.go index b4d0dbd..9c3504e 100644 --- a/pkg/fbs/comm/datalayer/Raw.go +++ b/pkg/fbs/comm/datalayer/Raw.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type RawT struct { + Value []int8 +} + +func (t *RawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != nil { + valueLength := len(t.Value) + RawStartValueVector(builder, valueLength) + for j := valueLength - 1; j >= 0; j-- { + builder.PrependInt8(t.Value[j]) + } + valueOffset = builder.EndVector(valueLength) + } + RawStart(builder) + RawAddValue(builder, valueOffset) + return RawEnd(builder) +} + +func (rcv *Raw) UnPackTo(t *RawT) { + valueLength := rcv.ValueLength() + t.Value = make([]int8, valueLength) + for j := 0; j < valueLength; j++ { + t.Value[j] = rcv.Value(j) + } +} + +func (rcv *Raw) UnPack() *RawT { + if rcv == nil { return nil } + t := &RawT{} + rcv.UnPackTo(t) + return t +} + type Raw struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/RealtimeConfig.go b/pkg/fbs/comm/datalayer/RealtimeConfig.go new file mode 100644 index 0000000..713bd0e --- /dev/null +++ b/pkg/fbs/comm/datalayer/RealtimeConfig.go @@ -0,0 +1,98 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type RealtimeConfigT struct { + DefaultInputAcessType AccessType + NTelBufConfig *NTelBufferConfigT +} + +func (t *RealtimeConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nTelBufConfigOffset := t.NTelBufConfig.Pack(builder) + RealtimeConfigStart(builder) + RealtimeConfigAddDefaultInputAcessType(builder, t.DefaultInputAcessType) + RealtimeConfigAddNTelBufConfig(builder, nTelBufConfigOffset) + return RealtimeConfigEnd(builder) +} + +func (rcv *RealtimeConfig) UnPackTo(t *RealtimeConfigT) { + t.DefaultInputAcessType = rcv.DefaultInputAcessType() + t.NTelBufConfig = rcv.NTelBufConfig(nil).UnPack() +} + +func (rcv *RealtimeConfig) UnPack() *RealtimeConfigT { + if rcv == nil { return nil } + t := &RealtimeConfigT{} + rcv.UnPackTo(t) + return t +} + +type RealtimeConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsRealtimeConfig(buf []byte, offset flatbuffers.UOffsetT) *RealtimeConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &RealtimeConfig{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsRealtimeConfig(buf []byte, offset flatbuffers.UOffsetT) *RealtimeConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &RealtimeConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *RealtimeConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *RealtimeConfig) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *RealtimeConfig) DefaultInputAcessType() AccessType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return AccessType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 2 +} + +func (rcv *RealtimeConfig) MutateDefaultInputAcessType(n AccessType) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func (rcv *RealtimeConfig) NTelBufConfig(obj *NTelBufferConfig) *NTelBufferConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(NTelBufferConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func RealtimeConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func RealtimeConfigAddDefaultInputAcessType(builder *flatbuffers.Builder, defaultInputAcessType AccessType) { + builder.PrependInt8Slot(0, int8(defaultInputAcessType), 2) +} +func RealtimeConfigAddNTelBufConfig(builder *flatbuffers.Builder, nTelBufConfig flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(nTelBufConfig), 0) +} +func RealtimeConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/Reference.go b/pkg/fbs/comm/datalayer/Reference.go index a71b515..1b32a60 100644 --- a/pkg/fbs/comm/datalayer/Reference.go +++ b/pkg/fbs/comm/datalayer/Reference.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ReferenceT struct { + Type string + TargetAddress string +} + +func (t *ReferenceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + typeOffset := builder.CreateString(t.Type) + targetAddressOffset := builder.CreateString(t.TargetAddress) + ReferenceStart(builder) + ReferenceAddType(builder, typeOffset) + ReferenceAddTargetAddress(builder, targetAddressOffset) + return ReferenceEnd(builder) +} + +func (rcv *Reference) UnPackTo(t *ReferenceT) { + t.Type = string(rcv.Type()) + t.TargetAddress = string(rcv.TargetAddress()) +} + +func (rcv *Reference) UnPack() *ReferenceT { + if rcv == nil { return nil } + t := &ReferenceT{} + rcv.UnPackTo(t) + return t +} + type Reference struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/RetainStats.go b/pkg/fbs/comm/datalayer/RetainStats.go index 8f0124c..98b10a2 100644 --- a/pkg/fbs/comm/datalayer/RetainStats.go +++ b/pkg/fbs/comm/datalayer/RetainStats.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type RetainStatsT struct { + Total uint32 + Free uint32 + Used uint32 + BiggestFree uint32 + SyncCounter uint32 + LastUsed uint32 + Info string +} + +func (t *RetainStatsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + infoOffset := builder.CreateString(t.Info) + RetainStatsStart(builder) + RetainStatsAddTotal(builder, t.Total) + RetainStatsAddFree(builder, t.Free) + RetainStatsAddUsed(builder, t.Used) + RetainStatsAddBiggestFree(builder, t.BiggestFree) + RetainStatsAddSyncCounter(builder, t.SyncCounter) + RetainStatsAddLastUsed(builder, t.LastUsed) + RetainStatsAddInfo(builder, infoOffset) + return RetainStatsEnd(builder) +} + +func (rcv *RetainStats) UnPackTo(t *RetainStatsT) { + t.Total = rcv.Total() + t.Free = rcv.Free() + t.Used = rcv.Used() + t.BiggestFree = rcv.BiggestFree() + t.SyncCounter = rcv.SyncCounter() + t.LastUsed = rcv.LastUsed() + t.Info = string(rcv.Info()) +} + +func (rcv *RetainStats) UnPack() *RetainStatsT { + if rcv == nil { return nil } + t := &RetainStatsT{} + rcv.UnPackTo(t) + return t +} + type RetainStats struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Sampling.go b/pkg/fbs/comm/datalayer/Sampling.go index ff88716..c0e2e11 100644 --- a/pkg/fbs/comm/datalayer/Sampling.go +++ b/pkg/fbs/comm/datalayer/Sampling.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SamplingT struct { + SamplingInterval uint64 +} + +func (t *SamplingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SamplingStart(builder) + SamplingAddSamplingInterval(builder, t.SamplingInterval) + return SamplingEnd(builder) +} + +func (rcv *Sampling) UnPackTo(t *SamplingT) { + t.SamplingInterval = rcv.SamplingInterval() +} + +func (rcv *Sampling) UnPack() *SamplingT { + if rcv == nil { return nil } + t := &SamplingT{} + rcv.UnPackTo(t) + return t +} + type Sampling struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Scope.go b/pkg/fbs/comm/datalayer/Scope.go index b6ab04c..32edb0f 100644 --- a/pkg/fbs/comm/datalayer/Scope.go +++ b/pkg/fbs/comm/datalayer/Scope.go @@ -6,6 +6,117 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ScopeT struct { + Identifier string + Name string + Description string + PermissionsR []string + PermissionsRW []string + PermissionsX []string + PermissionsRWX []string +} + +func (t *ScopeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + identifierOffset := builder.CreateString(t.Identifier) + nameOffset := builder.CreateString(t.Name) + descriptionOffset := builder.CreateString(t.Description) + permissionsROffset := flatbuffers.UOffsetT(0) + if t.PermissionsR != nil { + permissionsRLength := len(t.PermissionsR) + permissionsROffsets := make([]flatbuffers.UOffsetT, permissionsRLength) + for j := 0; j < permissionsRLength; j++ { + permissionsROffsets[j] = builder.CreateString(t.PermissionsR[j]) + } + ScopeStartPermissionsRVector(builder, permissionsRLength) + for j := permissionsRLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(permissionsROffsets[j]) + } + permissionsROffset = builder.EndVector(permissionsRLength) + } + permissionsRWOffset := flatbuffers.UOffsetT(0) + if t.PermissionsRW != nil { + permissionsRWLength := len(t.PermissionsRW) + permissionsRWOffsets := make([]flatbuffers.UOffsetT, permissionsRWLength) + for j := 0; j < permissionsRWLength; j++ { + permissionsRWOffsets[j] = builder.CreateString(t.PermissionsRW[j]) + } + ScopeStartPermissionsRWVector(builder, permissionsRWLength) + for j := permissionsRWLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(permissionsRWOffsets[j]) + } + permissionsRWOffset = builder.EndVector(permissionsRWLength) + } + permissionsXOffset := flatbuffers.UOffsetT(0) + if t.PermissionsX != nil { + permissionsXLength := len(t.PermissionsX) + permissionsXOffsets := make([]flatbuffers.UOffsetT, permissionsXLength) + for j := 0; j < permissionsXLength; j++ { + permissionsXOffsets[j] = builder.CreateString(t.PermissionsX[j]) + } + ScopeStartPermissionsXVector(builder, permissionsXLength) + for j := permissionsXLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(permissionsXOffsets[j]) + } + permissionsXOffset = builder.EndVector(permissionsXLength) + } + permissionsRWXOffset := flatbuffers.UOffsetT(0) + if t.PermissionsRWX != nil { + permissionsRWXLength := len(t.PermissionsRWX) + permissionsRWXOffsets := make([]flatbuffers.UOffsetT, permissionsRWXLength) + for j := 0; j < permissionsRWXLength; j++ { + permissionsRWXOffsets[j] = builder.CreateString(t.PermissionsRWX[j]) + } + ScopeStartPermissionsRWXVector(builder, permissionsRWXLength) + for j := permissionsRWXLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(permissionsRWXOffsets[j]) + } + permissionsRWXOffset = builder.EndVector(permissionsRWXLength) + } + ScopeStart(builder) + ScopeAddIdentifier(builder, identifierOffset) + ScopeAddName(builder, nameOffset) + ScopeAddDescription(builder, descriptionOffset) + ScopeAddPermissionsR(builder, permissionsROffset) + ScopeAddPermissionsRW(builder, permissionsRWOffset) + ScopeAddPermissionsX(builder, permissionsXOffset) + ScopeAddPermissionsRWX(builder, permissionsRWXOffset) + return ScopeEnd(builder) +} + +func (rcv *Scope) UnPackTo(t *ScopeT) { + t.Identifier = string(rcv.Identifier()) + t.Name = string(rcv.Name()) + t.Description = string(rcv.Description()) + permissionsRLength := rcv.PermissionsRLength() + t.PermissionsR = make([]string, permissionsRLength) + for j := 0; j < permissionsRLength; j++ { + t.PermissionsR[j] = string(rcv.PermissionsR(j)) + } + permissionsRWLength := rcv.PermissionsRWLength() + t.PermissionsRW = make([]string, permissionsRWLength) + for j := 0; j < permissionsRWLength; j++ { + t.PermissionsRW[j] = string(rcv.PermissionsRW(j)) + } + permissionsXLength := rcv.PermissionsXLength() + t.PermissionsX = make([]string, permissionsXLength) + for j := 0; j < permissionsXLength; j++ { + t.PermissionsX[j] = string(rcv.PermissionsX(j)) + } + permissionsRWXLength := rcv.PermissionsRWXLength() + t.PermissionsRWX = make([]string, permissionsRWXLength) + for j := 0; j < permissionsRWXLength; j++ { + t.PermissionsRWX[j] = string(rcv.PermissionsRWX(j)) + } +} + +func (rcv *Scope) UnPack() *ScopeT { + if rcv == nil { return nil } + t := &ScopeT{} + rcv.UnPackTo(t) + return t +} + type Scope struct { _tab flatbuffers.Table } @@ -57,7 +168,7 @@ func (rcv *Scope) Description() []byte { return nil } -func (rcv *Scope) PermissionStrings(j int) []byte { +func (rcv *Scope) PermissionsR(j int) []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { a := rcv._tab.Vector(o) @@ -66,7 +177,7 @@ func (rcv *Scope) PermissionStrings(j int) []byte { return nil } -func (rcv *Scope) PermissionStringsLength() int { +func (rcv *Scope) PermissionsRLength() int { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { return rcv._tab.VectorLen(o) @@ -74,8 +185,59 @@ func (rcv *Scope) PermissionStringsLength() int { return 0 } +func (rcv *Scope) PermissionsRW(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *Scope) PermissionsRWLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Scope) PermissionsX(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *Scope) PermissionsXLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Scope) PermissionsRWX(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *Scope) PermissionsRWXLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + func ScopeStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(7) } func ScopeAddIdentifier(builder *flatbuffers.Builder, identifier flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(identifier), 0) @@ -86,10 +248,28 @@ func ScopeAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { func ScopeAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(description), 0) } -func ScopeAddPermissionStrings(builder *flatbuffers.Builder, permissionStrings flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(permissionStrings), 0) +func ScopeAddPermissionsR(builder *flatbuffers.Builder, permissionsR flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(permissionsR), 0) +} +func ScopeStartPermissionsRVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ScopeAddPermissionsRW(builder *flatbuffers.Builder, permissionsRW flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(permissionsRW), 0) +} +func ScopeStartPermissionsRWVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ScopeAddPermissionsX(builder *flatbuffers.Builder, permissionsX flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(permissionsX), 0) +} +func ScopeStartPermissionsXVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ScopeAddPermissionsRWX(builder *flatbuffers.Builder, permissionsRWX flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(permissionsRWX), 0) } -func ScopeStartPermissionStringsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { +func ScopeStartPermissionsRWXVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } func ScopeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { diff --git a/pkg/fbs/comm/datalayer/Scopes.go b/pkg/fbs/comm/datalayer/Scopes.go index bceedb7..96b346d 100644 --- a/pkg/fbs/comm/datalayer/Scopes.go +++ b/pkg/fbs/comm/datalayer/Scopes.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ScopesT struct { + Scopes []*ScopeT +} + +func (t *ScopesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + scopesOffset := flatbuffers.UOffsetT(0) + if t.Scopes != nil { + scopesLength := len(t.Scopes) + scopesOffsets := make([]flatbuffers.UOffsetT, scopesLength) + for j := 0; j < scopesLength; j++ { + scopesOffsets[j] = t.Scopes[j].Pack(builder) + } + ScopesStartScopesVector(builder, scopesLength) + for j := scopesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(scopesOffsets[j]) + } + scopesOffset = builder.EndVector(scopesLength) + } + ScopesStart(builder) + ScopesAddScopes(builder, scopesOffset) + return ScopesEnd(builder) +} + +func (rcv *Scopes) UnPackTo(t *ScopesT) { + scopesLength := rcv.ScopesLength() + t.Scopes = make([]*ScopeT, scopesLength) + for j := 0; j < scopesLength; j++ { + x := Scope{} + rcv.Scopes(&x, j) + t.Scopes[j] = x.UnPack() + } +} + +func (rcv *Scopes) UnPack() *ScopesT { + if rcv == nil { return nil } + t := &ScopesT{} + rcv.UnPackTo(t) + return t +} + type Scopes struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/ServerSettings.go b/pkg/fbs/comm/datalayer/ServerSettings.go index 795cd60..9fe0afd 100644 --- a/pkg/fbs/comm/datalayer/ServerSettings.go +++ b/pkg/fbs/comm/datalayer/ServerSettings.go @@ -6,6 +6,34 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ServerSettingsT struct { + ServerIdlePingTimeout uint32 + ServerWaitResponseTimeout uint32 + ServerMaxMessageSize uint32 +} + +func (t *ServerSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ServerSettingsStart(builder) + ServerSettingsAddServerIdlePingTimeout(builder, t.ServerIdlePingTimeout) + ServerSettingsAddServerWaitResponseTimeout(builder, t.ServerWaitResponseTimeout) + ServerSettingsAddServerMaxMessageSize(builder, t.ServerMaxMessageSize) + return ServerSettingsEnd(builder) +} + +func (rcv *ServerSettings) UnPackTo(t *ServerSettingsT) { + t.ServerIdlePingTimeout = rcv.ServerIdlePingTimeout() + t.ServerWaitResponseTimeout = rcv.ServerWaitResponseTimeout() + t.ServerMaxMessageSize = rcv.ServerMaxMessageSize() +} + +func (rcv *ServerSettings) UnPack() *ServerSettingsT { + if rcv == nil { return nil } + t := &ServerSettingsT{} + rcv.UnPackTo(t) + return t +} + type ServerSettings struct { _tab flatbuffers.Table } @@ -57,8 +85,20 @@ func (rcv *ServerSettings) MutateServerWaitResponseTimeout(n uint32) bool { return rcv._tab.MutateUint32Slot(6, n) } +func (rcv *ServerSettings) ServerMaxMessageSize() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 52428800 +} + +func (rcv *ServerSettings) MutateServerMaxMessageSize(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + func ServerSettingsStart(builder *flatbuffers.Builder) { - builder.StartObject(2) + builder.StartObject(3) } func ServerSettingsAddServerIdlePingTimeout(builder *flatbuffers.Builder, serverIdlePingTimeout uint32) { builder.PrependUint32Slot(0, serverIdlePingTimeout, 30000) @@ -66,6 +106,9 @@ func ServerSettingsAddServerIdlePingTimeout(builder *flatbuffers.Builder, server func ServerSettingsAddServerWaitResponseTimeout(builder *flatbuffers.Builder, serverWaitResponseTimeout uint32) { builder.PrependUint32Slot(1, serverWaitResponseTimeout, 3000) } +func ServerSettingsAddServerMaxMessageSize(builder *flatbuffers.Builder, serverMaxMessageSize uint32) { + builder.PrependUint32Slot(2, serverMaxMessageSize, 52428800) +} func ServerSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/String.go b/pkg/fbs/comm/datalayer/String.go index 392ef23..2f538a7 100644 --- a/pkg/fbs/comm/datalayer/String.go +++ b/pkg/fbs/comm/datalayer/String.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type StringT struct { + Value string +} + +func (t *StringT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := builder.CreateString(t.Value) + StringStart(builder) + StringAddValue(builder, valueOffset) + return StringEnd(builder) +} + +func (rcv *String) UnPackTo(t *StringT) { + t.Value = string(rcv.Value()) +} + +func (rcv *String) UnPack() *StringT { + if rcv == nil { return nil } + t := &StringT{} + rcv.UnPackTo(t) + return t +} + type String struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/SubscriptionData.go b/pkg/fbs/comm/datalayer/SubscriptionData.go index f66901c..0ce880c 100644 --- a/pkg/fbs/comm/datalayer/SubscriptionData.go +++ b/pkg/fbs/comm/datalayer/SubscriptionData.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SubscriptionDataT struct { + Properties *SubscriptionPropertiesT + Nodes []string +} + +func (t *SubscriptionDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + propertiesOffset := t.Properties.Pack(builder) + nodesOffset := flatbuffers.UOffsetT(0) + if t.Nodes != nil { + nodesLength := len(t.Nodes) + nodesOffsets := make([]flatbuffers.UOffsetT, nodesLength) + for j := 0; j < nodesLength; j++ { + nodesOffsets[j] = builder.CreateString(t.Nodes[j]) + } + SubscriptionDataStartNodesVector(builder, nodesLength) + for j := nodesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(nodesOffsets[j]) + } + nodesOffset = builder.EndVector(nodesLength) + } + SubscriptionDataStart(builder) + SubscriptionDataAddProperties(builder, propertiesOffset) + SubscriptionDataAddNodes(builder, nodesOffset) + return SubscriptionDataEnd(builder) +} + +func (rcv *SubscriptionData) UnPackTo(t *SubscriptionDataT) { + t.Properties = rcv.Properties(nil).UnPack() + nodesLength := rcv.NodesLength() + t.Nodes = make([]string, nodesLength) + for j := 0; j < nodesLength; j++ { + t.Nodes[j] = string(rcv.Nodes(j)) + } +} + +func (rcv *SubscriptionData) UnPack() *SubscriptionDataT { + if rcv == nil { return nil } + t := &SubscriptionDataT{} + rcv.UnPackTo(t) + return t +} + type SubscriptionData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/SubscriptionProperties.go b/pkg/fbs/comm/datalayer/SubscriptionProperties.go index 6429244..651c9a8 100644 --- a/pkg/fbs/comm/datalayer/SubscriptionProperties.go +++ b/pkg/fbs/comm/datalayer/SubscriptionProperties.go @@ -6,6 +6,60 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SubscriptionPropertiesT struct { + Id string + KeepaliveInterval uint32 + PublishInterval uint32 + Rules []*PropertyT + ErrorInterval uint32 +} + +func (t *SubscriptionPropertiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idOffset := builder.CreateString(t.Id) + rulesOffset := flatbuffers.UOffsetT(0) + if t.Rules != nil { + rulesLength := len(t.Rules) + rulesOffsets := make([]flatbuffers.UOffsetT, rulesLength) + for j := 0; j < rulesLength; j++ { + rulesOffsets[j] = t.Rules[j].Pack(builder) + } + SubscriptionPropertiesStartRulesVector(builder, rulesLength) + for j := rulesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(rulesOffsets[j]) + } + rulesOffset = builder.EndVector(rulesLength) + } + SubscriptionPropertiesStart(builder) + SubscriptionPropertiesAddId(builder, idOffset) + SubscriptionPropertiesAddKeepaliveInterval(builder, t.KeepaliveInterval) + SubscriptionPropertiesAddPublishInterval(builder, t.PublishInterval) + SubscriptionPropertiesAddRules(builder, rulesOffset) + SubscriptionPropertiesAddErrorInterval(builder, t.ErrorInterval) + return SubscriptionPropertiesEnd(builder) +} + +func (rcv *SubscriptionProperties) UnPackTo(t *SubscriptionPropertiesT) { + t.Id = string(rcv.Id()) + t.KeepaliveInterval = rcv.KeepaliveInterval() + t.PublishInterval = rcv.PublishInterval() + rulesLength := rcv.RulesLength() + t.Rules = make([]*PropertyT, rulesLength) + for j := 0; j < rulesLength; j++ { + x := Property{} + rcv.Rules(&x, j) + t.Rules[j] = x.UnPack() + } + t.ErrorInterval = rcv.ErrorInterval() +} + +func (rcv *SubscriptionProperties) UnPack() *SubscriptionPropertiesT { + if rcv == nil { return nil } + t := &SubscriptionPropertiesT{} + rcv.UnPackTo(t) + return t +} + type SubscriptionProperties struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/SubscriptionSettings.go b/pkg/fbs/comm/datalayer/SubscriptionSettings.go index acb3079..86d95b9 100644 --- a/pkg/fbs/comm/datalayer/SubscriptionSettings.go +++ b/pkg/fbs/comm/datalayer/SubscriptionSettings.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SubscriptionSettingsT struct { + MinimumPublishInterval uint32 + MinimumSampleInterval uint64 + MaximumBufferSize uint32 + MinimumErrorInterval uint32 +} + +func (t *SubscriptionSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SubscriptionSettingsStart(builder) + SubscriptionSettingsAddMinimumPublishInterval(builder, t.MinimumPublishInterval) + SubscriptionSettingsAddMinimumSampleInterval(builder, t.MinimumSampleInterval) + SubscriptionSettingsAddMaximumBufferSize(builder, t.MaximumBufferSize) + SubscriptionSettingsAddMinimumErrorInterval(builder, t.MinimumErrorInterval) + return SubscriptionSettingsEnd(builder) +} + +func (rcv *SubscriptionSettings) UnPackTo(t *SubscriptionSettingsT) { + t.MinimumPublishInterval = rcv.MinimumPublishInterval() + t.MinimumSampleInterval = rcv.MinimumSampleInterval() + t.MaximumBufferSize = rcv.MaximumBufferSize() + t.MinimumErrorInterval = rcv.MinimumErrorInterval() +} + +func (rcv *SubscriptionSettings) UnPack() *SubscriptionSettingsT { + if rcv == nil { return nil } + t := &SubscriptionSettingsT{} + rcv.UnPackTo(t) + return t +} + type SubscriptionSettings struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Timestamp.go b/pkg/fbs/comm/datalayer/Timestamp.go new file mode 100644 index 0000000..4a9e3e5 --- /dev/null +++ b/pkg/fbs/comm/datalayer/Timestamp.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TimestampT struct { + Value uint64 +} + +func (t *TimestampT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TimestampStart(builder) + TimestampAddValue(builder, t.Value) + return TimestampEnd(builder) +} + +func (rcv *Timestamp) UnPackTo(t *TimestampT) { + t.Value = rcv.Value() +} + +func (rcv *Timestamp) UnPack() *TimestampT { + if rcv == nil { return nil } + t := &TimestampT{} + rcv.UnPackTo(t) + return t +} + +type Timestamp struct { + _tab flatbuffers.Table +} + +func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Timestamp{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Timestamp{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Timestamp) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Timestamp) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Timestamp) Value() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Timestamp) MutateValue(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func TimestampStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TimestampAddValue(builder *flatbuffers.Builder, value uint64) { + builder.PrependUint64Slot(0, value, 0) +} +func TimestampEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/Token.go b/pkg/fbs/comm/datalayer/Token.go index b4c1b0b..35f8bd1 100644 --- a/pkg/fbs/comm/datalayer/Token.go +++ b/pkg/fbs/comm/datalayer/Token.go @@ -6,6 +6,84 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TokenT struct { + Claims []*ClaimT + Id string + Iat uint64 + Exp uint64 + Name string + Plchandle uint64 + Scope []string +} + +func (t *TokenT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + claimsOffset := flatbuffers.UOffsetT(0) + if t.Claims != nil { + claimsLength := len(t.Claims) + claimsOffsets := make([]flatbuffers.UOffsetT, claimsLength) + for j := 0; j < claimsLength; j++ { + claimsOffsets[j] = t.Claims[j].Pack(builder) + } + TokenStartClaimsVector(builder, claimsLength) + for j := claimsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(claimsOffsets[j]) + } + claimsOffset = builder.EndVector(claimsLength) + } + idOffset := builder.CreateString(t.Id) + nameOffset := builder.CreateString(t.Name) + scopeOffset := flatbuffers.UOffsetT(0) + if t.Scope != nil { + scopeLength := len(t.Scope) + scopeOffsets := make([]flatbuffers.UOffsetT, scopeLength) + for j := 0; j < scopeLength; j++ { + scopeOffsets[j] = builder.CreateString(t.Scope[j]) + } + TokenStartScopeVector(builder, scopeLength) + for j := scopeLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(scopeOffsets[j]) + } + scopeOffset = builder.EndVector(scopeLength) + } + TokenStart(builder) + TokenAddClaims(builder, claimsOffset) + TokenAddId(builder, idOffset) + TokenAddIat(builder, t.Iat) + TokenAddExp(builder, t.Exp) + TokenAddName(builder, nameOffset) + TokenAddPlchandle(builder, t.Plchandle) + TokenAddScope(builder, scopeOffset) + return TokenEnd(builder) +} + +func (rcv *Token) UnPackTo(t *TokenT) { + claimsLength := rcv.ClaimsLength() + t.Claims = make([]*ClaimT, claimsLength) + for j := 0; j < claimsLength; j++ { + x := Claim{} + rcv.Claims(&x, j) + t.Claims[j] = x.UnPack() + } + t.Id = string(rcv.Id()) + t.Iat = rcv.Iat() + t.Exp = rcv.Exp() + t.Name = string(rcv.Name()) + t.Plchandle = rcv.Plchandle() + scopeLength := rcv.ScopeLength() + t.Scope = make([]string, scopeLength) + for j := 0; j < scopeLength; j++ { + t.Scope[j] = string(rcv.Scope(j)) + } +} + +func (rcv *Token) UnPack() *TokenT { + if rcv == nil { return nil } + t := &TokenT{} + rcv.UnPackTo(t) + return t +} + type Token struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/UInt16.go b/pkg/fbs/comm/datalayer/UInt16.go index a02a270..9481262 100644 --- a/pkg/fbs/comm/datalayer/UInt16.go +++ b/pkg/fbs/comm/datalayer/UInt16.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UInt16T struct { + Value uint16 +} + +func (t *UInt16T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt16Start(builder) + UInt16AddValue(builder, t.Value) + return UInt16End(builder) +} + +func (rcv *UInt16) UnPackTo(t *UInt16T) { + t.Value = rcv.Value() +} + +func (rcv *UInt16) UnPack() *UInt16T { + if rcv == nil { return nil } + t := &UInt16T{} + rcv.UnPackTo(t) + return t +} + type UInt16 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/UInt32.go b/pkg/fbs/comm/datalayer/UInt32.go index 50b5803..284886b 100644 --- a/pkg/fbs/comm/datalayer/UInt32.go +++ b/pkg/fbs/comm/datalayer/UInt32.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UInt32T struct { + Value uint32 +} + +func (t *UInt32T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt32Start(builder) + UInt32AddValue(builder, t.Value) + return UInt32End(builder) +} + +func (rcv *UInt32) UnPackTo(t *UInt32T) { + t.Value = rcv.Value() +} + +func (rcv *UInt32) UnPack() *UInt32T { + if rcv == nil { return nil } + t := &UInt32T{} + rcv.UnPackTo(t) + return t +} + type UInt32 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/UInt64.go b/pkg/fbs/comm/datalayer/UInt64.go index d5524da..8369009 100644 --- a/pkg/fbs/comm/datalayer/UInt64.go +++ b/pkg/fbs/comm/datalayer/UInt64.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UInt64T struct { + Value uint64 +} + +func (t *UInt64T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt64Start(builder) + UInt64AddValue(builder, t.Value) + return UInt64End(builder) +} + +func (rcv *UInt64) UnPackTo(t *UInt64T) { + t.Value = rcv.Value() +} + +func (rcv *UInt64) UnPack() *UInt64T { + if rcv == nil { return nil } + t := &UInt64T{} + rcv.UnPackTo(t) + return t +} + type UInt64 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/UInt8.go b/pkg/fbs/comm/datalayer/UInt8.go index f0427aa..5202120 100644 --- a/pkg/fbs/comm/datalayer/UInt8.go +++ b/pkg/fbs/comm/datalayer/UInt8.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UInt8T struct { + Value byte +} + +func (t *UInt8T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt8Start(builder) + UInt8AddValue(builder, t.Value) + return UInt8End(builder) +} + +func (rcv *UInt8) UnPackTo(t *UInt8T) { + t.Value = rcv.Value() +} + +func (rcv *UInt8) UnPack() *UInt8T { + if rcv == nil { return nil } + t := &UInt8T{} + rcv.UnPackTo(t) + return t +} + type UInt8 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Variable.go b/pkg/fbs/comm/datalayer/Variable.go index 8b78c78..4b490b9 100644 --- a/pkg/fbs/comm/datalayer/Variable.go +++ b/pkg/fbs/comm/datalayer/Variable.go @@ -6,6 +6,39 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type VariableT struct { + Name string + Bitoffset uint32 + Bitsize uint32 + Type string +} + +func (t *VariableT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + typeOffset := builder.CreateString(t.Type) + VariableStart(builder) + VariableAddName(builder, nameOffset) + VariableAddBitoffset(builder, t.Bitoffset) + VariableAddBitsize(builder, t.Bitsize) + VariableAddType(builder, typeOffset) + return VariableEnd(builder) +} + +func (rcv *Variable) UnPackTo(t *VariableT) { + t.Name = string(rcv.Name()) + t.Bitoffset = rcv.Bitoffset() + t.Bitsize = rcv.Bitsize() + t.Type = string(rcv.Type()) +} + +func (rcv *Variable) UnPack() *VariableT { + if rcv == nil { return nil } + t := &VariableT{} + rcv.UnPackTo(t) + return t +} + type Variable struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Watchlist.go b/pkg/fbs/comm/datalayer/Watchlist.go index 18211e3..fb88757 100644 --- a/pkg/fbs/comm/datalayer/Watchlist.go +++ b/pkg/fbs/comm/datalayer/Watchlist.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type WatchlistT struct { + Name string + Items []string +} + +func (t *WatchlistT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + itemsOffset := flatbuffers.UOffsetT(0) + if t.Items != nil { + itemsLength := len(t.Items) + itemsOffsets := make([]flatbuffers.UOffsetT, itemsLength) + for j := 0; j < itemsLength; j++ { + itemsOffsets[j] = builder.CreateString(t.Items[j]) + } + WatchlistStartItemsVector(builder, itemsLength) + for j := itemsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(itemsOffsets[j]) + } + itemsOffset = builder.EndVector(itemsLength) + } + WatchlistStart(builder) + WatchlistAddName(builder, nameOffset) + WatchlistAddItems(builder, itemsOffset) + return WatchlistEnd(builder) +} + +func (rcv *Watchlist) UnPackTo(t *WatchlistT) { + t.Name = string(rcv.Name()) + itemsLength := rcv.ItemsLength() + t.Items = make([]string, itemsLength) + for j := 0; j < itemsLength; j++ { + t.Items[j] = string(rcv.Items(j)) + } +} + +func (rcv *Watchlist) UnPack() *WatchlistT { + if rcv == nil { return nil } + t := &WatchlistT{} + rcv.UnPackTo(t) + return t +} + type Watchlist struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/Watchlists.go b/pkg/fbs/comm/datalayer/Watchlists.go index a1ee52c..3fbe122 100644 --- a/pkg/fbs/comm/datalayer/Watchlists.go +++ b/pkg/fbs/comm/datalayer/Watchlists.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type WatchlistsT struct { + Watchlists []*WatchlistT +} + +func (t *WatchlistsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + watchlistsOffset := flatbuffers.UOffsetT(0) + if t.Watchlists != nil { + watchlistsLength := len(t.Watchlists) + watchlistsOffsets := make([]flatbuffers.UOffsetT, watchlistsLength) + for j := 0; j < watchlistsLength; j++ { + watchlistsOffsets[j] = t.Watchlists[j].Pack(builder) + } + WatchlistsStartWatchlistsVector(builder, watchlistsLength) + for j := watchlistsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(watchlistsOffsets[j]) + } + watchlistsOffset = builder.EndVector(watchlistsLength) + } + WatchlistsStart(builder) + WatchlistsAddWatchlists(builder, watchlistsOffset) + return WatchlistsEnd(builder) +} + +func (rcv *Watchlists) UnPackTo(t *WatchlistsT) { + watchlistsLength := rcv.WatchlistsLength() + t.Watchlists = make([]*WatchlistT, watchlistsLength) + for j := 0; j < watchlistsLength; j++ { + x := Watchlist{} + rcv.Watchlists(&x, j) + t.Watchlists[j] = x.UnPack() + } +} + +func (rcv *Watchlists) UnPack() *WatchlistsT { + if rcv == nil { return nil } + t := &WatchlistsT{} + rcv.UnPackTo(t) + return t +} + type Watchlists struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Bundle.go b/pkg/fbs/comm/datalayer/framework/Bundle.go index 193d6ed..5b19f0d 100644 --- a/pkg/fbs/comm/datalayer/framework/Bundle.go +++ b/pkg/fbs/comm/datalayer/framework/Bundle.go @@ -6,6 +6,72 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type BundleT struct { + Name string + Version string + Location string + Id int64 + Components []*ComponentT + State string + Active bool + Installed bool +} + +func (t *BundleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + locationOffset := builder.CreateString(t.Location) + componentsOffset := flatbuffers.UOffsetT(0) + if t.Components != nil { + componentsLength := len(t.Components) + componentsOffsets := make([]flatbuffers.UOffsetT, componentsLength) + for j := 0; j < componentsLength; j++ { + componentsOffsets[j] = t.Components[j].Pack(builder) + } + BundleStartComponentsVector(builder, componentsLength) + for j := componentsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(componentsOffsets[j]) + } + componentsOffset = builder.EndVector(componentsLength) + } + stateOffset := builder.CreateString(t.State) + BundleStart(builder) + BundleAddName(builder, nameOffset) + BundleAddVersion(builder, versionOffset) + BundleAddLocation(builder, locationOffset) + BundleAddId(builder, t.Id) + BundleAddComponents(builder, componentsOffset) + BundleAddState(builder, stateOffset) + BundleAddActive(builder, t.Active) + BundleAddInstalled(builder, t.Installed) + return BundleEnd(builder) +} + +func (rcv *Bundle) UnPackTo(t *BundleT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) + t.Location = string(rcv.Location()) + t.Id = rcv.Id() + componentsLength := rcv.ComponentsLength() + t.Components = make([]*ComponentT, componentsLength) + for j := 0; j < componentsLength; j++ { + x := Component{} + rcv.Components(&x, j) + t.Components[j] = x.UnPack() + } + t.State = string(rcv.State()) + t.Active = rcv.Active() + t.Installed = rcv.Installed() +} + +func (rcv *Bundle) UnPack() *BundleT { + if rcv == nil { return nil } + t := &BundleT{} + rcv.UnPackTo(t) + return t +} + type Bundle struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/BundleList.go b/pkg/fbs/comm/datalayer/framework/BundleList.go index c83f5a7..4f80e8e 100644 --- a/pkg/fbs/comm/datalayer/framework/BundleList.go +++ b/pkg/fbs/comm/datalayer/framework/BundleList.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type BundleListT struct { + Bundles []*BundleT +} + +func (t *BundleListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + bundlesOffset := flatbuffers.UOffsetT(0) + if t.Bundles != nil { + bundlesLength := len(t.Bundles) + bundlesOffsets := make([]flatbuffers.UOffsetT, bundlesLength) + for j := 0; j < bundlesLength; j++ { + bundlesOffsets[j] = t.Bundles[j].Pack(builder) + } + BundleListStartBundlesVector(builder, bundlesLength) + for j := bundlesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(bundlesOffsets[j]) + } + bundlesOffset = builder.EndVector(bundlesLength) + } + BundleListStart(builder) + BundleListAddBundles(builder, bundlesOffset) + return BundleListEnd(builder) +} + +func (rcv *BundleList) UnPackTo(t *BundleListT) { + bundlesLength := rcv.BundlesLength() + t.Bundles = make([]*BundleT, bundlesLength) + for j := 0; j < bundlesLength; j++ { + x := Bundle{} + rcv.Bundles(&x, j) + t.Bundles[j] = x.UnPack() + } +} + +func (rcv *BundleList) UnPack() *BundleListT { + if rcv == nil { return nil } + t := &BundleListT{} + rcv.UnPackTo(t) + return t +} + type BundleList struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Component.go b/pkg/fbs/comm/datalayer/framework/Component.go index 965bbef..0c5fa9e 100644 --- a/pkg/fbs/comm/datalayer/framework/Component.go +++ b/pkg/fbs/comm/datalayer/framework/Component.go @@ -6,6 +6,84 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ComponentT struct { + Name string + Id string + Active bool + State string + Interfaces []*Interface_T + Dependencies []*DependencyT +} + +func (t *ComponentT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + idOffset := builder.CreateString(t.Id) + stateOffset := builder.CreateString(t.State) + interfacesOffset := flatbuffers.UOffsetT(0) + if t.Interfaces != nil { + interfacesLength := len(t.Interfaces) + interfacesOffsets := make([]flatbuffers.UOffsetT, interfacesLength) + for j := 0; j < interfacesLength; j++ { + interfacesOffsets[j] = t.Interfaces[j].Pack(builder) + } + ComponentStartInterfacesVector(builder, interfacesLength) + for j := interfacesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(interfacesOffsets[j]) + } + interfacesOffset = builder.EndVector(interfacesLength) + } + dependenciesOffset := flatbuffers.UOffsetT(0) + if t.Dependencies != nil { + dependenciesLength := len(t.Dependencies) + dependenciesOffsets := make([]flatbuffers.UOffsetT, dependenciesLength) + for j := 0; j < dependenciesLength; j++ { + dependenciesOffsets[j] = t.Dependencies[j].Pack(builder) + } + ComponentStartDependenciesVector(builder, dependenciesLength) + for j := dependenciesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(dependenciesOffsets[j]) + } + dependenciesOffset = builder.EndVector(dependenciesLength) + } + ComponentStart(builder) + ComponentAddName(builder, nameOffset) + ComponentAddId(builder, idOffset) + ComponentAddActive(builder, t.Active) + ComponentAddState(builder, stateOffset) + ComponentAddInterfaces(builder, interfacesOffset) + ComponentAddDependencies(builder, dependenciesOffset) + return ComponentEnd(builder) +} + +func (rcv *Component) UnPackTo(t *ComponentT) { + t.Name = string(rcv.Name()) + t.Id = string(rcv.Id()) + t.Active = rcv.Active() + t.State = string(rcv.State()) + interfacesLength := rcv.InterfacesLength() + t.Interfaces = make([]*Interface_T, interfacesLength) + for j := 0; j < interfacesLength; j++ { + x := Interface_{} + rcv.Interfaces(&x, j) + t.Interfaces[j] = x.UnPack() + } + dependenciesLength := rcv.DependenciesLength() + t.Dependencies = make([]*DependencyT, dependenciesLength) + for j := 0; j < dependenciesLength; j++ { + x := Dependency{} + rcv.Dependencies(&x, j) + t.Dependencies[j] = x.UnPack() + } +} + +func (rcv *Component) UnPack() *ComponentT { + if rcv == nil { return nil } + t := &ComponentT{} + rcv.UnPackTo(t) + return t +} + type Component struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/ComponentList.go b/pkg/fbs/comm/datalayer/framework/ComponentList.go index 1fb986f..57551ad 100644 --- a/pkg/fbs/comm/datalayer/framework/ComponentList.go +++ b/pkg/fbs/comm/datalayer/framework/ComponentList.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ComponentListT struct { + Components []*ComponentT +} + +func (t *ComponentListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + componentsOffset := flatbuffers.UOffsetT(0) + if t.Components != nil { + componentsLength := len(t.Components) + componentsOffsets := make([]flatbuffers.UOffsetT, componentsLength) + for j := 0; j < componentsLength; j++ { + componentsOffsets[j] = t.Components[j].Pack(builder) + } + ComponentListStartComponentsVector(builder, componentsLength) + for j := componentsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(componentsOffsets[j]) + } + componentsOffset = builder.EndVector(componentsLength) + } + ComponentListStart(builder) + ComponentListAddComponents(builder, componentsOffset) + return ComponentListEnd(builder) +} + +func (rcv *ComponentList) UnPackTo(t *ComponentListT) { + componentsLength := rcv.ComponentsLength() + t.Components = make([]*ComponentT, componentsLength) + for j := 0; j < componentsLength; j++ { + x := Component{} + rcv.Components(&x, j) + t.Components[j] = x.UnPack() + } +} + +func (rcv *ComponentList) UnPack() *ComponentListT { + if rcv == nil { return nil } + t := &ComponentListT{} + rcv.UnPackTo(t) + return t +} + type ComponentList struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Dependency.go b/pkg/fbs/comm/datalayer/framework/Dependency.go index b421ac7..25d98fa 100644 --- a/pkg/fbs/comm/datalayer/framework/Dependency.go +++ b/pkg/fbs/comm/datalayer/framework/Dependency.go @@ -6,6 +6,39 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DependencyT struct { + Name string + Available bool + Required bool + Filter string +} + +func (t *DependencyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + filterOffset := builder.CreateString(t.Filter) + DependencyStart(builder) + DependencyAddName(builder, nameOffset) + DependencyAddAvailable(builder, t.Available) + DependencyAddRequired(builder, t.Required) + DependencyAddFilter(builder, filterOffset) + return DependencyEnd(builder) +} + +func (rcv *Dependency) UnPackTo(t *DependencyT) { + t.Name = string(rcv.Name()) + t.Available = rcv.Available() + t.Required = rcv.Required() + t.Filter = string(rcv.Filter()) +} + +func (rcv *Dependency) UnPack() *DependencyT { + if rcv == nil { return nil } + t := &DependencyT{} + rcv.UnPackTo(t) + return t +} + type Dependency struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/DependencyList.go b/pkg/fbs/comm/datalayer/framework/DependencyList.go index 32d825b..1ce8a04 100644 --- a/pkg/fbs/comm/datalayer/framework/DependencyList.go +++ b/pkg/fbs/comm/datalayer/framework/DependencyList.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DependencyListT struct { + Dependencies []*DependencyT +} + +func (t *DependencyListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dependenciesOffset := flatbuffers.UOffsetT(0) + if t.Dependencies != nil { + dependenciesLength := len(t.Dependencies) + dependenciesOffsets := make([]flatbuffers.UOffsetT, dependenciesLength) + for j := 0; j < dependenciesLength; j++ { + dependenciesOffsets[j] = t.Dependencies[j].Pack(builder) + } + DependencyListStartDependenciesVector(builder, dependenciesLength) + for j := dependenciesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(dependenciesOffsets[j]) + } + dependenciesOffset = builder.EndVector(dependenciesLength) + } + DependencyListStart(builder) + DependencyListAddDependencies(builder, dependenciesOffset) + return DependencyListEnd(builder) +} + +func (rcv *DependencyList) UnPackTo(t *DependencyListT) { + dependenciesLength := rcv.DependenciesLength() + t.Dependencies = make([]*DependencyT, dependenciesLength) + for j := 0; j < dependenciesLength; j++ { + x := Dependency{} + rcv.Dependencies(&x, j) + t.Dependencies[j] = x.UnPack() + } +} + +func (rcv *DependencyList) UnPack() *DependencyListT { + if rcv == nil { return nil } + t := &DependencyListT{} + rcv.UnPackTo(t) + return t +} + type DependencyList struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Exception.go b/pkg/fbs/comm/datalayer/framework/Exception.go new file mode 100644 index 0000000..f2a8159 --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/Exception.go @@ -0,0 +1,188 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ExceptionT struct { + Date string + Name string + Signal string + Code string + Register *RegisterT + Stack []*StackentryT +} + +func (t *ExceptionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dateOffset := builder.CreateString(t.Date) + nameOffset := builder.CreateString(t.Name) + signalOffset := builder.CreateString(t.Signal) + codeOffset := builder.CreateString(t.Code) + registerOffset := t.Register.Pack(builder) + stackOffset := flatbuffers.UOffsetT(0) + if t.Stack != nil { + stackLength := len(t.Stack) + stackOffsets := make([]flatbuffers.UOffsetT, stackLength) + for j := 0; j < stackLength; j++ { + stackOffsets[j] = t.Stack[j].Pack(builder) + } + ExceptionStartStackVector(builder, stackLength) + for j := stackLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(stackOffsets[j]) + } + stackOffset = builder.EndVector(stackLength) + } + ExceptionStart(builder) + ExceptionAddDate(builder, dateOffset) + ExceptionAddName(builder, nameOffset) + ExceptionAddSignal(builder, signalOffset) + ExceptionAddCode(builder, codeOffset) + ExceptionAddRegister(builder, registerOffset) + ExceptionAddStack(builder, stackOffset) + return ExceptionEnd(builder) +} + +func (rcv *Exception) UnPackTo(t *ExceptionT) { + t.Date = string(rcv.Date()) + t.Name = string(rcv.Name()) + t.Signal = string(rcv.Signal()) + t.Code = string(rcv.Code()) + t.Register = rcv.Register(nil).UnPack() + stackLength := rcv.StackLength() + t.Stack = make([]*StackentryT, stackLength) + for j := 0; j < stackLength; j++ { + x := Stackentry{} + rcv.Stack(&x, j) + t.Stack[j] = x.UnPack() + } +} + +func (rcv *Exception) UnPack() *ExceptionT { + if rcv == nil { return nil } + t := &ExceptionT{} + rcv.UnPackTo(t) + return t +} + +type Exception struct { + _tab flatbuffers.Table +} + +func GetRootAsException(buf []byte, offset flatbuffers.UOffsetT) *Exception { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Exception{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsException(buf []byte, offset flatbuffers.UOffsetT) *Exception { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Exception{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Exception) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Exception) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Exception) Date() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Exception) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Exception) Signal() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Exception) Code() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Exception) Register(obj *Register) *Register { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Register) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Exception) Stack(obj *Stackentry, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + 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 *Exception) StackLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ExceptionStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func ExceptionAddDate(builder *flatbuffers.Builder, date flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(date), 0) +} +func ExceptionAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0) +} +func ExceptionAddSignal(builder *flatbuffers.Builder, signal flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(signal), 0) +} +func ExceptionAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(code), 0) +} +func ExceptionAddRegister(builder *flatbuffers.Builder, register flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(register), 0) +} +func ExceptionAddStack(builder *flatbuffers.Builder, stack flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(stack), 0) +} +func ExceptionStartStackVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ExceptionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/framework/Exceptions.go b/pkg/fbs/comm/datalayer/framework/Exceptions.go new file mode 100644 index 0000000..b9921e2 --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/Exceptions.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ExceptionsT struct { + Exceptions []*ExceptionT +} + +func (t *ExceptionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + exceptionsOffset := flatbuffers.UOffsetT(0) + if t.Exceptions != nil { + exceptionsLength := len(t.Exceptions) + exceptionsOffsets := make([]flatbuffers.UOffsetT, exceptionsLength) + for j := 0; j < exceptionsLength; j++ { + exceptionsOffsets[j] = t.Exceptions[j].Pack(builder) + } + ExceptionsStartExceptionsVector(builder, exceptionsLength) + for j := exceptionsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(exceptionsOffsets[j]) + } + exceptionsOffset = builder.EndVector(exceptionsLength) + } + ExceptionsStart(builder) + ExceptionsAddExceptions(builder, exceptionsOffset) + return ExceptionsEnd(builder) +} + +func (rcv *Exceptions) UnPackTo(t *ExceptionsT) { + exceptionsLength := rcv.ExceptionsLength() + t.Exceptions = make([]*ExceptionT, exceptionsLength) + for j := 0; j < exceptionsLength; j++ { + x := Exception{} + rcv.Exceptions(&x, j) + t.Exceptions[j] = x.UnPack() + } +} + +func (rcv *Exceptions) UnPack() *ExceptionsT { + if rcv == nil { return nil } + t := &ExceptionsT{} + rcv.UnPackTo(t) + return t +} + +type Exceptions struct { + _tab flatbuffers.Table +} + +func GetRootAsExceptions(buf []byte, offset flatbuffers.UOffsetT) *Exceptions { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Exceptions{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsExceptions(buf []byte, offset flatbuffers.UOffsetT) *Exceptions { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Exceptions{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Exceptions) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Exceptions) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Exceptions) Exceptions(obj *Exception, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *Exceptions) ExceptionsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ExceptionsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ExceptionsAddExceptions(builder *flatbuffers.Builder, exceptions flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(exceptions), 0) +} +func ExceptionsStartExceptionsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ExceptionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/framework/InterfaceList_.go b/pkg/fbs/comm/datalayer/framework/InterfaceList_.go index 41a35d9..ba1287c 100644 --- a/pkg/fbs/comm/datalayer/framework/InterfaceList_.go +++ b/pkg/fbs/comm/datalayer/framework/InterfaceList_.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type InterfaceList_T struct { + Interfaces []*Interface_T +} + +func (t *InterfaceList_T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + interfacesOffset := flatbuffers.UOffsetT(0) + if t.Interfaces != nil { + interfacesLength := len(t.Interfaces) + interfacesOffsets := make([]flatbuffers.UOffsetT, interfacesLength) + for j := 0; j < interfacesLength; j++ { + interfacesOffsets[j] = t.Interfaces[j].Pack(builder) + } + InterfaceList_StartInterfacesVector(builder, interfacesLength) + for j := interfacesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(interfacesOffsets[j]) + } + interfacesOffset = builder.EndVector(interfacesLength) + } + InterfaceList_Start(builder) + InterfaceList_AddInterfaces(builder, interfacesOffset) + return InterfaceList_End(builder) +} + +func (rcv *InterfaceList_) UnPackTo(t *InterfaceList_T) { + interfacesLength := rcv.InterfacesLength() + t.Interfaces = make([]*Interface_T, interfacesLength) + for j := 0; j < interfacesLength; j++ { + x := Interface_{} + rcv.Interfaces(&x, j) + t.Interfaces[j] = x.UnPack() + } +} + +func (rcv *InterfaceList_) UnPack() *InterfaceList_T { + if rcv == nil { return nil } + t := &InterfaceList_T{} + rcv.UnPackTo(t) + return t +} + type InterfaceList_ struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Interface_.go b/pkg/fbs/comm/datalayer/framework/Interface_.go index 080a994..20b872d 100644 --- a/pkg/fbs/comm/datalayer/framework/Interface_.go +++ b/pkg/fbs/comm/datalayer/framework/Interface_.go @@ -6,6 +6,59 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Interface_T struct { + Name string + Version string + Language string + Properties []*PropertyT +} + +func (t *Interface_T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + languageOffset := builder.CreateString(t.Language) + propertiesOffset := flatbuffers.UOffsetT(0) + if t.Properties != nil { + propertiesLength := len(t.Properties) + propertiesOffsets := make([]flatbuffers.UOffsetT, propertiesLength) + for j := 0; j < propertiesLength; j++ { + propertiesOffsets[j] = t.Properties[j].Pack(builder) + } + Interface_StartPropertiesVector(builder, propertiesLength) + for j := propertiesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(propertiesOffsets[j]) + } + propertiesOffset = builder.EndVector(propertiesLength) + } + Interface_Start(builder) + Interface_AddName(builder, nameOffset) + Interface_AddVersion(builder, versionOffset) + Interface_AddLanguage(builder, languageOffset) + Interface_AddProperties(builder, propertiesOffset) + return Interface_End(builder) +} + +func (rcv *Interface_) UnPackTo(t *Interface_T) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) + t.Language = string(rcv.Language()) + propertiesLength := rcv.PropertiesLength() + t.Properties = make([]*PropertyT, propertiesLength) + for j := 0; j < propertiesLength; j++ { + x := Property{} + rcv.Properties(&x, j) + t.Properties[j] = x.UnPack() + } +} + +func (rcv *Interface_) UnPack() *Interface_T { + if rcv == nil { return nil } + t := &Interface_T{} + rcv.UnPackTo(t) + return t +} + type Interface_ struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Property.go b/pkg/fbs/comm/datalayer/framework/Property.go index 0166169..a7d9383 100644 --- a/pkg/fbs/comm/datalayer/framework/Property.go +++ b/pkg/fbs/comm/datalayer/framework/Property.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type PropertyT struct { + Name string + Value string +} + +func (t *PropertyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + valueOffset := builder.CreateString(t.Value) + PropertyStart(builder) + PropertyAddName(builder, nameOffset) + PropertyAddValue(builder, valueOffset) + return PropertyEnd(builder) +} + +func (rcv *Property) UnPackTo(t *PropertyT) { + t.Name = string(rcv.Name()) + t.Value = string(rcv.Value()) +} + +func (rcv *Property) UnPack() *PropertyT { + if rcv == nil { return nil } + t := &PropertyT{} + rcv.UnPackTo(t) + return t +} + type Property struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/PropertyList.go b/pkg/fbs/comm/datalayer/framework/PropertyList.go index cfbcc4b..bf30905 100644 --- a/pkg/fbs/comm/datalayer/framework/PropertyList.go +++ b/pkg/fbs/comm/datalayer/framework/PropertyList.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type PropertyListT struct { + Properties []*PropertyT +} + +func (t *PropertyListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + propertiesOffset := flatbuffers.UOffsetT(0) + if t.Properties != nil { + propertiesLength := len(t.Properties) + propertiesOffsets := make([]flatbuffers.UOffsetT, propertiesLength) + for j := 0; j < propertiesLength; j++ { + propertiesOffsets[j] = t.Properties[j].Pack(builder) + } + PropertyListStartPropertiesVector(builder, propertiesLength) + for j := propertiesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(propertiesOffsets[j]) + } + propertiesOffset = builder.EndVector(propertiesLength) + } + PropertyListStart(builder) + PropertyListAddProperties(builder, propertiesOffset) + return PropertyListEnd(builder) +} + +func (rcv *PropertyList) UnPackTo(t *PropertyListT) { + propertiesLength := rcv.PropertiesLength() + t.Properties = make([]*PropertyT, propertiesLength) + for j := 0; j < propertiesLength; j++ { + x := Property{} + rcv.Properties(&x, j) + t.Properties[j] = x.UnPack() + } +} + +func (rcv *PropertyList) UnPack() *PropertyListT { + if rcv == nil { return nil } + t := &PropertyListT{} + rcv.UnPackTo(t) + return t +} + type PropertyList struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/framework/Register.go b/pkg/fbs/comm/datalayer/framework/Register.go new file mode 100644 index 0000000..4eadba4 --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/Register.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type RegisterT struct { + IP string + SP string + BP string +} + +func (t *RegisterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + IPOffset := builder.CreateString(t.IP) + SPOffset := builder.CreateString(t.SP) + BPOffset := builder.CreateString(t.BP) + RegisterStart(builder) + RegisterAddIP(builder, IPOffset) + RegisterAddSP(builder, SPOffset) + RegisterAddBP(builder, BPOffset) + return RegisterEnd(builder) +} + +func (rcv *Register) UnPackTo(t *RegisterT) { + t.IP = string(rcv.IP()) + t.SP = string(rcv.SP()) + t.BP = string(rcv.BP()) +} + +func (rcv *Register) UnPack() *RegisterT { + if rcv == nil { return nil } + t := &RegisterT{} + rcv.UnPackTo(t) + return t +} + +type Register struct { + _tab flatbuffers.Table +} + +func GetRootAsRegister(buf []byte, offset flatbuffers.UOffsetT) *Register { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Register{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsRegister(buf []byte, offset flatbuffers.UOffsetT) *Register { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Register{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Register) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Register) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Register) IP() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Register) SP() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Register) BP() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func RegisterStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func RegisterAddIP(builder *flatbuffers.Builder, IP flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(IP), 0) +} +func RegisterAddSP(builder *flatbuffers.Builder, SP flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(SP), 0) +} +func RegisterAddBP(builder *flatbuffers.Builder, BP flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(BP), 0) +} +func RegisterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/framework/Stackentry.go b/pkg/fbs/comm/datalayer/framework/Stackentry.go new file mode 100644 index 0000000..27b90c9 --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/Stackentry.go @@ -0,0 +1,93 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type StackentryT struct { + Frame uint32 + Stack string +} + +func (t *StackentryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + stackOffset := builder.CreateString(t.Stack) + StackentryStart(builder) + StackentryAddFrame(builder, t.Frame) + StackentryAddStack(builder, stackOffset) + return StackentryEnd(builder) +} + +func (rcv *Stackentry) UnPackTo(t *StackentryT) { + t.Frame = rcv.Frame() + t.Stack = string(rcv.Stack()) +} + +func (rcv *Stackentry) UnPack() *StackentryT { + if rcv == nil { return nil } + t := &StackentryT{} + rcv.UnPackTo(t) + return t +} + +type Stackentry struct { + _tab flatbuffers.Table +} + +func GetRootAsStackentry(buf []byte, offset flatbuffers.UOffsetT) *Stackentry { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Stackentry{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStackentry(buf []byte, offset flatbuffers.UOffsetT) *Stackentry { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Stackentry{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Stackentry) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Stackentry) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Stackentry) Frame() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Stackentry) MutateFrame(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *Stackentry) Stack() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func StackentryStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func StackentryAddFrame(builder *flatbuffers.Builder, frame uint32) { + builder.PrependUint32Slot(0, frame, 0) +} +func StackentryAddStack(builder *flatbuffers.Builder, stack flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(stack), 0) +} +func StackentryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/remote/ConfigItem.go b/pkg/fbs/comm/datalayer/remote/ConfigItem.go index 863dfaa..b1dad4d 100644 --- a/pkg/fbs/comm/datalayer/remote/ConfigItem.go +++ b/pkg/fbs/comm/datalayer/remote/ConfigItem.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ConfigItemT struct { + Name string + Address string +} + +func (t *ConfigItemT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + addressOffset := builder.CreateString(t.Address) + ConfigItemStart(builder) + ConfigItemAddName(builder, nameOffset) + ConfigItemAddAddress(builder, addressOffset) + return ConfigItemEnd(builder) +} + +func (rcv *ConfigItem) UnPackTo(t *ConfigItemT) { + t.Name = string(rcv.Name()) + t.Address = string(rcv.Address()) +} + +func (rcv *ConfigItem) UnPack() *ConfigItemT { + if rcv == nil { return nil } + t := &ConfigItemT{} + rcv.UnPackTo(t) + return t +} + type ConfigItem struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/datalayer/remote/RemoteConfig.go b/pkg/fbs/comm/datalayer/remote/RemoteConfig.go new file mode 100644 index 0000000..98741fe --- /dev/null +++ b/pkg/fbs/comm/datalayer/remote/RemoteConfig.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package remote + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type RemoteConfigT struct { + Remotes []*ConfigItemT +} + +func (t *RemoteConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + remotesOffset := flatbuffers.UOffsetT(0) + if t.Remotes != nil { + remotesLength := len(t.Remotes) + remotesOffsets := make([]flatbuffers.UOffsetT, remotesLength) + for j := 0; j < remotesLength; j++ { + remotesOffsets[j] = t.Remotes[j].Pack(builder) + } + RemoteConfigStartRemotesVector(builder, remotesLength) + for j := remotesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(remotesOffsets[j]) + } + remotesOffset = builder.EndVector(remotesLength) + } + RemoteConfigStart(builder) + RemoteConfigAddRemotes(builder, remotesOffset) + return RemoteConfigEnd(builder) +} + +func (rcv *RemoteConfig) UnPackTo(t *RemoteConfigT) { + remotesLength := rcv.RemotesLength() + t.Remotes = make([]*ConfigItemT, remotesLength) + for j := 0; j < remotesLength; j++ { + x := ConfigItem{} + rcv.Remotes(&x, j) + t.Remotes[j] = x.UnPack() + } +} + +func (rcv *RemoteConfig) UnPack() *RemoteConfigT { + if rcv == nil { return nil } + t := &RemoteConfigT{} + rcv.UnPackTo(t) + return t +} + +type RemoteConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsRemoteConfig(buf []byte, offset flatbuffers.UOffsetT) *RemoteConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &RemoteConfig{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsRemoteConfig(buf []byte, offset flatbuffers.UOffsetT) *RemoteConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &RemoteConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *RemoteConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *RemoteConfig) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *RemoteConfig) Remotes(obj *ConfigItem, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *RemoteConfig) RemotesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func RemoteConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func RemoteConfigAddRemotes(builder *flatbuffers.Builder, remotes flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(remotes), 0) +} +func RemoteConfigStartRemotesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func RemoteConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/AddressedRequest.go b/pkg/fbs/comm/ethercat/master/fbs/AddressedRequest.go index b81ea73..866a3ad 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AddressedRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AddressedRequest.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AddressedRequestT struct { + AddressType Addresstype + Address uint16 +} + +func (t *AddressedRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AddressedRequestStart(builder) + AddressedRequestAddAddressType(builder, t.AddressType) + AddressedRequestAddAddress(builder, t.Address) + return AddressedRequestEnd(builder) +} + +func (rcv *AddressedRequest) UnPackTo(t *AddressedRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() +} + +func (rcv *AddressedRequest) UnPack() *AddressedRequestT { + if rcv == nil { return nil } + t := &AddressedRequestT{} + rcv.UnPackTo(t) + return t +} + type AddressedRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfo.go index 7a9c6cf..b6e733a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfo.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeConfigInfoT struct { + Request *AddressedRequestT + Response *AoeConfigInfoResponseT +} + +func (t *AoeConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + AoeConfigInfoStart(builder) + AoeConfigInfoAddRequest(builder, requestOffset) + AoeConfigInfoAddResponse(builder, responseOffset) + return AoeConfigInfoEnd(builder) +} + +func (rcv *AoeConfigInfo) UnPackTo(t *AoeConfigInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *AoeConfigInfo) UnPack() *AoeConfigInfoT { + if rcv == nil { return nil } + t := &AoeConfigInfoT{} + rcv.UnPackTo(t) + return t +} + type AoeConfigInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfoResponse.go index f9dc6e5..f3858ae 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeConfigInfoResponse.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeConfigInfoResponseT struct { + NetId []byte +} + +func (t *AoeConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + netIdOffset := flatbuffers.UOffsetT(0) + if t.NetId != nil { + netIdOffset = builder.CreateByteString(t.NetId) + } + AoeConfigInfoResponseStart(builder) + AoeConfigInfoResponseAddNetId(builder, netIdOffset) + return AoeConfigInfoResponseEnd(builder) +} + +func (rcv *AoeConfigInfoResponse) UnPackTo(t *AoeConfigInfoResponseT) { + t.NetId = rcv.NetIdBytes() +} + +func (rcv *AoeConfigInfoResponse) UnPack() *AoeConfigInfoResponseT { + if rcv == nil { return nil } + t := &AoeConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + type AoeConfigInfoResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeControl.go b/pkg/fbs/comm/ethercat/master/fbs/AoeControl.go index 0cc56dc..0fcdfb1 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeControl.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeControl.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeControlT struct { + Request *AoeControlRequestT + Response *AoeControlResponseT +} + +func (t *AoeControlT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + AoeControlStart(builder) + AoeControlAddRequest(builder, requestOffset) + AoeControlAddResponse(builder, responseOffset) + return AoeControlEnd(builder) +} + +func (rcv *AoeControl) UnPackTo(t *AoeControlT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *AoeControl) UnPack() *AoeControlT { + if rcv == nil { return nil } + t := &AoeControlT{} + rcv.UnPackTo(t) + return t +} + type AoeControl struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeControlRequest.go b/pkg/fbs/comm/ethercat/master/fbs/AoeControlRequest.go index 98576ff..d9c619c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeControlRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeControlRequest.go @@ -6,6 +6,54 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeControlRequestT struct { + AddressType Addresstype + Address uint16 + TargetNetId []byte + TargetPort uint16 + AoeState uint16 + DeviceState uint16 + Data []byte +} + +func (t *AoeControlRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + targetNetIdOffset := flatbuffers.UOffsetT(0) + if t.TargetNetId != nil { + targetNetIdOffset = builder.CreateByteString(t.TargetNetId) + } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + AoeControlRequestStart(builder) + AoeControlRequestAddAddressType(builder, t.AddressType) + AoeControlRequestAddAddress(builder, t.Address) + AoeControlRequestAddTargetNetId(builder, targetNetIdOffset) + AoeControlRequestAddTargetPort(builder, t.TargetPort) + AoeControlRequestAddAoeState(builder, t.AoeState) + AoeControlRequestAddDeviceState(builder, t.DeviceState) + AoeControlRequestAddData(builder, dataOffset) + return AoeControlRequestEnd(builder) +} + +func (rcv *AoeControlRequest) UnPackTo(t *AoeControlRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.TargetNetId = rcv.TargetNetIdBytes() + t.TargetPort = rcv.TargetPort() + t.AoeState = rcv.AoeState() + t.DeviceState = rcv.DeviceState() + t.Data = rcv.DataBytes() +} + +func (rcv *AoeControlRequest) UnPack() *AoeControlRequestT { + if rcv == nil { return nil } + t := &AoeControlRequestT{} + rcv.UnPackTo(t) + return t +} + type AoeControlRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeControlResponse.go b/pkg/fbs/comm/ethercat/master/fbs/AoeControlResponse.go index 6649a8c..50c5da4 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeControlResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeControlResponse.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeControlResponseT struct { + ErrorCode uint32 + CmdResult uint32 +} + +func (t *AoeControlResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AoeControlResponseStart(builder) + AoeControlResponseAddErrorCode(builder, t.ErrorCode) + AoeControlResponseAddCmdResult(builder, t.CmdResult) + return AoeControlResponseEnd(builder) +} + +func (rcv *AoeControlResponse) UnPackTo(t *AoeControlResponseT) { + t.ErrorCode = rcv.ErrorCode() + t.CmdResult = rcv.CmdResult() +} + +func (rcv *AoeControlResponse) UnPack() *AoeControlResponseT { + if rcv == nil { return nil } + t := &AoeControlResponseT{} + rcv.UnPackTo(t) + return t +} + type AoeControlResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeData.go b/pkg/fbs/comm/ethercat/master/fbs/AoeData.go index 6802648..90ffec4 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeData.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeData.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeDataT struct { + Request *AoeDataRequestT + Response *AoeDataResponseT +} + +func (t *AoeDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + AoeDataStart(builder) + AoeDataAddRequest(builder, requestOffset) + AoeDataAddResponse(builder, responseOffset) + return AoeDataEnd(builder) +} + +func (rcv *AoeData) UnPackTo(t *AoeDataT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *AoeData) UnPack() *AoeDataT { + if rcv == nil { return nil } + t := &AoeDataT{} + rcv.UnPackTo(t) + return t +} + type AoeData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeDataRequest.go b/pkg/fbs/comm/ethercat/master/fbs/AoeDataRequest.go index 4741025..d98533e 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeDataRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeDataRequest.go @@ -6,6 +6,57 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeDataRequestT struct { + AddressType Addresstype + Address uint16 + TargetNetId []byte + TargetPort uint16 + IndexGroup uint32 + IndexOffset uint32 + Data []byte + MaxLength uint32 +} + +func (t *AoeDataRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + targetNetIdOffset := flatbuffers.UOffsetT(0) + if t.TargetNetId != nil { + targetNetIdOffset = builder.CreateByteString(t.TargetNetId) + } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + AoeDataRequestStart(builder) + AoeDataRequestAddAddressType(builder, t.AddressType) + AoeDataRequestAddAddress(builder, t.Address) + AoeDataRequestAddTargetNetId(builder, targetNetIdOffset) + AoeDataRequestAddTargetPort(builder, t.TargetPort) + AoeDataRequestAddIndexGroup(builder, t.IndexGroup) + AoeDataRequestAddIndexOffset(builder, t.IndexOffset) + AoeDataRequestAddData(builder, dataOffset) + AoeDataRequestAddMaxLength(builder, t.MaxLength) + return AoeDataRequestEnd(builder) +} + +func (rcv *AoeDataRequest) UnPackTo(t *AoeDataRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.TargetNetId = rcv.TargetNetIdBytes() + t.TargetPort = rcv.TargetPort() + t.IndexGroup = rcv.IndexGroup() + t.IndexOffset = rcv.IndexOffset() + t.Data = rcv.DataBytes() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *AoeDataRequest) UnPack() *AoeDataRequestT { + if rcv == nil { return nil } + t := &AoeDataRequestT{} + rcv.UnPackTo(t) + return t +} + type AoeDataRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/AoeDataResponse.go b/pkg/fbs/comm/ethercat/master/fbs/AoeDataResponse.go index 93a15f9..e12050c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/AoeDataResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/AoeDataResponse.go @@ -6,6 +6,38 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AoeDataResponseT struct { + Data []byte + ErrorCode uint32 + CmdResult uint32 +} + +func (t *AoeDataResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + AoeDataResponseStart(builder) + AoeDataResponseAddData(builder, dataOffset) + AoeDataResponseAddErrorCode(builder, t.ErrorCode) + AoeDataResponseAddCmdResult(builder, t.CmdResult) + return AoeDataResponseEnd(builder) +} + +func (rcv *AoeDataResponse) UnPackTo(t *AoeDataResponseT) { + t.Data = rcv.DataBytes() + t.ErrorCode = rcv.ErrorCode() + t.CmdResult = rcv.CmdResult() +} + +func (rcv *AoeDataResponse) UnPack() *AoeDataResponseT { + if rcv == nil { return nil } + t := &AoeDataResponseT{} + rcv.UnPackTo(t) + return t +} + type AoeDataResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCounters.go b/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCounters.go new file mode 100644 index 0000000..6739a3e --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCounters.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BusLoadStatisticCountersT struct { + Response *BusLoadStatisticCountersResponseT +} + +func (t *BusLoadStatisticCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + BusLoadStatisticCountersStart(builder) + BusLoadStatisticCountersAddResponse(builder, responseOffset) + return BusLoadStatisticCountersEnd(builder) +} + +func (rcv *BusLoadStatisticCounters) UnPackTo(t *BusLoadStatisticCountersT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *BusLoadStatisticCounters) UnPack() *BusLoadStatisticCountersT { + if rcv == nil { return nil } + t := &BusLoadStatisticCountersT{} + rcv.UnPackTo(t) + return t +} + +type BusLoadStatisticCounters struct { + _tab flatbuffers.Table +} + +func GetRootAsBusLoadStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *BusLoadStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BusLoadStatisticCounters{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBusLoadStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *BusLoadStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BusLoadStatisticCounters{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *BusLoadStatisticCounters) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BusLoadStatisticCounters) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BusLoadStatisticCounters) Response(obj *BusLoadStatisticCountersResponse) *BusLoadStatisticCountersResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(BusLoadStatisticCountersResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func BusLoadStatisticCountersStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func BusLoadStatisticCountersAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func BusLoadStatisticCountersEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCountersResponse.go b/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCountersResponse.go new file mode 100644 index 0000000..645bc9f --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/BusLoadStatisticCountersResponse.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BusLoadStatisticCountersResponseT struct { + TxBytesPerSecond *MinActMaxValuesT + TxBytesPerCycle *MinActMaxValuesT +} + +func (t *BusLoadStatisticCountersResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + BusLoadStatisticCountersResponseStart(builder) + txBytesPerSecondOffset := t.TxBytesPerSecond.Pack(builder) + BusLoadStatisticCountersResponseAddTxBytesPerSecond(builder, txBytesPerSecondOffset) + txBytesPerCycleOffset := t.TxBytesPerCycle.Pack(builder) + BusLoadStatisticCountersResponseAddTxBytesPerCycle(builder, txBytesPerCycleOffset) + return BusLoadStatisticCountersResponseEnd(builder) +} + +func (rcv *BusLoadStatisticCountersResponse) UnPackTo(t *BusLoadStatisticCountersResponseT) { + t.TxBytesPerSecond = rcv.TxBytesPerSecond(nil).UnPack() + t.TxBytesPerCycle = rcv.TxBytesPerCycle(nil).UnPack() +} + +func (rcv *BusLoadStatisticCountersResponse) UnPack() *BusLoadStatisticCountersResponseT { + if rcv == nil { return nil } + t := &BusLoadStatisticCountersResponseT{} + rcv.UnPackTo(t) + return t +} + +type BusLoadStatisticCountersResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsBusLoadStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *BusLoadStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BusLoadStatisticCountersResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBusLoadStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *BusLoadStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BusLoadStatisticCountersResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *BusLoadStatisticCountersResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BusLoadStatisticCountersResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BusLoadStatisticCountersResponse) TxBytesPerSecond(obj *MinActMaxValues) *MinActMaxValues { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(MinActMaxValues) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *BusLoadStatisticCountersResponse) TxBytesPerCycle(obj *MinActMaxValues) *MinActMaxValues { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(MinActMaxValues) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func BusLoadStatisticCountersResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func BusLoadStatisticCountersResponseAddTxBytesPerSecond(builder *flatbuffers.Builder, txBytesPerSecond flatbuffers.UOffsetT) { + builder.PrependStructSlot(0, flatbuffers.UOffsetT(txBytesPerSecond), 0) +} +func BusLoadStatisticCountersResponseAddTxBytesPerCycle(builder *flatbuffers.Builder, txBytesPerCycle flatbuffers.UOffsetT) { + builder.PrependStructSlot(1, flatbuffers.UOffsetT(txBytesPerCycle), 0) +} +func BusLoadStatisticCountersResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/Capability.go b/pkg/fbs/comm/ethercat/master/fbs/Capability.go index 0fc1f1b..1cecd4a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/Capability.go +++ b/pkg/fbs/comm/ethercat/master/fbs/Capability.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CapabilityT struct { + Name string + Value string +} + +func (t *CapabilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + valueOffset := builder.CreateString(t.Value) + CapabilityStart(builder) + CapabilityAddName(builder, nameOffset) + CapabilityAddValue(builder, valueOffset) + return CapabilityEnd(builder) +} + +func (rcv *Capability) UnPackTo(t *CapabilityT) { + t.Name = string(rcv.Name()) + t.Value = string(rcv.Value()) +} + +func (rcv *Capability) UnPack() *CapabilityT { + if rcv == nil { return nil } + t := &CapabilityT{} + rcv.UnPackTo(t) + return t +} + type Capability struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/CapableInterfaces.go b/pkg/fbs/comm/ethercat/master/fbs/CapableInterfaces.go index e6c2807..f86c6e0 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/CapableInterfaces.go +++ b/pkg/fbs/comm/ethercat/master/fbs/CapableInterfaces.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CapableInterfacesT struct { + InterfaceList []*InterfaceT +} + +func (t *CapableInterfacesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + interfaceListOffset := flatbuffers.UOffsetT(0) + if t.InterfaceList != nil { + interfaceListLength := len(t.InterfaceList) + interfaceListOffsets := make([]flatbuffers.UOffsetT, interfaceListLength) + for j := 0; j < interfaceListLength; j++ { + interfaceListOffsets[j] = t.InterfaceList[j].Pack(builder) + } + CapableInterfacesStartInterfaceListVector(builder, interfaceListLength) + for j := interfaceListLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(interfaceListOffsets[j]) + } + interfaceListOffset = builder.EndVector(interfaceListLength) + } + CapableInterfacesStart(builder) + CapableInterfacesAddInterfaceList(builder, interfaceListOffset) + return CapableInterfacesEnd(builder) +} + +func (rcv *CapableInterfaces) UnPackTo(t *CapableInterfacesT) { + interfaceListLength := rcv.InterfaceListLength() + t.InterfaceList = make([]*InterfaceT, interfaceListLength) + for j := 0; j < interfaceListLength; j++ { + x := Interface{} + rcv.InterfaceList(&x, j) + t.InterfaceList[j] = x.UnPack() + } +} + +func (rcv *CapableInterfaces) UnPack() *CapableInterfacesT { + if rcv == nil { return nil } + t := &CapableInterfacesT{} + rcv.UnPackTo(t) + return t +} + type CapableInterfaces struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/Checksum.go b/pkg/fbs/comm/ethercat/master/fbs/Checksum.go index 30a4285..eb3dfa5 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/Checksum.go +++ b/pkg/fbs/comm/ethercat/master/fbs/Checksum.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ChecksumT struct { + Response *ChecksumResponseT +} + +func (t *ChecksumT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + ChecksumStart(builder) + ChecksumAddResponse(builder, responseOffset) + return ChecksumEnd(builder) +} + +func (rcv *Checksum) UnPackTo(t *ChecksumT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *Checksum) UnPack() *ChecksumT { + if rcv == nil { return nil } + t := &ChecksumT{} + rcv.UnPackTo(t) + return t +} + type Checksum struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ChecksumElement.go b/pkg/fbs/comm/ethercat/master/fbs/ChecksumElement.go index 79e6c77..3f4a403 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ChecksumElement.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ChecksumElement.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ChecksumElementT struct { + Id string + Checksum []byte +} + +func (t *ChecksumElementT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idOffset := builder.CreateString(t.Id) + checksumOffset := flatbuffers.UOffsetT(0) + if t.Checksum != nil { + checksumOffset = builder.CreateByteString(t.Checksum) + } + ChecksumElementStart(builder) + ChecksumElementAddId(builder, idOffset) + ChecksumElementAddChecksum(builder, checksumOffset) + return ChecksumElementEnd(builder) +} + +func (rcv *ChecksumElement) UnPackTo(t *ChecksumElementT) { + t.Id = string(rcv.Id()) + t.Checksum = rcv.ChecksumBytes() +} + +func (rcv *ChecksumElement) UnPack() *ChecksumElementT { + if rcv == nil { return nil } + t := &ChecksumElementT{} + rcv.UnPackTo(t) + return t +} + type ChecksumElement struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ChecksumResponse.go b/pkg/fbs/comm/ethercat/master/fbs/ChecksumResponse.go index a09c6a9..27fde99 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ChecksumResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ChecksumResponse.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ChecksumResponseT struct { + Checksums []*ChecksumElementT +} + +func (t *ChecksumResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + checksumsOffset := flatbuffers.UOffsetT(0) + if t.Checksums != nil { + checksumsLength := len(t.Checksums) + checksumsOffsets := make([]flatbuffers.UOffsetT, checksumsLength) + for j := 0; j < checksumsLength; j++ { + checksumsOffsets[j] = t.Checksums[j].Pack(builder) + } + ChecksumResponseStartChecksumsVector(builder, checksumsLength) + for j := checksumsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(checksumsOffsets[j]) + } + checksumsOffset = builder.EndVector(checksumsLength) + } + ChecksumResponseStart(builder) + ChecksumResponseAddChecksums(builder, checksumsOffset) + return ChecksumResponseEnd(builder) +} + +func (rcv *ChecksumResponse) UnPackTo(t *ChecksumResponseT) { + checksumsLength := rcv.ChecksumsLength() + t.Checksums = make([]*ChecksumElementT, checksumsLength) + for j := 0; j < checksumsLength; j++ { + x := ChecksumElement{} + rcv.Checksums(&x, j) + t.Checksums[j] = x.UnPack() + } +} + +func (rcv *ChecksumResponse) UnPack() *ChecksumResponseT { + if rcv == nil { return nil } + t := &ChecksumResponseT{} + rcv.UnPackTo(t) + return t +} + type ChecksumResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/CommDirection.go b/pkg/fbs/comm/ethercat/master/fbs/CommDirection.go new file mode 100644 index 0000000..35b240e --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/CommDirection.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type CommDirection byte + +const ( + CommDirectiontx CommDirection = 0 + CommDirectionrx CommDirection = 1 + CommDirectiontx_rx CommDirection = 2 +) + +var EnumNamesCommDirection = map[CommDirection]string{ + CommDirectiontx: "tx", + CommDirectionrx: "rx", + CommDirectiontx_rx: "tx_rx", +} + +var EnumValuesCommDirection = map[string]CommDirection{ + "tx": CommDirectiontx, + "rx": CommDirectionrx, + "tx_rx": CommDirectiontx_rx, +} + +func (v CommDirection) String() string { + if s, ok := EnumNamesCommDirection[v]; ok { + return s + } + return "CommDirection(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfo.go new file mode 100644 index 0000000..0b60ce1 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfo.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DcConfigInfoT struct { + Response *DcConfigInfoResponseT +} + +func (t *DcConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + DcConfigInfoStart(builder) + DcConfigInfoAddResponse(builder, responseOffset) + return DcConfigInfoEnd(builder) +} + +func (rcv *DcConfigInfo) UnPackTo(t *DcConfigInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *DcConfigInfo) UnPack() *DcConfigInfoT { + if rcv == nil { return nil } + t := &DcConfigInfoT{} + rcv.UnPackTo(t) + return t +} + +type DcConfigInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsDcConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *DcConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcConfigInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *DcConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcConfigInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcConfigInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcConfigInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcConfigInfo) Response(obj *DcConfigInfoResponse) *DcConfigInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DcConfigInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func DcConfigInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func DcConfigInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func DcConfigInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go new file mode 100644 index 0000000..838ea32 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go @@ -0,0 +1,168 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DcConfigInfoResponseT struct { + SyncMode SyncMode + CycleTime uint32 + SyncShiftTime uint32 + SyncWindowMonitoring bool + DeviationLimit uint32 + ContinuousDelayCompensation bool +} + +func (t *DcConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DcConfigInfoResponseStart(builder) + DcConfigInfoResponseAddSyncMode(builder, t.SyncMode) + DcConfigInfoResponseAddCycleTime(builder, t.CycleTime) + DcConfigInfoResponseAddSyncShiftTime(builder, t.SyncShiftTime) + DcConfigInfoResponseAddSyncWindowMonitoring(builder, t.SyncWindowMonitoring) + DcConfigInfoResponseAddDeviationLimit(builder, t.DeviationLimit) + DcConfigInfoResponseAddContinuousDelayCompensation(builder, t.ContinuousDelayCompensation) + return DcConfigInfoResponseEnd(builder) +} + +func (rcv *DcConfigInfoResponse) UnPackTo(t *DcConfigInfoResponseT) { + t.SyncMode = rcv.SyncMode() + t.CycleTime = rcv.CycleTime() + t.SyncShiftTime = rcv.SyncShiftTime() + t.SyncWindowMonitoring = rcv.SyncWindowMonitoring() + t.DeviationLimit = rcv.DeviationLimit() + t.ContinuousDelayCompensation = rcv.ContinuousDelayCompensation() +} + +func (rcv *DcConfigInfoResponse) UnPack() *DcConfigInfoResponseT { + if rcv == nil { return nil } + t := &DcConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type DcConfigInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsDcConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcConfigInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcConfigInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcConfigInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcConfigInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcConfigInfoResponse) SyncMode() SyncMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return SyncMode(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *DcConfigInfoResponse) MutateSyncMode(n SyncMode) bool { + return rcv._tab.MutateUint32Slot(4, uint32(n)) +} + +func (rcv *DcConfigInfoResponse) CycleTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcConfigInfoResponse) MutateCycleTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *DcConfigInfoResponse) SyncShiftTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcConfigInfoResponse) MutateSyncShiftTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *DcConfigInfoResponse) SyncWindowMonitoring() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *DcConfigInfoResponse) MutateSyncWindowMonitoring(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func (rcv *DcConfigInfoResponse) DeviationLimit() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcConfigInfoResponse) MutateDeviationLimit(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func (rcv *DcConfigInfoResponse) ContinuousDelayCompensation() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *DcConfigInfoResponse) MutateContinuousDelayCompensation(n bool) bool { + return rcv._tab.MutateBoolSlot(14, n) +} + +func DcConfigInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func DcConfigInfoResponseAddSyncMode(builder *flatbuffers.Builder, syncMode SyncMode) { + builder.PrependUint32Slot(0, uint32(syncMode), 0) +} +func DcConfigInfoResponseAddCycleTime(builder *flatbuffers.Builder, cycleTime uint32) { + builder.PrependUint32Slot(1, cycleTime, 0) +} +func DcConfigInfoResponseAddSyncShiftTime(builder *flatbuffers.Builder, syncShiftTime uint32) { + builder.PrependUint32Slot(2, syncShiftTime, 0) +} +func DcConfigInfoResponseAddSyncWindowMonitoring(builder *flatbuffers.Builder, syncWindowMonitoring bool) { + builder.PrependBoolSlot(3, syncWindowMonitoring, false) +} +func DcConfigInfoResponseAddDeviationLimit(builder *flatbuffers.Builder, deviationLimit uint32) { + builder.PrependUint32Slot(4, deviationLimit, 0) +} +func DcConfigInfoResponseAddContinuousDelayCompensation(builder *flatbuffers.Builder, continuousDelayCompensation bool) { + builder.PrependBoolSlot(5, continuousDelayCompensation, false) +} +func DcConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfo.go b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfo.go new file mode 100644 index 0000000..c2d0ff2 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfo.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DcOnlineInfoT struct { + Response *DcOnlineInfoResponseT +} + +func (t *DcOnlineInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + DcOnlineInfoStart(builder) + DcOnlineInfoAddResponse(builder, responseOffset) + return DcOnlineInfoEnd(builder) +} + +func (rcv *DcOnlineInfo) UnPackTo(t *DcOnlineInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *DcOnlineInfo) UnPack() *DcOnlineInfoT { + if rcv == nil { return nil } + t := &DcOnlineInfoT{} + rcv.UnPackTo(t) + return t +} + +type DcOnlineInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsDcOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *DcOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcOnlineInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *DcOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcOnlineInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcOnlineInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcOnlineInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcOnlineInfo) Response(obj *DcOnlineInfoResponse) *DcOnlineInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DcOnlineInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func DcOnlineInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func DcOnlineInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func DcOnlineInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go new file mode 100644 index 0000000..67fb89c --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go @@ -0,0 +1,186 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DcOnlineInfoResponseT struct { + SyncMode SyncMode + CycleTime uint32 + SyncShiftTime uint32 + SyncWindowMonitoring bool + DeviationLimit uint32 + ContinuousDelayCompensation bool + SystemTime uint64 +} + +func (t *DcOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DcOnlineInfoResponseStart(builder) + DcOnlineInfoResponseAddSyncMode(builder, t.SyncMode) + DcOnlineInfoResponseAddCycleTime(builder, t.CycleTime) + DcOnlineInfoResponseAddSyncShiftTime(builder, t.SyncShiftTime) + DcOnlineInfoResponseAddSyncWindowMonitoring(builder, t.SyncWindowMonitoring) + DcOnlineInfoResponseAddDeviationLimit(builder, t.DeviationLimit) + DcOnlineInfoResponseAddContinuousDelayCompensation(builder, t.ContinuousDelayCompensation) + DcOnlineInfoResponseAddSystemTime(builder, t.SystemTime) + return DcOnlineInfoResponseEnd(builder) +} + +func (rcv *DcOnlineInfoResponse) UnPackTo(t *DcOnlineInfoResponseT) { + t.SyncMode = rcv.SyncMode() + t.CycleTime = rcv.CycleTime() + t.SyncShiftTime = rcv.SyncShiftTime() + t.SyncWindowMonitoring = rcv.SyncWindowMonitoring() + t.DeviationLimit = rcv.DeviationLimit() + t.ContinuousDelayCompensation = rcv.ContinuousDelayCompensation() + t.SystemTime = rcv.SystemTime() +} + +func (rcv *DcOnlineInfoResponse) UnPack() *DcOnlineInfoResponseT { + if rcv == nil { return nil } + t := &DcOnlineInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type DcOnlineInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsDcOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcOnlineInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcOnlineInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcOnlineInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcOnlineInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcOnlineInfoResponse) SyncMode() SyncMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return SyncMode(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *DcOnlineInfoResponse) MutateSyncMode(n SyncMode) bool { + return rcv._tab.MutateUint32Slot(4, uint32(n)) +} + +func (rcv *DcOnlineInfoResponse) CycleTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcOnlineInfoResponse) MutateCycleTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *DcOnlineInfoResponse) SyncShiftTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcOnlineInfoResponse) MutateSyncShiftTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *DcOnlineInfoResponse) SyncWindowMonitoring() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *DcOnlineInfoResponse) MutateSyncWindowMonitoring(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func (rcv *DcOnlineInfoResponse) DeviationLimit() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcOnlineInfoResponse) MutateDeviationLimit(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func (rcv *DcOnlineInfoResponse) ContinuousDelayCompensation() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *DcOnlineInfoResponse) MutateContinuousDelayCompensation(n bool) bool { + return rcv._tab.MutateBoolSlot(14, n) +} + +func (rcv *DcOnlineInfoResponse) SystemTime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DcOnlineInfoResponse) MutateSystemTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(16, n) +} + +func DcOnlineInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func DcOnlineInfoResponseAddSyncMode(builder *flatbuffers.Builder, syncMode SyncMode) { + builder.PrependUint32Slot(0, uint32(syncMode), 0) +} +func DcOnlineInfoResponseAddCycleTime(builder *flatbuffers.Builder, cycleTime uint32) { + builder.PrependUint32Slot(1, cycleTime, 0) +} +func DcOnlineInfoResponseAddSyncShiftTime(builder *flatbuffers.Builder, syncShiftTime uint32) { + builder.PrependUint32Slot(2, syncShiftTime, 0) +} +func DcOnlineInfoResponseAddSyncWindowMonitoring(builder *flatbuffers.Builder, syncWindowMonitoring bool) { + builder.PrependBoolSlot(3, syncWindowMonitoring, false) +} +func DcOnlineInfoResponseAddDeviationLimit(builder *flatbuffers.Builder, deviationLimit uint32) { + builder.PrependUint32Slot(4, deviationLimit, 0) +} +func DcOnlineInfoResponseAddContinuousDelayCompensation(builder *flatbuffers.Builder, continuousDelayCompensation bool) { + builder.PrependBoolSlot(5, continuousDelayCompensation, false) +} +func DcOnlineInfoResponseAddSystemTime(builder *flatbuffers.Builder, systemTime uint64) { + builder.PrependUint64Slot(6, systemTime, 0) +} +func DcOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/EntryDescription.go b/pkg/fbs/comm/ethercat/master/fbs/EntryDescription.go index cd69ac2..49f62ef 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EntryDescription.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EntryDescription.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EntryDescriptionT struct { + Request *EntryDescriptionRequestT + Response *EntryDescriptionResponseT +} + +func (t *EntryDescriptionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + EntryDescriptionStart(builder) + EntryDescriptionAddRequest(builder, requestOffset) + EntryDescriptionAddResponse(builder, responseOffset) + return EntryDescriptionEnd(builder) +} + +func (rcv *EntryDescription) UnPackTo(t *EntryDescriptionT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *EntryDescription) UnPack() *EntryDescriptionT { + if rcv == nil { return nil } + t := &EntryDescriptionT{} + rcv.UnPackTo(t) + return t +} + type EntryDescription struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionRequest.go b/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionRequest.go index 0e79735..649d26a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionRequest.go @@ -6,6 +6,43 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EntryDescriptionRequestT struct { + AddressType Addresstype + Address uint16 + ObjectIndex uint16 + SubIndex byte + ValueInfo byte + MaxLength uint32 +} + +func (t *EntryDescriptionRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + EntryDescriptionRequestStart(builder) + EntryDescriptionRequestAddAddressType(builder, t.AddressType) + EntryDescriptionRequestAddAddress(builder, t.Address) + EntryDescriptionRequestAddObjectIndex(builder, t.ObjectIndex) + EntryDescriptionRequestAddSubIndex(builder, t.SubIndex) + EntryDescriptionRequestAddValueInfo(builder, t.ValueInfo) + EntryDescriptionRequestAddMaxLength(builder, t.MaxLength) + return EntryDescriptionRequestEnd(builder) +} + +func (rcv *EntryDescriptionRequest) UnPackTo(t *EntryDescriptionRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.ObjectIndex = rcv.ObjectIndex() + t.SubIndex = rcv.SubIndex() + t.ValueInfo = rcv.ValueInfo() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *EntryDescriptionRequest) UnPack() *EntryDescriptionRequestT { + if rcv == nil { return nil } + t := &EntryDescriptionRequestT{} + rcv.UnPackTo(t) + return t +} + type EntryDescriptionRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionResponse.go b/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionResponse.go index 7e76a10..8deb492 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EntryDescriptionResponse.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EntryDescriptionResponseT struct { + Data []byte +} + +func (t *EntryDescriptionResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + EntryDescriptionResponseStart(builder) + EntryDescriptionResponseAddData(builder, dataOffset) + return EntryDescriptionResponseEnd(builder) +} + +func (rcv *EntryDescriptionResponse) UnPackTo(t *EntryDescriptionResponseT) { + t.Data = rcv.DataBytes() +} + +func (rcv *EntryDescriptionResponse) UnPack() *EntryDescriptionResponseT { + if rcv == nil { return nil } + t := &EntryDescriptionResponseT{} + rcv.UnPackTo(t) + return t +} + type EntryDescriptionResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfo.go index 36dbe03..c99b4ca 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfo.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EoeConfigInfoT struct { + Request *AddressedRequestT + Response *EoeConfigInfoResponseT +} + +func (t *EoeConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + EoeConfigInfoStart(builder) + EoeConfigInfoAddRequest(builder, requestOffset) + EoeConfigInfoAddResponse(builder, responseOffset) + return EoeConfigInfoEnd(builder) +} + +func (rcv *EoeConfigInfo) UnPackTo(t *EoeConfigInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *EoeConfigInfo) UnPack() *EoeConfigInfoT { + if rcv == nil { return nil } + t := &EoeConfigInfoT{} + rcv.UnPackTo(t) + return t +} + type EoeConfigInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfoResponse.go index 71d7eb3..52e4df4 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EoeConfigInfoResponse.go @@ -6,6 +6,64 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EoeConfigInfoResponseT struct { + MacAddress []byte + IpAddress []byte + SubnetMask []byte + DefaultGateway []byte + DnsIpAddress []byte + DnsName string +} + +func (t *EoeConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + macAddressOffset := flatbuffers.UOffsetT(0) + if t.MacAddress != nil { + macAddressOffset = builder.CreateByteString(t.MacAddress) + } + ipAddressOffset := flatbuffers.UOffsetT(0) + if t.IpAddress != nil { + ipAddressOffset = builder.CreateByteString(t.IpAddress) + } + subnetMaskOffset := flatbuffers.UOffsetT(0) + if t.SubnetMask != nil { + subnetMaskOffset = builder.CreateByteString(t.SubnetMask) + } + defaultGatewayOffset := flatbuffers.UOffsetT(0) + if t.DefaultGateway != nil { + defaultGatewayOffset = builder.CreateByteString(t.DefaultGateway) + } + dnsIpAddressOffset := flatbuffers.UOffsetT(0) + if t.DnsIpAddress != nil { + dnsIpAddressOffset = builder.CreateByteString(t.DnsIpAddress) + } + dnsNameOffset := builder.CreateString(t.DnsName) + EoeConfigInfoResponseStart(builder) + EoeConfigInfoResponseAddMacAddress(builder, macAddressOffset) + EoeConfigInfoResponseAddIpAddress(builder, ipAddressOffset) + EoeConfigInfoResponseAddSubnetMask(builder, subnetMaskOffset) + EoeConfigInfoResponseAddDefaultGateway(builder, defaultGatewayOffset) + EoeConfigInfoResponseAddDnsIpAddress(builder, dnsIpAddressOffset) + EoeConfigInfoResponseAddDnsName(builder, dnsNameOffset) + return EoeConfigInfoResponseEnd(builder) +} + +func (rcv *EoeConfigInfoResponse) UnPackTo(t *EoeConfigInfoResponseT) { + t.MacAddress = rcv.MacAddressBytes() + t.IpAddress = rcv.IpAddressBytes() + t.SubnetMask = rcv.SubnetMaskBytes() + t.DefaultGateway = rcv.DefaultGatewayBytes() + t.DnsIpAddress = rcv.DnsIpAddressBytes() + t.DnsName = string(rcv.DnsName()) +} + +func (rcv *EoeConfigInfoResponse) UnPack() *EoeConfigInfoResponseT { + if rcv == nil { return nil } + t := &EoeConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + type EoeConfigInfoResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EthercatIdentityInfo.go b/pkg/fbs/comm/ethercat/master/fbs/EthercatIdentityInfo.go index af37376..e86507b 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EthercatIdentityInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EthercatIdentityInfo.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EthercatIdentityInfoT struct { + VendorId uint32 + ProductCode uint32 + RevisionNumber uint32 + SerialNumber uint32 +} + +func (t *EthercatIdentityInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateEthercatIdentityInfo(builder, t.VendorId, t.ProductCode, t.RevisionNumber, t.SerialNumber) +} +func (rcv *EthercatIdentityInfo) UnPackTo(t *EthercatIdentityInfoT) { + t.VendorId = rcv.VendorId() + t.ProductCode = rcv.ProductCode() + t.RevisionNumber = rcv.RevisionNumber() + t.SerialNumber = rcv.SerialNumber() +} + +func (rcv *EthercatIdentityInfo) UnPack() *EthercatIdentityInfoT { + if rcv == nil { return nil } + t := &EthercatIdentityInfoT{} + rcv.UnPackTo(t) + return t +} + type EthercatIdentityInfo struct { _tab flatbuffers.Struct } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EthercatMailboxInfo.go b/pkg/fbs/comm/ethercat/master/fbs/EthercatMailboxInfo.go index 2162bb5..0edfc68 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EthercatMailboxInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EthercatMailboxInfo.go @@ -6,6 +6,27 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EthercatMailboxInfoT struct { + SizeIn uint32 + SizeOut uint32 +} + +func (t *EthercatMailboxInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateEthercatMailboxInfo(builder, t.SizeIn, t.SizeOut) +} +func (rcv *EthercatMailboxInfo) UnPackTo(t *EthercatMailboxInfoT) { + t.SizeIn = rcv.SizeIn() + t.SizeOut = rcv.SizeOut() +} + +func (rcv *EthercatMailboxInfo) UnPack() *EthercatMailboxInfoT { + if rcv == nil { return nil } + t := &EthercatMailboxInfoT{} + rcv.UnPackTo(t) + return t +} + type EthercatMailboxInfo struct { _tab flatbuffers.Struct } diff --git a/pkg/fbs/comm/ethercat/master/fbs/EthercatMemoryInfo.go b/pkg/fbs/comm/ethercat/master/fbs/EthercatMemoryInfo.go index be3c900..a40094c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/EthercatMemoryInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/EthercatMemoryInfo.go @@ -6,6 +6,27 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EthercatMemoryInfoT struct { + Offset uint32 + Size uint32 +} + +func (t *EthercatMemoryInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateEthercatMemoryInfo(builder, t.Offset, t.Size) +} +func (rcv *EthercatMemoryInfo) UnPackTo(t *EthercatMemoryInfoT) { + t.Offset = rcv.Offset() + t.Size = rcv.Size() +} + +func (rcv *EthercatMemoryInfo) UnPack() *EthercatMemoryInfoT { + if rcv == nil { return nil } + t := &EthercatMemoryInfoT{} + rcv.UnPackTo(t) + return t +} + type EthercatMemoryInfo struct { _tab flatbuffers.Struct } diff --git a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfig.go b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfig.go index e4985df..928d731 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfig.go +++ b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfig.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type FieldbusConfigT struct { + Request *FieldbusConfigRequestT + Response *FieldbusConfigResponseT +} + +func (t *FieldbusConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + FieldbusConfigStart(builder) + FieldbusConfigAddRequest(builder, requestOffset) + FieldbusConfigAddResponse(builder, responseOffset) + return FieldbusConfigEnd(builder) +} + +func (rcv *FieldbusConfig) UnPackTo(t *FieldbusConfigT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *FieldbusConfig) UnPack() *FieldbusConfigT { + if rcv == nil { return nil } + t := &FieldbusConfigT{} + rcv.UnPackTo(t) + return t +} + type FieldbusConfig struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigRequest.go b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigRequest.go index 4b33bab..6285d88 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigRequest.go @@ -6,6 +6,39 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type FieldbusConfigRequestT struct { + Ini []byte + Eni []byte +} + +func (t *FieldbusConfigRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + iniOffset := flatbuffers.UOffsetT(0) + if t.Ini != nil { + iniOffset = builder.CreateByteString(t.Ini) + } + eniOffset := flatbuffers.UOffsetT(0) + if t.Eni != nil { + eniOffset = builder.CreateByteString(t.Eni) + } + FieldbusConfigRequestStart(builder) + FieldbusConfigRequestAddIni(builder, iniOffset) + FieldbusConfigRequestAddEni(builder, eniOffset) + return FieldbusConfigRequestEnd(builder) +} + +func (rcv *FieldbusConfigRequest) UnPackTo(t *FieldbusConfigRequestT) { + t.Ini = rcv.IniBytes() + t.Eni = rcv.EniBytes() +} + +func (rcv *FieldbusConfigRequest) UnPack() *FieldbusConfigRequestT { + if rcv == nil { return nil } + t := &FieldbusConfigRequestT{} + rcv.UnPackTo(t) + return t +} + type FieldbusConfigRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigResponse.go b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigResponse.go index fdbe324..80f360a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/FieldbusConfigResponse.go @@ -6,6 +6,39 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type FieldbusConfigResponseT struct { + Ini []byte + Eni []byte +} + +func (t *FieldbusConfigResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + iniOffset := flatbuffers.UOffsetT(0) + if t.Ini != nil { + iniOffset = builder.CreateByteString(t.Ini) + } + eniOffset := flatbuffers.UOffsetT(0) + if t.Eni != nil { + eniOffset = builder.CreateByteString(t.Eni) + } + FieldbusConfigResponseStart(builder) + FieldbusConfigResponseAddIni(builder, iniOffset) + FieldbusConfigResponseAddEni(builder, eniOffset) + return FieldbusConfigResponseEnd(builder) +} + +func (rcv *FieldbusConfigResponse) UnPackTo(t *FieldbusConfigResponseT) { + t.Ini = rcv.IniBytes() + t.Eni = rcv.EniBytes() +} + +func (rcv *FieldbusConfigResponse) UnPack() *FieldbusConfigResponseT { + if rcv == nil { return nil } + t := &FieldbusConfigResponseT{} + rcv.UnPackTo(t) + return t +} + type FieldbusConfigResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/Foe.go b/pkg/fbs/comm/ethercat/master/fbs/Foe.go new file mode 100644 index 0000000..bffe0f3 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/Foe.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FoeT struct { + Request *FoeRequestT + Response *FoeResponseT +} + +func (t *FoeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + FoeStart(builder) + FoeAddRequest(builder, requestOffset) + FoeAddResponse(builder, responseOffset) + return FoeEnd(builder) +} + +func (rcv *Foe) UnPackTo(t *FoeT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *Foe) UnPack() *FoeT { + if rcv == nil { return nil } + t := &FoeT{} + rcv.UnPackTo(t) + return t +} + +type Foe struct { + _tab flatbuffers.Table +} + +func GetRootAsFoe(buf []byte, offset flatbuffers.UOffsetT) *Foe { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Foe{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFoe(buf []byte, offset flatbuffers.UOffsetT) *Foe { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Foe{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Foe) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Foe) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Foe) Request(obj *FoeRequest) *FoeRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(FoeRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Foe) Response(obj *FoeResponse) *FoeResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(FoeResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func FoeStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func FoeAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func FoeAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func FoeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FoeRequest.go b/pkg/fbs/comm/ethercat/master/fbs/FoeRequest.go new file mode 100644 index 0000000..ac36fb7 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FoeRequest.go @@ -0,0 +1,212 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FoeRequestT struct { + AddressType Addresstype + Address uint16 + Data []byte + MaxLength uint32 + Filename string + Password uint32 + Timeout uint32 +} + +func (t *FoeRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + filenameOffset := builder.CreateString(t.Filename) + FoeRequestStart(builder) + FoeRequestAddAddressType(builder, t.AddressType) + FoeRequestAddAddress(builder, t.Address) + FoeRequestAddData(builder, dataOffset) + FoeRequestAddMaxLength(builder, t.MaxLength) + FoeRequestAddFilename(builder, filenameOffset) + FoeRequestAddPassword(builder, t.Password) + FoeRequestAddTimeout(builder, t.Timeout) + return FoeRequestEnd(builder) +} + +func (rcv *FoeRequest) UnPackTo(t *FoeRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.Data = rcv.DataBytes() + t.MaxLength = rcv.MaxLength() + t.Filename = string(rcv.Filename()) + t.Password = rcv.Password() + t.Timeout = rcv.Timeout() +} + +func (rcv *FoeRequest) UnPack() *FoeRequestT { + if rcv == nil { return nil } + t := &FoeRequestT{} + rcv.UnPackTo(t) + return t +} + +type FoeRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsFoeRequest(buf []byte, offset flatbuffers.UOffsetT) *FoeRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FoeRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFoeRequest(buf []byte, offset flatbuffers.UOffsetT) *FoeRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FoeRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FoeRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FoeRequest) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FoeRequest) AddressType() Addresstype { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return Addresstype(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *FoeRequest) MutateAddressType(n Addresstype) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *FoeRequest) Address() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FoeRequest) MutateAddress(n uint16) bool { + return rcv._tab.MutateUint16Slot(6, n) +} + +func (rcv *FoeRequest) Data(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *FoeRequest) DataLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *FoeRequest) DataBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *FoeRequest) MutateData(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func (rcv *FoeRequest) MaxLength() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FoeRequest) MutateMaxLength(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func (rcv *FoeRequest) Filename() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *FoeRequest) Password() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FoeRequest) MutatePassword(n uint32) bool { + return rcv._tab.MutateUint32Slot(14, n) +} + +func (rcv *FoeRequest) Timeout() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FoeRequest) MutateTimeout(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +func FoeRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func FoeRequestAddAddressType(builder *flatbuffers.Builder, addressType Addresstype) { + builder.PrependByteSlot(0, byte(addressType), 0) +} +func FoeRequestAddAddress(builder *flatbuffers.Builder, address uint16) { + builder.PrependUint16Slot(1, address, 0) +} +func FoeRequestAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(data), 0) +} +func FoeRequestStartDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func FoeRequestAddMaxLength(builder *flatbuffers.Builder, maxLength uint32) { + builder.PrependUint32Slot(3, maxLength, 0) +} +func FoeRequestAddFilename(builder *flatbuffers.Builder, filename flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(filename), 0) +} +func FoeRequestAddPassword(builder *flatbuffers.Builder, password uint32) { + builder.PrependUint32Slot(5, password, 0) +} +func FoeRequestAddTimeout(builder *flatbuffers.Builder, timeout uint32) { + builder.PrependUint32Slot(6, timeout, 0) +} +func FoeRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FoeResponse.go b/pkg/fbs/comm/ethercat/master/fbs/FoeResponse.go new file mode 100644 index 0000000..0f7c5ac --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FoeResponse.go @@ -0,0 +1,107 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FoeResponseT struct { + Data []byte +} + +func (t *FoeResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + FoeResponseStart(builder) + FoeResponseAddData(builder, dataOffset) + return FoeResponseEnd(builder) +} + +func (rcv *FoeResponse) UnPackTo(t *FoeResponseT) { + t.Data = rcv.DataBytes() +} + +func (rcv *FoeResponse) UnPack() *FoeResponseT { + if rcv == nil { return nil } + t := &FoeResponseT{} + rcv.UnPackTo(t) + return t +} + +type FoeResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsFoeResponse(buf []byte, offset flatbuffers.UOffsetT) *FoeResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FoeResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFoeResponse(buf []byte, offset flatbuffers.UOffsetT) *FoeResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FoeResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FoeResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FoeResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FoeResponse) Data(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *FoeResponse) DataLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *FoeResponse) DataBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *FoeResponse) MutateData(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func FoeResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func FoeResponseAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(data), 0) +} +func FoeResponseStartDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func FoeResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCounters.go b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCounters.go new file mode 100644 index 0000000..eeff5c4 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCounters.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FrameStatisticCountersT struct { + Response *FrameStatisticCountersResponseT +} + +func (t *FrameStatisticCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + FrameStatisticCountersStart(builder) + FrameStatisticCountersAddResponse(builder, responseOffset) + return FrameStatisticCountersEnd(builder) +} + +func (rcv *FrameStatisticCounters) UnPackTo(t *FrameStatisticCountersT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *FrameStatisticCounters) UnPack() *FrameStatisticCountersT { + if rcv == nil { return nil } + t := &FrameStatisticCountersT{} + rcv.UnPackTo(t) + return t +} + +type FrameStatisticCounters struct { + _tab flatbuffers.Table +} + +func GetRootAsFrameStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FrameStatisticCounters{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFrameStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FrameStatisticCounters{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FrameStatisticCounters) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FrameStatisticCounters) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FrameStatisticCounters) Response(obj *FrameStatisticCountersResponse) *FrameStatisticCountersResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(FrameStatisticCountersResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func FrameStatisticCountersStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func FrameStatisticCountersAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func FrameStatisticCountersEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCountersResponse.go b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCountersResponse.go new file mode 100644 index 0000000..e30486c --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticCountersResponse.go @@ -0,0 +1,222 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FrameStatisticCountersResponseT struct { + NumTxFrames uint32 + NumRxFrames uint32 + NumCyclicFrames uint32 + NumCyclicDatagrams uint32 + NumAcyclicFrames uint32 + NumAcyclicDatagrams uint32 + NumLostFrames uint32 + NumLostCyclicFrames uint32 + NumLostAcyclicFrames uint32 +} + +func (t *FrameStatisticCountersResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + FrameStatisticCountersResponseStart(builder) + FrameStatisticCountersResponseAddNumTxFrames(builder, t.NumTxFrames) + FrameStatisticCountersResponseAddNumRxFrames(builder, t.NumRxFrames) + FrameStatisticCountersResponseAddNumCyclicFrames(builder, t.NumCyclicFrames) + FrameStatisticCountersResponseAddNumCyclicDatagrams(builder, t.NumCyclicDatagrams) + FrameStatisticCountersResponseAddNumAcyclicFrames(builder, t.NumAcyclicFrames) + FrameStatisticCountersResponseAddNumAcyclicDatagrams(builder, t.NumAcyclicDatagrams) + FrameStatisticCountersResponseAddNumLostFrames(builder, t.NumLostFrames) + FrameStatisticCountersResponseAddNumLostCyclicFrames(builder, t.NumLostCyclicFrames) + FrameStatisticCountersResponseAddNumLostAcyclicFrames(builder, t.NumLostAcyclicFrames) + return FrameStatisticCountersResponseEnd(builder) +} + +func (rcv *FrameStatisticCountersResponse) UnPackTo(t *FrameStatisticCountersResponseT) { + t.NumTxFrames = rcv.NumTxFrames() + t.NumRxFrames = rcv.NumRxFrames() + t.NumCyclicFrames = rcv.NumCyclicFrames() + t.NumCyclicDatagrams = rcv.NumCyclicDatagrams() + t.NumAcyclicFrames = rcv.NumAcyclicFrames() + t.NumAcyclicDatagrams = rcv.NumAcyclicDatagrams() + t.NumLostFrames = rcv.NumLostFrames() + t.NumLostCyclicFrames = rcv.NumLostCyclicFrames() + t.NumLostAcyclicFrames = rcv.NumLostAcyclicFrames() +} + +func (rcv *FrameStatisticCountersResponse) UnPack() *FrameStatisticCountersResponseT { + if rcv == nil { return nil } + t := &FrameStatisticCountersResponseT{} + rcv.UnPackTo(t) + return t +} + +type FrameStatisticCountersResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsFrameStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FrameStatisticCountersResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFrameStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FrameStatisticCountersResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FrameStatisticCountersResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FrameStatisticCountersResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FrameStatisticCountersResponse) NumTxFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumTxFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *FrameStatisticCountersResponse) NumRxFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumRxFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *FrameStatisticCountersResponse) NumCyclicFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumCyclicFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *FrameStatisticCountersResponse) NumCyclicDatagrams() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumCyclicDatagrams(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func (rcv *FrameStatisticCountersResponse) NumAcyclicFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumAcyclicFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func (rcv *FrameStatisticCountersResponse) NumAcyclicDatagrams() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumAcyclicDatagrams(n uint32) bool { + return rcv._tab.MutateUint32Slot(14, n) +} + +func (rcv *FrameStatisticCountersResponse) NumLostFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumLostFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +func (rcv *FrameStatisticCountersResponse) NumLostCyclicFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumLostCyclicFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + +func (rcv *FrameStatisticCountersResponse) NumLostAcyclicFrames() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *FrameStatisticCountersResponse) MutateNumLostAcyclicFrames(n uint32) bool { + return rcv._tab.MutateUint32Slot(20, n) +} + +func FrameStatisticCountersResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(9) +} +func FrameStatisticCountersResponseAddNumTxFrames(builder *flatbuffers.Builder, numTxFrames uint32) { + builder.PrependUint32Slot(0, numTxFrames, 0) +} +func FrameStatisticCountersResponseAddNumRxFrames(builder *flatbuffers.Builder, numRxFrames uint32) { + builder.PrependUint32Slot(1, numRxFrames, 0) +} +func FrameStatisticCountersResponseAddNumCyclicFrames(builder *flatbuffers.Builder, numCyclicFrames uint32) { + builder.PrependUint32Slot(2, numCyclicFrames, 0) +} +func FrameStatisticCountersResponseAddNumCyclicDatagrams(builder *flatbuffers.Builder, numCyclicDatagrams uint32) { + builder.PrependUint32Slot(3, numCyclicDatagrams, 0) +} +func FrameStatisticCountersResponseAddNumAcyclicFrames(builder *flatbuffers.Builder, numAcyclicFrames uint32) { + builder.PrependUint32Slot(4, numAcyclicFrames, 0) +} +func FrameStatisticCountersResponseAddNumAcyclicDatagrams(builder *flatbuffers.Builder, numAcyclicDatagrams uint32) { + builder.PrependUint32Slot(5, numAcyclicDatagrams, 0) +} +func FrameStatisticCountersResponseAddNumLostFrames(builder *flatbuffers.Builder, numLostFrames uint32) { + builder.PrependUint32Slot(6, numLostFrames, 0) +} +func FrameStatisticCountersResponseAddNumLostCyclicFrames(builder *flatbuffers.Builder, numLostCyclicFrames uint32) { + builder.PrependUint32Slot(7, numLostCyclicFrames, 0) +} +func FrameStatisticCountersResponseAddNumLostAcyclicFrames(builder *flatbuffers.Builder, numLostAcyclicFrames uint32) { + builder.PrependUint32Slot(8, numLostAcyclicFrames, 0) +} +func FrameStatisticCountersResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticReset.go b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticReset.go new file mode 100644 index 0000000..69a29f7 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticReset.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FrameStatisticResetT struct { + Request *FrameStatisticResetRequestT +} + +func (t *FrameStatisticResetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + FrameStatisticResetStart(builder) + FrameStatisticResetAddRequest(builder, requestOffset) + return FrameStatisticResetEnd(builder) +} + +func (rcv *FrameStatisticReset) UnPackTo(t *FrameStatisticResetT) { + t.Request = rcv.Request(nil).UnPack() +} + +func (rcv *FrameStatisticReset) UnPack() *FrameStatisticResetT { + if rcv == nil { return nil } + t := &FrameStatisticResetT{} + rcv.UnPackTo(t) + return t +} + +type FrameStatisticReset struct { + _tab flatbuffers.Table +} + +func GetRootAsFrameStatisticReset(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticReset { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FrameStatisticReset{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFrameStatisticReset(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticReset { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FrameStatisticReset{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FrameStatisticReset) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FrameStatisticReset) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FrameStatisticReset) Request(obj *FrameStatisticResetRequest) *FrameStatisticResetRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(FrameStatisticResetRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func FrameStatisticResetStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func FrameStatisticResetAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func FrameStatisticResetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticResetRequest.go b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticResetRequest.go new file mode 100644 index 0000000..394eec7 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/FrameStatisticResetRequest.go @@ -0,0 +1,186 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FrameStatisticResetRequestT struct { + NumTxFrames bool + NumRxFrames bool + NumLostFrames bool + NumCyclicFrames bool + NumCyclicDatagrams bool + NumAcyclicFrames bool + NumAcyclicDatagrams bool +} + +func (t *FrameStatisticResetRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + FrameStatisticResetRequestStart(builder) + FrameStatisticResetRequestAddNumTxFrames(builder, t.NumTxFrames) + FrameStatisticResetRequestAddNumRxFrames(builder, t.NumRxFrames) + FrameStatisticResetRequestAddNumLostFrames(builder, t.NumLostFrames) + FrameStatisticResetRequestAddNumCyclicFrames(builder, t.NumCyclicFrames) + FrameStatisticResetRequestAddNumCyclicDatagrams(builder, t.NumCyclicDatagrams) + FrameStatisticResetRequestAddNumAcyclicFrames(builder, t.NumAcyclicFrames) + FrameStatisticResetRequestAddNumAcyclicDatagrams(builder, t.NumAcyclicDatagrams) + return FrameStatisticResetRequestEnd(builder) +} + +func (rcv *FrameStatisticResetRequest) UnPackTo(t *FrameStatisticResetRequestT) { + t.NumTxFrames = rcv.NumTxFrames() + t.NumRxFrames = rcv.NumRxFrames() + t.NumLostFrames = rcv.NumLostFrames() + t.NumCyclicFrames = rcv.NumCyclicFrames() + t.NumCyclicDatagrams = rcv.NumCyclicDatagrams() + t.NumAcyclicFrames = rcv.NumAcyclicFrames() + t.NumAcyclicDatagrams = rcv.NumAcyclicDatagrams() +} + +func (rcv *FrameStatisticResetRequest) UnPack() *FrameStatisticResetRequestT { + if rcv == nil { return nil } + t := &FrameStatisticResetRequestT{} + rcv.UnPackTo(t) + return t +} + +type FrameStatisticResetRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsFrameStatisticResetRequest(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticResetRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FrameStatisticResetRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFrameStatisticResetRequest(buf []byte, offset flatbuffers.UOffsetT) *FrameStatisticResetRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FrameStatisticResetRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FrameStatisticResetRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FrameStatisticResetRequest) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FrameStatisticResetRequest) NumTxFrames() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumTxFrames(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func (rcv *FrameStatisticResetRequest) NumRxFrames() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumRxFrames(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *FrameStatisticResetRequest) NumLostFrames() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumLostFrames(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func (rcv *FrameStatisticResetRequest) NumCyclicFrames() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumCyclicFrames(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func (rcv *FrameStatisticResetRequest) NumCyclicDatagrams() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumCyclicDatagrams(n bool) bool { + return rcv._tab.MutateBoolSlot(12, n) +} + +func (rcv *FrameStatisticResetRequest) NumAcyclicFrames() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumAcyclicFrames(n bool) bool { + return rcv._tab.MutateBoolSlot(14, n) +} + +func (rcv *FrameStatisticResetRequest) NumAcyclicDatagrams() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *FrameStatisticResetRequest) MutateNumAcyclicDatagrams(n bool) bool { + return rcv._tab.MutateBoolSlot(16, n) +} + +func FrameStatisticResetRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func FrameStatisticResetRequestAddNumTxFrames(builder *flatbuffers.Builder, numTxFrames bool) { + builder.PrependBoolSlot(0, numTxFrames, false) +} +func FrameStatisticResetRequestAddNumRxFrames(builder *flatbuffers.Builder, numRxFrames bool) { + builder.PrependBoolSlot(1, numRxFrames, false) +} +func FrameStatisticResetRequestAddNumLostFrames(builder *flatbuffers.Builder, numLostFrames bool) { + builder.PrependBoolSlot(2, numLostFrames, false) +} +func FrameStatisticResetRequestAddNumCyclicFrames(builder *flatbuffers.Builder, numCyclicFrames bool) { + builder.PrependBoolSlot(3, numCyclicFrames, false) +} +func FrameStatisticResetRequestAddNumCyclicDatagrams(builder *flatbuffers.Builder, numCyclicDatagrams bool) { + builder.PrependBoolSlot(4, numCyclicDatagrams, false) +} +func FrameStatisticResetRequestAddNumAcyclicFrames(builder *flatbuffers.Builder, numAcyclicFrames bool) { + builder.PrependBoolSlot(5, numAcyclicFrames, false) +} +func FrameStatisticResetRequestAddNumAcyclicDatagrams(builder *flatbuffers.Builder, numAcyclicDatagrams bool) { + builder.PrependBoolSlot(6, numAcyclicDatagrams, false) +} +func FrameStatisticResetRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/InhibitTime.go b/pkg/fbs/comm/ethercat/master/fbs/InhibitTime.go new file mode 100644 index 0000000..71cf958 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/InhibitTime.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type InhibitTimeT struct { + Response *InhibitTimeResponseT +} + +func (t *InhibitTimeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + InhibitTimeStart(builder) + InhibitTimeAddResponse(builder, responseOffset) + return InhibitTimeEnd(builder) +} + +func (rcv *InhibitTime) UnPackTo(t *InhibitTimeT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *InhibitTime) UnPack() *InhibitTimeT { + if rcv == nil { return nil } + t := &InhibitTimeT{} + rcv.UnPackTo(t) + return t +} + +type InhibitTime struct { + _tab flatbuffers.Table +} + +func GetRootAsInhibitTime(buf []byte, offset flatbuffers.UOffsetT) *InhibitTime { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &InhibitTime{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsInhibitTime(buf []byte, offset flatbuffers.UOffsetT) *InhibitTime { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &InhibitTime{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *InhibitTime) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *InhibitTime) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *InhibitTime) Response(obj *InhibitTimeResponse) *InhibitTimeResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(InhibitTimeResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func InhibitTimeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func InhibitTimeAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func InhibitTimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/InhibitTimeResponse.go b/pkg/fbs/comm/ethercat/master/fbs/InhibitTimeResponse.go new file mode 100644 index 0000000..8375f7f --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/InhibitTimeResponse.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type InhibitTimeResponseT struct { + Time uint32 +} + +func (t *InhibitTimeResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + InhibitTimeResponseStart(builder) + InhibitTimeResponseAddTime(builder, t.Time) + return InhibitTimeResponseEnd(builder) +} + +func (rcv *InhibitTimeResponse) UnPackTo(t *InhibitTimeResponseT) { + t.Time = rcv.Time() +} + +func (rcv *InhibitTimeResponse) UnPack() *InhibitTimeResponseT { + if rcv == nil { return nil } + t := &InhibitTimeResponseT{} + rcv.UnPackTo(t) + return t +} + +type InhibitTimeResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsInhibitTimeResponse(buf []byte, offset flatbuffers.UOffsetT) *InhibitTimeResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &InhibitTimeResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsInhibitTimeResponse(buf []byte, offset flatbuffers.UOffsetT) *InhibitTimeResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &InhibitTimeResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *InhibitTimeResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *InhibitTimeResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *InhibitTimeResponse) Time() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *InhibitTimeResponse) MutateTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func InhibitTimeResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func InhibitTimeResponseAddTime(builder *flatbuffers.Builder, time uint32) { + builder.PrependUint32Slot(0, time, 0) +} +func InhibitTimeResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/InstancesCreate.go b/pkg/fbs/comm/ethercat/master/fbs/InstancesCreate.go index 5725a13..355be47 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/InstancesCreate.go +++ b/pkg/fbs/comm/ethercat/master/fbs/InstancesCreate.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type InstancesCreateT struct { + Request *InstancesCreateRequestT +} + +func (t *InstancesCreateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + InstancesCreateStart(builder) + InstancesCreateAddRequest(builder, requestOffset) + return InstancesCreateEnd(builder) +} + +func (rcv *InstancesCreate) UnPackTo(t *InstancesCreateT) { + t.Request = rcv.Request(nil).UnPack() +} + +func (rcv *InstancesCreate) UnPack() *InstancesCreateT { + if rcv == nil { return nil } + t := &InstancesCreateT{} + rcv.UnPackTo(t) + return t +} + type InstancesCreate struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/InstancesCreateRequest.go b/pkg/fbs/comm/ethercat/master/fbs/InstancesCreateRequest.go index 7d2fac3..773ab56 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/InstancesCreateRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/InstancesCreateRequest.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type InstancesCreateRequestT struct { + InstanceName string + Port string + LinkLayer string + Arguments string +} + +func (t *InstancesCreateRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + instanceNameOffset := builder.CreateString(t.InstanceName) + portOffset := builder.CreateString(t.Port) + linkLayerOffset := builder.CreateString(t.LinkLayer) + argumentsOffset := builder.CreateString(t.Arguments) + InstancesCreateRequestStart(builder) + InstancesCreateRequestAddInstanceName(builder, instanceNameOffset) + InstancesCreateRequestAddPort(builder, portOffset) + InstancesCreateRequestAddLinkLayer(builder, linkLayerOffset) + InstancesCreateRequestAddArguments(builder, argumentsOffset) + return InstancesCreateRequestEnd(builder) +} + +func (rcv *InstancesCreateRequest) UnPackTo(t *InstancesCreateRequestT) { + t.InstanceName = string(rcv.InstanceName()) + t.Port = string(rcv.Port()) + t.LinkLayer = string(rcv.LinkLayer()) + t.Arguments = string(rcv.Arguments()) +} + +func (rcv *InstancesCreateRequest) UnPack() *InstancesCreateRequestT { + if rcv == nil { return nil } + t := &InstancesCreateRequestT{} + rcv.UnPackTo(t) + return t +} + type InstancesCreateRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/Interface.go b/pkg/fbs/comm/ethercat/master/fbs/Interface.go index e34b822..b9e8031 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/Interface.go +++ b/pkg/fbs/comm/ethercat/master/fbs/Interface.go @@ -6,6 +6,59 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type InterfaceT struct { + Port string + Device string + LinkLayer string + CapabilityList []*CapabilityT +} + +func (t *InterfaceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + portOffset := builder.CreateString(t.Port) + deviceOffset := builder.CreateString(t.Device) + linkLayerOffset := builder.CreateString(t.LinkLayer) + capabilityListOffset := flatbuffers.UOffsetT(0) + if t.CapabilityList != nil { + capabilityListLength := len(t.CapabilityList) + capabilityListOffsets := make([]flatbuffers.UOffsetT, capabilityListLength) + for j := 0; j < capabilityListLength; j++ { + capabilityListOffsets[j] = t.CapabilityList[j].Pack(builder) + } + InterfaceStartCapabilityListVector(builder, capabilityListLength) + for j := capabilityListLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(capabilityListOffsets[j]) + } + capabilityListOffset = builder.EndVector(capabilityListLength) + } + InterfaceStart(builder) + InterfaceAddPort(builder, portOffset) + InterfaceAddDevice(builder, deviceOffset) + InterfaceAddLinkLayer(builder, linkLayerOffset) + InterfaceAddCapabilityList(builder, capabilityListOffset) + return InterfaceEnd(builder) +} + +func (rcv *Interface) UnPackTo(t *InterfaceT) { + t.Port = string(rcv.Port()) + t.Device = string(rcv.Device()) + t.LinkLayer = string(rcv.LinkLayer()) + capabilityListLength := rcv.CapabilityListLength() + t.CapabilityList = make([]*CapabilityT, capabilityListLength) + for j := 0; j < capabilityListLength; j++ { + x := Capability{} + rcv.CapabilityList(&x, j) + t.CapabilityList[j] = x.UnPack() + } +} + +func (rcv *Interface) UnPack() *InterfaceT { + if rcv == nil { return nil } + t := &InterfaceT{} + rcv.UnPackTo(t) + return t +} + type Interface struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfo.go new file mode 100644 index 0000000..df0e555 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfo.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LinkLayerConfigInfoT struct { + Response *LinkLayerConfigInfoResponseT +} + +func (t *LinkLayerConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + LinkLayerConfigInfoStart(builder) + LinkLayerConfigInfoAddResponse(builder, responseOffset) + return LinkLayerConfigInfoEnd(builder) +} + +func (rcv *LinkLayerConfigInfo) UnPackTo(t *LinkLayerConfigInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *LinkLayerConfigInfo) UnPack() *LinkLayerConfigInfoT { + if rcv == nil { return nil } + t := &LinkLayerConfigInfoT{} + rcv.UnPackTo(t) + return t +} + +type LinkLayerConfigInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsLinkLayerConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LinkLayerConfigInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLinkLayerConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LinkLayerConfigInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LinkLayerConfigInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LinkLayerConfigInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *LinkLayerConfigInfo) Response(obj *LinkLayerConfigInfoResponse) *LinkLayerConfigInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(LinkLayerConfigInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func LinkLayerConfigInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func LinkLayerConfigInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func LinkLayerConfigInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfoResponse.go new file mode 100644 index 0000000..73ebb78 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerConfigInfoResponse.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LinkLayerConfigInfoResponseT struct { + Port string + LinkLayer string + Arguments string +} + +func (t *LinkLayerConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + portOffset := builder.CreateString(t.Port) + linkLayerOffset := builder.CreateString(t.LinkLayer) + argumentsOffset := builder.CreateString(t.Arguments) + LinkLayerConfigInfoResponseStart(builder) + LinkLayerConfigInfoResponseAddPort(builder, portOffset) + LinkLayerConfigInfoResponseAddLinkLayer(builder, linkLayerOffset) + LinkLayerConfigInfoResponseAddArguments(builder, argumentsOffset) + return LinkLayerConfigInfoResponseEnd(builder) +} + +func (rcv *LinkLayerConfigInfoResponse) UnPackTo(t *LinkLayerConfigInfoResponseT) { + t.Port = string(rcv.Port()) + t.LinkLayer = string(rcv.LinkLayer()) + t.Arguments = string(rcv.Arguments()) +} + +func (rcv *LinkLayerConfigInfoResponse) UnPack() *LinkLayerConfigInfoResponseT { + if rcv == nil { return nil } + t := &LinkLayerConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type LinkLayerConfigInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsLinkLayerConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LinkLayerConfigInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLinkLayerConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LinkLayerConfigInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LinkLayerConfigInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LinkLayerConfigInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *LinkLayerConfigInfoResponse) Port() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerConfigInfoResponse) LinkLayer() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerConfigInfoResponse) Arguments() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func LinkLayerConfigInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func LinkLayerConfigInfoResponseAddPort(builder *flatbuffers.Builder, port flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(port), 0) +} +func LinkLayerConfigInfoResponseAddLinkLayer(builder *flatbuffers.Builder, linkLayer flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(linkLayer), 0) +} +func LinkLayerConfigInfoResponseAddArguments(builder *flatbuffers.Builder, arguments flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(arguments), 0) +} +func LinkLayerConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfo.go b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfo.go new file mode 100644 index 0000000..cb31484 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfo.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LinkLayerOnlineInfoT struct { + Response *LinkLayerOnlineInfoResponseT +} + +func (t *LinkLayerOnlineInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + LinkLayerOnlineInfoStart(builder) + LinkLayerOnlineInfoAddResponse(builder, responseOffset) + return LinkLayerOnlineInfoEnd(builder) +} + +func (rcv *LinkLayerOnlineInfo) UnPackTo(t *LinkLayerOnlineInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *LinkLayerOnlineInfo) UnPack() *LinkLayerOnlineInfoT { + if rcv == nil { return nil } + t := &LinkLayerOnlineInfoT{} + rcv.UnPackTo(t) + return t +} + +type LinkLayerOnlineInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsLinkLayerOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LinkLayerOnlineInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLinkLayerOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LinkLayerOnlineInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LinkLayerOnlineInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LinkLayerOnlineInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *LinkLayerOnlineInfo) Response(obj *LinkLayerOnlineInfoResponse) *LinkLayerOnlineInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(LinkLayerOnlineInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func LinkLayerOnlineInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func LinkLayerOnlineInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func LinkLayerOnlineInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfoResponse.go new file mode 100644 index 0000000..2ce4e58 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkLayerOnlineInfoResponse.go @@ -0,0 +1,311 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LinkLayerOnlineInfoResponseT struct { + Port string + LinkLayer string + Arguments string + Message string + MacAddress []byte + FrameRepeatCntSupport bool + LinkSpeed uint32 + LinkMode LinkMode + LinkStatus LinkStatus + RefClockWidth uint32 + SystemTime uint64 + PhysicalErrorCnt uint32 + TelegramErrorCnt uint32 +} + +func (t *LinkLayerOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + portOffset := builder.CreateString(t.Port) + linkLayerOffset := builder.CreateString(t.LinkLayer) + argumentsOffset := builder.CreateString(t.Arguments) + messageOffset := builder.CreateString(t.Message) + macAddressOffset := flatbuffers.UOffsetT(0) + if t.MacAddress != nil { + macAddressOffset = builder.CreateByteString(t.MacAddress) + } + LinkLayerOnlineInfoResponseStart(builder) + LinkLayerOnlineInfoResponseAddPort(builder, portOffset) + LinkLayerOnlineInfoResponseAddLinkLayer(builder, linkLayerOffset) + LinkLayerOnlineInfoResponseAddArguments(builder, argumentsOffset) + LinkLayerOnlineInfoResponseAddMessage(builder, messageOffset) + LinkLayerOnlineInfoResponseAddMacAddress(builder, macAddressOffset) + LinkLayerOnlineInfoResponseAddFrameRepeatCntSupport(builder, t.FrameRepeatCntSupport) + LinkLayerOnlineInfoResponseAddLinkSpeed(builder, t.LinkSpeed) + LinkLayerOnlineInfoResponseAddLinkMode(builder, t.LinkMode) + LinkLayerOnlineInfoResponseAddLinkStatus(builder, t.LinkStatus) + LinkLayerOnlineInfoResponseAddRefClockWidth(builder, t.RefClockWidth) + LinkLayerOnlineInfoResponseAddSystemTime(builder, t.SystemTime) + LinkLayerOnlineInfoResponseAddPhysicalErrorCnt(builder, t.PhysicalErrorCnt) + LinkLayerOnlineInfoResponseAddTelegramErrorCnt(builder, t.TelegramErrorCnt) + return LinkLayerOnlineInfoResponseEnd(builder) +} + +func (rcv *LinkLayerOnlineInfoResponse) UnPackTo(t *LinkLayerOnlineInfoResponseT) { + t.Port = string(rcv.Port()) + t.LinkLayer = string(rcv.LinkLayer()) + t.Arguments = string(rcv.Arguments()) + t.Message = string(rcv.Message()) + t.MacAddress = rcv.MacAddressBytes() + t.FrameRepeatCntSupport = rcv.FrameRepeatCntSupport() + t.LinkSpeed = rcv.LinkSpeed() + t.LinkMode = rcv.LinkMode() + t.LinkStatus = rcv.LinkStatus() + t.RefClockWidth = rcv.RefClockWidth() + t.SystemTime = rcv.SystemTime() + t.PhysicalErrorCnt = rcv.PhysicalErrorCnt() + t.TelegramErrorCnt = rcv.TelegramErrorCnt() +} + +func (rcv *LinkLayerOnlineInfoResponse) UnPack() *LinkLayerOnlineInfoResponseT { + if rcv == nil { return nil } + t := &LinkLayerOnlineInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type LinkLayerOnlineInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsLinkLayerOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LinkLayerOnlineInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLinkLayerOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *LinkLayerOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LinkLayerOnlineInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LinkLayerOnlineInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LinkLayerOnlineInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *LinkLayerOnlineInfoResponse) Port() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerOnlineInfoResponse) LinkLayer() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerOnlineInfoResponse) Arguments() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerOnlineInfoResponse) Message() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerOnlineInfoResponse) MacAddress(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MacAddressLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MacAddressBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateMacAddress(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func (rcv *LinkLayerOnlineInfoResponse) FrameRepeatCntSupport() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateFrameRepeatCntSupport(n bool) bool { + return rcv._tab.MutateBoolSlot(14, n) +} + +func (rcv *LinkLayerOnlineInfoResponse) LinkSpeed() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateLinkSpeed(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +func (rcv *LinkLayerOnlineInfoResponse) LinkMode() LinkMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return LinkMode(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateLinkMode(n LinkMode) bool { + return rcv._tab.MutateUint32Slot(18, uint32(n)) +} + +func (rcv *LinkLayerOnlineInfoResponse) LinkStatus() LinkStatus { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return LinkStatus(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateLinkStatus(n LinkStatus) bool { + return rcv._tab.MutateUint32Slot(20, uint32(n)) +} + +func (rcv *LinkLayerOnlineInfoResponse) RefClockWidth() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateRefClockWidth(n uint32) bool { + return rcv._tab.MutateUint32Slot(22, n) +} + +func (rcv *LinkLayerOnlineInfoResponse) SystemTime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateSystemTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(24, n) +} + +func (rcv *LinkLayerOnlineInfoResponse) PhysicalErrorCnt() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutatePhysicalErrorCnt(n uint32) bool { + return rcv._tab.MutateUint32Slot(26, n) +} + +func (rcv *LinkLayerOnlineInfoResponse) TelegramErrorCnt() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *LinkLayerOnlineInfoResponse) MutateTelegramErrorCnt(n uint32) bool { + return rcv._tab.MutateUint32Slot(28, n) +} + +func LinkLayerOnlineInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(13) +} +func LinkLayerOnlineInfoResponseAddPort(builder *flatbuffers.Builder, port flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(port), 0) +} +func LinkLayerOnlineInfoResponseAddLinkLayer(builder *flatbuffers.Builder, linkLayer flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(linkLayer), 0) +} +func LinkLayerOnlineInfoResponseAddArguments(builder *flatbuffers.Builder, arguments flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(arguments), 0) +} +func LinkLayerOnlineInfoResponseAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(message), 0) +} +func LinkLayerOnlineInfoResponseAddMacAddress(builder *flatbuffers.Builder, macAddress flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(macAddress), 0) +} +func LinkLayerOnlineInfoResponseStartMacAddressVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func LinkLayerOnlineInfoResponseAddFrameRepeatCntSupport(builder *flatbuffers.Builder, frameRepeatCntSupport bool) { + builder.PrependBoolSlot(5, frameRepeatCntSupport, false) +} +func LinkLayerOnlineInfoResponseAddLinkSpeed(builder *flatbuffers.Builder, linkSpeed uint32) { + builder.PrependUint32Slot(6, linkSpeed, 0) +} +func LinkLayerOnlineInfoResponseAddLinkMode(builder *flatbuffers.Builder, linkMode LinkMode) { + builder.PrependUint32Slot(7, uint32(linkMode), 0) +} +func LinkLayerOnlineInfoResponseAddLinkStatus(builder *flatbuffers.Builder, linkStatus LinkStatus) { + builder.PrependUint32Slot(8, uint32(linkStatus), 0) +} +func LinkLayerOnlineInfoResponseAddRefClockWidth(builder *flatbuffers.Builder, refClockWidth uint32) { + builder.PrependUint32Slot(9, refClockWidth, 0) +} +func LinkLayerOnlineInfoResponseAddSystemTime(builder *flatbuffers.Builder, systemTime uint64) { + builder.PrependUint64Slot(10, systemTime, 0) +} +func LinkLayerOnlineInfoResponseAddPhysicalErrorCnt(builder *flatbuffers.Builder, physicalErrorCnt uint32) { + builder.PrependUint32Slot(11, physicalErrorCnt, 0) +} +func LinkLayerOnlineInfoResponseAddTelegramErrorCnt(builder *flatbuffers.Builder, telegramErrorCnt uint32) { + builder.PrependUint32Slot(12, telegramErrorCnt, 0) +} +func LinkLayerOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkMode.go b/pkg/fbs/comm/ethercat/master/fbs/LinkMode.go new file mode 100644 index 0000000..b3b7e83 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkMode.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type LinkMode uint32 + +const ( + LinkModeundefined LinkMode = 0 + LinkModeinterrupt LinkMode = 1 + LinkModepolling LinkMode = 2 +) + +var EnumNamesLinkMode = map[LinkMode]string{ + LinkModeundefined: "undefined", + LinkModeinterrupt: "interrupt", + LinkModepolling: "polling", +} + +var EnumValuesLinkMode = map[string]LinkMode{ + "undefined": LinkModeundefined, + "interrupt": LinkModeinterrupt, + "polling": LinkModepolling, +} + +func (v LinkMode) String() string { + if s, ok := EnumNamesLinkMode[v]; ok { + return s + } + return "LinkMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/LinkStatus.go b/pkg/fbs/comm/ethercat/master/fbs/LinkStatus.go new file mode 100644 index 0000000..1719b62 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/LinkStatus.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type LinkStatus uint32 + +const ( + LinkStatusundefined LinkStatus = 0 + LinkStatusok LinkStatus = 1 + LinkStatusdisconnected LinkStatus = 2 + LinkStatushalfduplex LinkStatus = 3 +) + +var EnumNamesLinkStatus = map[LinkStatus]string{ + LinkStatusundefined: "undefined", + LinkStatusok: "ok", + LinkStatusdisconnected: "disconnected", + LinkStatushalfduplex: "halfduplex", +} + +var EnumValuesLinkStatus = map[string]LinkStatus{ + "undefined": LinkStatusundefined, + "ok": LinkStatusok, + "disconnected": LinkStatusdisconnected, + "halfduplex": LinkStatushalfduplex, +} + +func (v LinkStatus) String() string { + if s, ok := EnumNamesLinkStatus[v]; ok { + return s + } + return "LinkStatus(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCounters.go b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCounters.go new file mode 100644 index 0000000..dddd5ff --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCounters.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MailboxStatisticCountersT struct { + Response *MailboxStatisticCountersResponseT +} + +func (t *MailboxStatisticCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + MailboxStatisticCountersStart(builder) + MailboxStatisticCountersAddResponse(builder, responseOffset) + return MailboxStatisticCountersEnd(builder) +} + +func (rcv *MailboxStatisticCounters) UnPackTo(t *MailboxStatisticCountersT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MailboxStatisticCounters) UnPack() *MailboxStatisticCountersT { + if rcv == nil { return nil } + t := &MailboxStatisticCountersT{} + rcv.UnPackTo(t) + return t +} + +type MailboxStatisticCounters struct { + _tab flatbuffers.Table +} + +func GetRootAsMailboxStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MailboxStatisticCounters{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMailboxStatisticCounters(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticCounters { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MailboxStatisticCounters{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MailboxStatisticCounters) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MailboxStatisticCounters) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MailboxStatisticCounters) Response(obj *MailboxStatisticCountersResponse) *MailboxStatisticCountersResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MailboxStatisticCountersResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MailboxStatisticCountersStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MailboxStatisticCountersAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func MailboxStatisticCountersEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCountersResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCountersResponse.go new file mode 100644 index 0000000..cad90b1 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticCountersResponse.go @@ -0,0 +1,200 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MailboxStatisticCountersResponseT struct { + Aoe *ProtocolStatisticT + Coe *ProtocolStatisticT + Eoe *ProtocolStatisticT + Foe *ProtocolStatisticT + Soe *ProtocolStatisticT + Voe *ProtocolStatisticT + Raw *ProtocolStatisticT +} + +func (t *MailboxStatisticCountersResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MailboxStatisticCountersResponseStart(builder) + aoeOffset := t.Aoe.Pack(builder) + MailboxStatisticCountersResponseAddAoe(builder, aoeOffset) + coeOffset := t.Coe.Pack(builder) + MailboxStatisticCountersResponseAddCoe(builder, coeOffset) + eoeOffset := t.Eoe.Pack(builder) + MailboxStatisticCountersResponseAddEoe(builder, eoeOffset) + foeOffset := t.Foe.Pack(builder) + MailboxStatisticCountersResponseAddFoe(builder, foeOffset) + soeOffset := t.Soe.Pack(builder) + MailboxStatisticCountersResponseAddSoe(builder, soeOffset) + voeOffset := t.Voe.Pack(builder) + MailboxStatisticCountersResponseAddVoe(builder, voeOffset) + rawOffset := t.Raw.Pack(builder) + MailboxStatisticCountersResponseAddRaw(builder, rawOffset) + return MailboxStatisticCountersResponseEnd(builder) +} + +func (rcv *MailboxStatisticCountersResponse) UnPackTo(t *MailboxStatisticCountersResponseT) { + t.Aoe = rcv.Aoe(nil).UnPack() + t.Coe = rcv.Coe(nil).UnPack() + t.Eoe = rcv.Eoe(nil).UnPack() + t.Foe = rcv.Foe(nil).UnPack() + t.Soe = rcv.Soe(nil).UnPack() + t.Voe = rcv.Voe(nil).UnPack() + t.Raw = rcv.Raw(nil).UnPack() +} + +func (rcv *MailboxStatisticCountersResponse) UnPack() *MailboxStatisticCountersResponseT { + if rcv == nil { return nil } + t := &MailboxStatisticCountersResponseT{} + rcv.UnPackTo(t) + return t +} + +type MailboxStatisticCountersResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMailboxStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MailboxStatisticCountersResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMailboxStatisticCountersResponse(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticCountersResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MailboxStatisticCountersResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MailboxStatisticCountersResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MailboxStatisticCountersResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MailboxStatisticCountersResponse) Aoe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Coe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Eoe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Foe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Soe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Voe(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticCountersResponse) Raw(obj *ProtocolStatistic) *ProtocolStatistic { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatistic) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MailboxStatisticCountersResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func MailboxStatisticCountersResponseAddAoe(builder *flatbuffers.Builder, aoe flatbuffers.UOffsetT) { + builder.PrependStructSlot(0, flatbuffers.UOffsetT(aoe), 0) +} +func MailboxStatisticCountersResponseAddCoe(builder *flatbuffers.Builder, coe flatbuffers.UOffsetT) { + builder.PrependStructSlot(1, flatbuffers.UOffsetT(coe), 0) +} +func MailboxStatisticCountersResponseAddEoe(builder *flatbuffers.Builder, eoe flatbuffers.UOffsetT) { + builder.PrependStructSlot(2, flatbuffers.UOffsetT(eoe), 0) +} +func MailboxStatisticCountersResponseAddFoe(builder *flatbuffers.Builder, foe flatbuffers.UOffsetT) { + builder.PrependStructSlot(3, flatbuffers.UOffsetT(foe), 0) +} +func MailboxStatisticCountersResponseAddSoe(builder *flatbuffers.Builder, soe flatbuffers.UOffsetT) { + builder.PrependStructSlot(4, flatbuffers.UOffsetT(soe), 0) +} +func MailboxStatisticCountersResponseAddVoe(builder *flatbuffers.Builder, voe flatbuffers.UOffsetT) { + builder.PrependStructSlot(5, flatbuffers.UOffsetT(voe), 0) +} +func MailboxStatisticCountersResponseAddRaw(builder *flatbuffers.Builder, raw flatbuffers.UOffsetT) { + builder.PrependStructSlot(6, flatbuffers.UOffsetT(raw), 0) +} +func MailboxStatisticCountersResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticReset.go b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticReset.go new file mode 100644 index 0000000..51e8835 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticReset.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MailboxStatisticResetT struct { + Request *MailboxStatisticResetRequestT + Response *MailboxStatisticResetResponseT +} + +func (t *MailboxStatisticResetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MailboxStatisticResetStart(builder) + MailboxStatisticResetAddRequest(builder, requestOffset) + MailboxStatisticResetAddResponse(builder, responseOffset) + return MailboxStatisticResetEnd(builder) +} + +func (rcv *MailboxStatisticReset) UnPackTo(t *MailboxStatisticResetT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MailboxStatisticReset) UnPack() *MailboxStatisticResetT { + if rcv == nil { return nil } + t := &MailboxStatisticResetT{} + rcv.UnPackTo(t) + return t +} + +type MailboxStatisticReset struct { + _tab flatbuffers.Table +} + +func GetRootAsMailboxStatisticReset(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticReset { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MailboxStatisticReset{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMailboxStatisticReset(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticReset { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MailboxStatisticReset{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MailboxStatisticReset) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MailboxStatisticReset) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MailboxStatisticReset) Request(obj *MailboxStatisticResetRequest) *MailboxStatisticResetRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MailboxStatisticResetRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticReset) Response(obj *MailboxStatisticResetResponse) *MailboxStatisticResetResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MailboxStatisticResetResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MailboxStatisticResetStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MailboxStatisticResetAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func MailboxStatisticResetAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func MailboxStatisticResetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetRequest.go new file mode 100644 index 0000000..9b82616 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetRequest.go @@ -0,0 +1,200 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MailboxStatisticResetRequestT struct { + Aoe *ProtocolStatisticResetT + Coe *ProtocolStatisticResetT + Foe *ProtocolStatisticResetT + Eoe *ProtocolStatisticResetT + Soe *ProtocolStatisticResetT + Voe *ProtocolStatisticResetT + Raw *ProtocolStatisticResetT +} + +func (t *MailboxStatisticResetRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MailboxStatisticResetRequestStart(builder) + aoeOffset := t.Aoe.Pack(builder) + MailboxStatisticResetRequestAddAoe(builder, aoeOffset) + coeOffset := t.Coe.Pack(builder) + MailboxStatisticResetRequestAddCoe(builder, coeOffset) + foeOffset := t.Foe.Pack(builder) + MailboxStatisticResetRequestAddFoe(builder, foeOffset) + eoeOffset := t.Eoe.Pack(builder) + MailboxStatisticResetRequestAddEoe(builder, eoeOffset) + soeOffset := t.Soe.Pack(builder) + MailboxStatisticResetRequestAddSoe(builder, soeOffset) + voeOffset := t.Voe.Pack(builder) + MailboxStatisticResetRequestAddVoe(builder, voeOffset) + rawOffset := t.Raw.Pack(builder) + MailboxStatisticResetRequestAddRaw(builder, rawOffset) + return MailboxStatisticResetRequestEnd(builder) +} + +func (rcv *MailboxStatisticResetRequest) UnPackTo(t *MailboxStatisticResetRequestT) { + t.Aoe = rcv.Aoe(nil).UnPack() + t.Coe = rcv.Coe(nil).UnPack() + t.Foe = rcv.Foe(nil).UnPack() + t.Eoe = rcv.Eoe(nil).UnPack() + t.Soe = rcv.Soe(nil).UnPack() + t.Voe = rcv.Voe(nil).UnPack() + t.Raw = rcv.Raw(nil).UnPack() +} + +func (rcv *MailboxStatisticResetRequest) UnPack() *MailboxStatisticResetRequestT { + if rcv == nil { return nil } + t := &MailboxStatisticResetRequestT{} + rcv.UnPackTo(t) + return t +} + +type MailboxStatisticResetRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsMailboxStatisticResetRequest(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticResetRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MailboxStatisticResetRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMailboxStatisticResetRequest(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticResetRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MailboxStatisticResetRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MailboxStatisticResetRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MailboxStatisticResetRequest) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MailboxStatisticResetRequest) Aoe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Coe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Foe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Eoe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Soe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Voe(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MailboxStatisticResetRequest) Raw(obj *ProtocolStatisticReset) *ProtocolStatisticReset { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(ProtocolStatisticReset) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MailboxStatisticResetRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func MailboxStatisticResetRequestAddAoe(builder *flatbuffers.Builder, aoe flatbuffers.UOffsetT) { + builder.PrependStructSlot(0, flatbuffers.UOffsetT(aoe), 0) +} +func MailboxStatisticResetRequestAddCoe(builder *flatbuffers.Builder, coe flatbuffers.UOffsetT) { + builder.PrependStructSlot(1, flatbuffers.UOffsetT(coe), 0) +} +func MailboxStatisticResetRequestAddFoe(builder *flatbuffers.Builder, foe flatbuffers.UOffsetT) { + builder.PrependStructSlot(2, flatbuffers.UOffsetT(foe), 0) +} +func MailboxStatisticResetRequestAddEoe(builder *flatbuffers.Builder, eoe flatbuffers.UOffsetT) { + builder.PrependStructSlot(3, flatbuffers.UOffsetT(eoe), 0) +} +func MailboxStatisticResetRequestAddSoe(builder *flatbuffers.Builder, soe flatbuffers.UOffsetT) { + builder.PrependStructSlot(4, flatbuffers.UOffsetT(soe), 0) +} +func MailboxStatisticResetRequestAddVoe(builder *flatbuffers.Builder, voe flatbuffers.UOffsetT) { + builder.PrependStructSlot(5, flatbuffers.UOffsetT(voe), 0) +} +func MailboxStatisticResetRequestAddRaw(builder *flatbuffers.Builder, raw flatbuffers.UOffsetT) { + builder.PrependStructSlot(6, flatbuffers.UOffsetT(raw), 0) +} +func MailboxStatisticResetRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetResponse.go new file mode 100644 index 0000000..7bdefa8 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MailboxStatisticResetResponse.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MailboxStatisticResetResponseT struct { +} + +func (t *MailboxStatisticResetResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MailboxStatisticResetResponseStart(builder) + return MailboxStatisticResetResponseEnd(builder) +} + +func (rcv *MailboxStatisticResetResponse) UnPackTo(t *MailboxStatisticResetResponseT) { +} + +func (rcv *MailboxStatisticResetResponse) UnPack() *MailboxStatisticResetResponseT { + if rcv == nil { return nil } + t := &MailboxStatisticResetResponseT{} + rcv.UnPackTo(t) + return t +} + +type MailboxStatisticResetResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMailboxStatisticResetResponse(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticResetResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MailboxStatisticResetResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMailboxStatisticResetResponse(buf []byte, offset flatbuffers.UOffsetT) *MailboxStatisticResetResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MailboxStatisticResetResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MailboxStatisticResetResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MailboxStatisticResetResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func MailboxStatisticResetResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(0) +} +func MailboxStatisticResetResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterInfo.go b/pkg/fbs/comm/ethercat/master/fbs/MasterInfo.go new file mode 100644 index 0000000..07bd8b3 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterInfo.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MasterInfoT struct { + Response *MasterInfoResponseT +} + +func (t *MasterInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + MasterInfoStart(builder) + MasterInfoAddResponse(builder, responseOffset) + return MasterInfoEnd(builder) +} + +func (rcv *MasterInfo) UnPackTo(t *MasterInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MasterInfo) UnPack() *MasterInfoT { + if rcv == nil { return nil } + t := &MasterInfoT{} + rcv.UnPackTo(t) + return t +} + +type MasterInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsMasterInfo(buf []byte, offset flatbuffers.UOffsetT) *MasterInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MasterInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMasterInfo(buf []byte, offset flatbuffers.UOffsetT) *MasterInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MasterInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MasterInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MasterInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MasterInfo) Response(obj *MasterInfoResponse) *MasterInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MasterInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MasterInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MasterInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func MasterInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MasterInfoResponse.go new file mode 100644 index 0000000..5e9e744 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterInfoResponse.go @@ -0,0 +1,254 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + common__scheduler__fbs2 "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/fbs2" +) + +type MasterInfoResponseT struct { + MasterState *MasterStateResponseT + MasterStatus uint32 + Checksums []*ChecksumElementT + TopologyStatus *TopologyStatusResponseT + SystemTime uint64 + TaskInfos []*taskInfoT + ComponentState *common__scheduler__fbs2.StateT +} + +func (t *MasterInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterStateOffset := t.MasterState.Pack(builder) + checksumsOffset := flatbuffers.UOffsetT(0) + if t.Checksums != nil { + checksumsLength := len(t.Checksums) + checksumsOffsets := make([]flatbuffers.UOffsetT, checksumsLength) + for j := 0; j < checksumsLength; j++ { + checksumsOffsets[j] = t.Checksums[j].Pack(builder) + } + MasterInfoResponseStartChecksumsVector(builder, checksumsLength) + for j := checksumsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(checksumsOffsets[j]) + } + checksumsOffset = builder.EndVector(checksumsLength) + } + topologyStatusOffset := t.TopologyStatus.Pack(builder) + taskInfosOffset := flatbuffers.UOffsetT(0) + if t.TaskInfos != nil { + taskInfosLength := len(t.TaskInfos) + taskInfosOffsets := make([]flatbuffers.UOffsetT, taskInfosLength) + for j := 0; j < taskInfosLength; j++ { + taskInfosOffsets[j] = t.TaskInfos[j].Pack(builder) + } + MasterInfoResponseStartTaskInfosVector(builder, taskInfosLength) + for j := taskInfosLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(taskInfosOffsets[j]) + } + taskInfosOffset = builder.EndVector(taskInfosLength) + } + componentStateOffset := t.ComponentState.Pack(builder) + MasterInfoResponseStart(builder) + MasterInfoResponseAddMasterState(builder, masterStateOffset) + MasterInfoResponseAddMasterStatus(builder, t.MasterStatus) + MasterInfoResponseAddChecksums(builder, checksumsOffset) + MasterInfoResponseAddTopologyStatus(builder, topologyStatusOffset) + MasterInfoResponseAddSystemTime(builder, t.SystemTime) + MasterInfoResponseAddTaskInfos(builder, taskInfosOffset) + MasterInfoResponseAddComponentState(builder, componentStateOffset) + return MasterInfoResponseEnd(builder) +} + +func (rcv *MasterInfoResponse) UnPackTo(t *MasterInfoResponseT) { + t.MasterState = rcv.MasterState(nil).UnPack() + t.MasterStatus = rcv.MasterStatus() + checksumsLength := rcv.ChecksumsLength() + t.Checksums = make([]*ChecksumElementT, checksumsLength) + for j := 0; j < checksumsLength; j++ { + x := ChecksumElement{} + rcv.Checksums(&x, j) + t.Checksums[j] = x.UnPack() + } + t.TopologyStatus = rcv.TopologyStatus(nil).UnPack() + t.SystemTime = rcv.SystemTime() + taskInfosLength := rcv.TaskInfosLength() + t.TaskInfos = make([]*taskInfoT, taskInfosLength) + for j := 0; j < taskInfosLength; j++ { + x := taskInfo{} + rcv.TaskInfos(&x, j) + t.TaskInfos[j] = x.UnPack() + } + t.ComponentState = rcv.ComponentState(nil).UnPack() +} + +func (rcv *MasterInfoResponse) UnPack() *MasterInfoResponseT { + if rcv == nil { return nil } + t := &MasterInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type MasterInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMasterInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MasterInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MasterInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMasterInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MasterInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MasterInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MasterInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MasterInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MasterInfoResponse) MasterState(obj *MasterStateResponse) *MasterStateResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MasterStateResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MasterInfoResponse) MasterStatus() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *MasterInfoResponse) MutateMasterStatus(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *MasterInfoResponse) Checksums(obj *ChecksumElement, 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 *MasterInfoResponse) ChecksumsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *MasterInfoResponse) TopologyStatus(obj *TopologyStatusResponse) *TopologyStatusResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TopologyStatusResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MasterInfoResponse) SystemTime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *MasterInfoResponse) MutateSystemTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(12, n) +} + +func (rcv *MasterInfoResponse) TaskInfos(obj *taskInfo, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + 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 *MasterInfoResponse) TaskInfosLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *MasterInfoResponse) ComponentState(obj *common__scheduler__fbs2.State) *common__scheduler__fbs2.State { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(common__scheduler__fbs2.State) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MasterInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func MasterInfoResponseAddMasterState(builder *flatbuffers.Builder, masterState flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(masterState), 0) +} +func MasterInfoResponseAddMasterStatus(builder *flatbuffers.Builder, masterStatus uint32) { + builder.PrependUint32Slot(1, masterStatus, 0) +} +func MasterInfoResponseAddChecksums(builder *flatbuffers.Builder, checksums flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(checksums), 0) +} +func MasterInfoResponseStartChecksumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func MasterInfoResponseAddTopologyStatus(builder *flatbuffers.Builder, topologyStatus flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(topologyStatus), 0) +} +func MasterInfoResponseAddSystemTime(builder *flatbuffers.Builder, systemTime uint64) { + builder.PrependUint64Slot(4, systemTime, 0) +} +func MasterInfoResponseAddTaskInfos(builder *flatbuffers.Builder, taskInfos flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(taskInfos), 0) +} +func MasterInfoResponseStartTaskInfosVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func MasterInfoResponseAddComponentState(builder *flatbuffers.Builder, componentState flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(componentState), 0) +} +func MasterInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterState.go b/pkg/fbs/comm/ethercat/master/fbs/MasterState.go index 98fae12..a93dc1e 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/MasterState.go +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterState.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MasterStateT struct { + Request *MasterStateRequestT + Response *MasterStateResponseT +} + +func (t *MasterStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MasterStateStart(builder) + MasterStateAddRequest(builder, requestOffset) + MasterStateAddResponse(builder, responseOffset) + return MasterStateEnd(builder) +} + +func (rcv *MasterState) UnPackTo(t *MasterStateT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MasterState) UnPack() *MasterStateT { + if rcv == nil { return nil } + t := &MasterStateT{} + rcv.UnPackTo(t) + return t +} + type MasterState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterStateRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MasterStateRequest.go index f33efeb..aac66ff 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/MasterStateRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterStateRequest.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MasterStateRequestT struct { + NewState EthercatState +} + +func (t *MasterStateRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MasterStateRequestStart(builder) + MasterStateRequestAddNewState(builder, t.NewState) + return MasterStateRequestEnd(builder) +} + +func (rcv *MasterStateRequest) UnPackTo(t *MasterStateRequestT) { + t.NewState = rcv.NewState() +} + +func (rcv *MasterStateRequest) UnPack() *MasterStateRequestT { + if rcv == nil { return nil } + t := &MasterStateRequestT{} + rcv.UnPackTo(t) + return t +} + type MasterStateRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterStateResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MasterStateResponse.go index ec7f01e..ed9095a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/MasterStateResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterStateResponse.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MasterStateResponseT struct { + CurrentState EthercatState + RequestedState EthercatState +} + +func (t *MasterStateResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MasterStateResponseStart(builder) + MasterStateResponseAddCurrentState(builder, t.CurrentState) + MasterStateResponseAddRequestedState(builder, t.RequestedState) + return MasterStateResponseEnd(builder) +} + +func (rcv *MasterStateResponse) UnPackTo(t *MasterStateResponseT) { + t.CurrentState = rcv.CurrentState() + t.RequestedState = rcv.RequestedState() +} + +func (rcv *MasterStateResponse) UnPack() *MasterStateResponseT { + if rcv == nil { return nil } + t := &MasterStateResponseT{} + rcv.UnPackTo(t) + return t +} + type MasterStateResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterStatus.go b/pkg/fbs/comm/ethercat/master/fbs/MasterStatus.go index 10bcbee..127876b 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/MasterStatus.go +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterStatus.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MasterStatusT struct { + Response *MasterStatusResponseT +} + +func (t *MasterStatusT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + MasterStatusStart(builder) + MasterStatusAddResponse(builder, responseOffset) + return MasterStatusEnd(builder) +} + +func (rcv *MasterStatus) UnPackTo(t *MasterStatusT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MasterStatus) UnPack() *MasterStatusT { + if rcv == nil { return nil } + t := &MasterStatusT{} + rcv.UnPackTo(t) + return t +} + type MasterStatus struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/MasterStatusResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MasterStatusResponse.go index 2fd75de..fb6889c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/MasterStatusResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/MasterStatusResponse.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MasterStatusResponseT struct { + Status uint32 +} + +func (t *MasterStatusResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MasterStatusResponseStart(builder) + MasterStatusResponseAddStatus(builder, t.Status) + return MasterStatusResponseEnd(builder) +} + +func (rcv *MasterStatusResponse) UnPackTo(t *MasterStatusResponseT) { + t.Status = rcv.Status() +} + +func (rcv *MasterStatusResponse) UnPack() *MasterStatusResponseT { + if rcv == nil { return nil } + t := &MasterStatusResponseT{} + rcv.UnPackTo(t) + return t +} + type MasterStatusResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/MinActMaxValues.go b/pkg/fbs/comm/ethercat/master/fbs/MinActMaxValues.go new file mode 100644 index 0000000..c73beb9 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MinActMaxValues.go @@ -0,0 +1,72 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type MinActMaxValuesT struct { + Minimum uint32 + Actual uint32 + Maximum uint32 +} + +func (t *MinActMaxValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateMinActMaxValues(builder, t.Minimum, t.Actual, t.Maximum) +} +func (rcv *MinActMaxValues) UnPackTo(t *MinActMaxValuesT) { + t.Minimum = rcv.Minimum() + t.Actual = rcv.Actual() + t.Maximum = rcv.Maximum() +} + +func (rcv *MinActMaxValues) UnPack() *MinActMaxValuesT { + if rcv == nil { return nil } + t := &MinActMaxValuesT{} + rcv.UnPackTo(t) + return t +} + +type MinActMaxValues struct { + _tab flatbuffers.Struct +} + +func (rcv *MinActMaxValues) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MinActMaxValues) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *MinActMaxValues) Minimum() uint32 { + return rcv._tab.GetUint32(rcv._tab.Pos + flatbuffers.UOffsetT(0)) +} +func (rcv *MinActMaxValues) MutateMinimum(n uint32) bool { + return rcv._tab.MutateUint32(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) +} + +func (rcv *MinActMaxValues) Actual() uint32 { + return rcv._tab.GetUint32(rcv._tab.Pos + flatbuffers.UOffsetT(4)) +} +func (rcv *MinActMaxValues) MutateActual(n uint32) bool { + return rcv._tab.MutateUint32(rcv._tab.Pos+flatbuffers.UOffsetT(4), n) +} + +func (rcv *MinActMaxValues) Maximum() uint32 { + return rcv._tab.GetUint32(rcv._tab.Pos + flatbuffers.UOffsetT(8)) +} +func (rcv *MinActMaxValues) MutateMaximum(n uint32) bool { + return rcv._tab.MutateUint32(rcv._tab.Pos+flatbuffers.UOffsetT(8), n) +} + +func CreateMinActMaxValues(builder *flatbuffers.Builder, minimum uint32, actual uint32, maximum uint32) flatbuffers.UOffsetT { + builder.Prep(4, 12) + builder.PrependUint32(maximum) + builder.PrependUint32(actual) + builder.PrependUint32(minimum) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlaves.go b/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlaves.go index a63d30b..bfa6357 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlaves.go +++ b/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlaves.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type NumConfiguredSlavesT struct { + Response *NumConfiguredSlavesResponseT +} + +func (t *NumConfiguredSlavesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + NumConfiguredSlavesStart(builder) + NumConfiguredSlavesAddResponse(builder, responseOffset) + return NumConfiguredSlavesEnd(builder) +} + +func (rcv *NumConfiguredSlaves) UnPackTo(t *NumConfiguredSlavesT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *NumConfiguredSlaves) UnPack() *NumConfiguredSlavesT { + if rcv == nil { return nil } + t := &NumConfiguredSlavesT{} + rcv.UnPackTo(t) + return t +} + type NumConfiguredSlaves struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlavesResponse.go b/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlavesResponse.go index c1de5f0..775e270 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlavesResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/NumConfiguredSlavesResponse.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type NumConfiguredSlavesResponseT struct { + NumSlaves uint32 +} + +func (t *NumConfiguredSlavesResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + NumConfiguredSlavesResponseStart(builder) + NumConfiguredSlavesResponseAddNumSlaves(builder, t.NumSlaves) + return NumConfiguredSlavesResponseEnd(builder) +} + +func (rcv *NumConfiguredSlavesResponse) UnPackTo(t *NumConfiguredSlavesResponseT) { + t.NumSlaves = rcv.NumSlaves() +} + +func (rcv *NumConfiguredSlavesResponse) UnPack() *NumConfiguredSlavesResponseT { + if rcv == nil { return nil } + t := &NumConfiguredSlavesResponseT{} + rcv.UnPackTo(t) + return t +} + type NumConfiguredSlavesResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlaves.go b/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlaves.go index 673107e..a615443 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlaves.go +++ b/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlaves.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type NumConnectedSlavesT struct { + Response *NumConnectedSlavesResponseT +} + +func (t *NumConnectedSlavesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + NumConnectedSlavesStart(builder) + NumConnectedSlavesAddResponse(builder, responseOffset) + return NumConnectedSlavesEnd(builder) +} + +func (rcv *NumConnectedSlaves) UnPackTo(t *NumConnectedSlavesT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *NumConnectedSlaves) UnPack() *NumConnectedSlavesT { + if rcv == nil { return nil } + t := &NumConnectedSlavesT{} + rcv.UnPackTo(t) + return t +} + type NumConnectedSlaves struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlavesResponse.go b/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlavesResponse.go index d741e5f..71785f7 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlavesResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/NumConnectedSlavesResponse.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type NumConnectedSlavesResponseT struct { + NumSlaves uint32 +} + +func (t *NumConnectedSlavesResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + NumConnectedSlavesResponseStart(builder) + NumConnectedSlavesResponseAddNumSlaves(builder, t.NumSlaves) + return NumConnectedSlavesResponseEnd(builder) +} + +func (rcv *NumConnectedSlavesResponse) UnPackTo(t *NumConnectedSlavesResponseT) { + t.NumSlaves = rcv.NumSlaves() +} + +func (rcv *NumConnectedSlavesResponse) UnPack() *NumConnectedSlavesResponseT { + if rcv == nil { return nil } + t := &NumConnectedSlavesResponseT{} + rcv.UnPackTo(t) + return t +} + type NumConnectedSlavesResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescription.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescription.go index 297cb6c..0ae9111 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescription.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescription.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDescriptionT struct { + Request *ObjectDescriptionRequestT + Response *ObjectDescriptionResponseT +} + +func (t *ObjectDescriptionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + ObjectDescriptionStart(builder) + ObjectDescriptionAddRequest(builder, requestOffset) + ObjectDescriptionAddResponse(builder, responseOffset) + return ObjectDescriptionEnd(builder) +} + +func (rcv *ObjectDescription) UnPackTo(t *ObjectDescriptionT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *ObjectDescription) UnPack() *ObjectDescriptionT { + if rcv == nil { return nil } + t := &ObjectDescriptionT{} + rcv.UnPackTo(t) + return t +} + type ObjectDescription struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionRequest.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionRequest.go index a06e435..768f895 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionRequest.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDescriptionRequestT struct { + AddressType Addresstype + Address uint16 + ObjectIndex uint16 + MaxLength uint32 +} + +func (t *ObjectDescriptionRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ObjectDescriptionRequestStart(builder) + ObjectDescriptionRequestAddAddressType(builder, t.AddressType) + ObjectDescriptionRequestAddAddress(builder, t.Address) + ObjectDescriptionRequestAddObjectIndex(builder, t.ObjectIndex) + ObjectDescriptionRequestAddMaxLength(builder, t.MaxLength) + return ObjectDescriptionRequestEnd(builder) +} + +func (rcv *ObjectDescriptionRequest) UnPackTo(t *ObjectDescriptionRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.ObjectIndex = rcv.ObjectIndex() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *ObjectDescriptionRequest) UnPack() *ObjectDescriptionRequestT { + if rcv == nil { return nil } + t := &ObjectDescriptionRequestT{} + rcv.UnPackTo(t) + return t +} + type ObjectDescriptionRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionResponse.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionResponse.go index 2943b24..92e8db2 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDescriptionResponse.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDescriptionResponseT struct { + Data []byte +} + +func (t *ObjectDescriptionResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + ObjectDescriptionResponseStart(builder) + ObjectDescriptionResponseAddData(builder, dataOffset) + return ObjectDescriptionResponseEnd(builder) +} + +func (rcv *ObjectDescriptionResponse) UnPackTo(t *ObjectDescriptionResponseT) { + t.Data = rcv.DataBytes() +} + +func (rcv *ObjectDescriptionResponse) UnPack() *ObjectDescriptionResponseT { + if rcv == nil { return nil } + t := &ObjectDescriptionResponseT{} + rcv.UnPackTo(t) + return t +} + type ObjectDescriptionResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryList.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryList.go index d2599ed..27e0f26 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryList.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryList.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDictionaryListT struct { + Request *ObjectDictionaryListRequestT + Response *ObjectDictionaryListResponseT +} + +func (t *ObjectDictionaryListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + ObjectDictionaryListStart(builder) + ObjectDictionaryListAddRequest(builder, requestOffset) + ObjectDictionaryListAddResponse(builder, responseOffset) + return ObjectDictionaryListEnd(builder) +} + +func (rcv *ObjectDictionaryList) UnPackTo(t *ObjectDictionaryListT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *ObjectDictionaryList) UnPack() *ObjectDictionaryListT { + if rcv == nil { return nil } + t := &ObjectDictionaryListT{} + rcv.UnPackTo(t) + return t +} + type ObjectDictionaryList struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListRequest.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListRequest.go index 9d8b6a0..1ff5e2a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListRequest.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDictionaryListRequestT struct { + AddressType Addresstype + Address uint16 + ListType ObjectDictionaryListType + MaxElements uint32 +} + +func (t *ObjectDictionaryListRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ObjectDictionaryListRequestStart(builder) + ObjectDictionaryListRequestAddAddressType(builder, t.AddressType) + ObjectDictionaryListRequestAddAddress(builder, t.Address) + ObjectDictionaryListRequestAddListType(builder, t.ListType) + ObjectDictionaryListRequestAddMaxElements(builder, t.MaxElements) + return ObjectDictionaryListRequestEnd(builder) +} + +func (rcv *ObjectDictionaryListRequest) UnPackTo(t *ObjectDictionaryListRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.ListType = rcv.ListType() + t.MaxElements = rcv.MaxElements() +} + +func (rcv *ObjectDictionaryListRequest) UnPack() *ObjectDictionaryListRequestT { + if rcv == nil { return nil } + t := &ObjectDictionaryListRequestT{} + rcv.UnPackTo(t) + return t +} + type ObjectDictionaryListRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListResponse.go b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListResponse.go index 044afc0..d1568ad 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ObjectDictionaryListResponse.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ObjectDictionaryListResponseT struct { + Indices []uint16 +} + +func (t *ObjectDictionaryListResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + indicesOffset := flatbuffers.UOffsetT(0) + if t.Indices != nil { + indicesLength := len(t.Indices) + ObjectDictionaryListResponseStartIndicesVector(builder, indicesLength) + for j := indicesLength - 1; j >= 0; j-- { + builder.PrependUint16(t.Indices[j]) + } + indicesOffset = builder.EndVector(indicesLength) + } + ObjectDictionaryListResponseStart(builder) + ObjectDictionaryListResponseAddIndices(builder, indicesOffset) + return ObjectDictionaryListResponseEnd(builder) +} + +func (rcv *ObjectDictionaryListResponse) UnPackTo(t *ObjectDictionaryListResponseT) { + indicesLength := rcv.IndicesLength() + t.Indices = make([]uint16, indicesLength) + for j := 0; j < indicesLength; j++ { + t.Indices[j] = rcv.Indices(j) + } +} + +func (rcv *ObjectDictionaryListResponse) UnPack() *ObjectDictionaryListResponseT { + if rcv == nil { return nil } + t := &ObjectDictionaryListResponseT{} + rcv.UnPackTo(t) + return t +} + type ObjectDictionaryListResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/Parameter.go b/pkg/fbs/comm/ethercat/master/fbs/Parameter.go index b4142e6..5edad22 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/Parameter.go +++ b/pkg/fbs/comm/ethercat/master/fbs/Parameter.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ParameterT struct { + Request *ParameterRequestT + Response *ParameterResponseT +} + +func (t *ParameterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + ParameterStart(builder) + ParameterAddRequest(builder, requestOffset) + ParameterAddResponse(builder, responseOffset) + return ParameterEnd(builder) +} + +func (rcv *Parameter) UnPackTo(t *ParameterT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *Parameter) UnPack() *ParameterT { + if rcv == nil { return nil } + t := &ParameterT{} + rcv.UnPackTo(t) + return t +} + type Parameter struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ParameterRequest.go b/pkg/fbs/comm/ethercat/master/fbs/ParameterRequest.go index 3390c31..4a796a6 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ParameterRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ParameterRequest.go @@ -6,6 +6,50 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ParameterRequestT struct { + AddressType Addresstype + Address uint16 + DriveNumber byte + ElementFlags ElementFlags + Idn uint16 + Data []byte + MaxLength uint32 +} + +func (t *ParameterRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + ParameterRequestStart(builder) + ParameterRequestAddAddressType(builder, t.AddressType) + ParameterRequestAddAddress(builder, t.Address) + ParameterRequestAddDriveNumber(builder, t.DriveNumber) + ParameterRequestAddElementFlags(builder, t.ElementFlags) + ParameterRequestAddIdn(builder, t.Idn) + ParameterRequestAddData(builder, dataOffset) + ParameterRequestAddMaxLength(builder, t.MaxLength) + return ParameterRequestEnd(builder) +} + +func (rcv *ParameterRequest) UnPackTo(t *ParameterRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.DriveNumber = rcv.DriveNumber() + t.ElementFlags = rcv.ElementFlags() + t.Idn = rcv.Idn() + t.Data = rcv.DataBytes() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *ParameterRequest) UnPack() *ParameterRequestT { + if rcv == nil { return nil } + t := &ParameterRequestT{} + rcv.UnPackTo(t) + return t +} + type ParameterRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ParameterResponse.go b/pkg/fbs/comm/ethercat/master/fbs/ParameterResponse.go index ee8bbf2..ee22eb0 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/ParameterResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/ParameterResponse.go @@ -6,6 +6,35 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ParameterResponseT struct { + ElementFlags ElementFlags + Data []byte +} + +func (t *ParameterResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + ParameterResponseStart(builder) + ParameterResponseAddElementFlags(builder, t.ElementFlags) + ParameterResponseAddData(builder, dataOffset) + return ParameterResponseEnd(builder) +} + +func (rcv *ParameterResponse) UnPackTo(t *ParameterResponseT) { + t.ElementFlags = rcv.ElementFlags() + t.Data = rcv.DataBytes() +} + +func (rcv *ParameterResponse) UnPack() *ParameterResponseT { + if rcv == nil { return nil } + t := &ParameterResponseT{} + rcv.UnPackTo(t) + return t +} + type ParameterResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/PortErrorCounters.go b/pkg/fbs/comm/ethercat/master/fbs/PortErrorCounters.go index 1eb21be..a516b7e 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/PortErrorCounters.go +++ b/pkg/fbs/comm/ethercat/master/fbs/PortErrorCounters.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type PortErrorCountersT struct { + InvalidFrameCounter byte + RxErrorCounter byte + FwdRxErrorCounter byte + LostLinkCounter byte +} + +func (t *PortErrorCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreatePortErrorCounters(builder, t.InvalidFrameCounter, t.RxErrorCounter, t.FwdRxErrorCounter, t.LostLinkCounter) +} +func (rcv *PortErrorCounters) UnPackTo(t *PortErrorCountersT) { + t.InvalidFrameCounter = rcv.InvalidFrameCounter() + t.RxErrorCounter = rcv.RxErrorCounter() + t.FwdRxErrorCounter = rcv.FwdRxErrorCounter() + t.LostLinkCounter = rcv.LostLinkCounter() +} + +func (rcv *PortErrorCounters) UnPack() *PortErrorCountersT { + if rcv == nil { return nil } + t := &PortErrorCountersT{} + rcv.UnPackTo(t) + return t +} + type PortErrorCounters struct { _tab flatbuffers.Struct } diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfo.go b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfo.go new file mode 100644 index 0000000..61aaff8 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfo.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProfileChannelInfoT struct { + Request *ProfileChannelInfoRequestT + Response *ProfileChannelInfoResponseT +} + +func (t *ProfileChannelInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + ProfileChannelInfoStart(builder) + ProfileChannelInfoAddRequest(builder, requestOffset) + ProfileChannelInfoAddResponse(builder, responseOffset) + return ProfileChannelInfoEnd(builder) +} + +func (rcv *ProfileChannelInfo) UnPackTo(t *ProfileChannelInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *ProfileChannelInfo) UnPack() *ProfileChannelInfoT { + if rcv == nil { return nil } + t := &ProfileChannelInfoT{} + rcv.UnPackTo(t) + return t +} + +type ProfileChannelInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsProfileChannelInfo(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ProfileChannelInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsProfileChannelInfo(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ProfileChannelInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ProfileChannelInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProfileChannelInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ProfileChannelInfo) Request(obj *ProfileChannelInfoRequest) *ProfileChannelInfoRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(ProfileChannelInfoRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *ProfileChannelInfo) Response(obj *ProfileChannelInfoResponse) *ProfileChannelInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(ProfileChannelInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func ProfileChannelInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func ProfileChannelInfoAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func ProfileChannelInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func ProfileChannelInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoRequest.go b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoRequest.go new file mode 100644 index 0000000..df2f6b2 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoRequest.go @@ -0,0 +1,114 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProfileChannelInfoRequestT struct { + AddressType Addresstype + Address uint16 + Channel uint32 +} + +func (t *ProfileChannelInfoRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ProfileChannelInfoRequestStart(builder) + ProfileChannelInfoRequestAddAddressType(builder, t.AddressType) + ProfileChannelInfoRequestAddAddress(builder, t.Address) + ProfileChannelInfoRequestAddChannel(builder, t.Channel) + return ProfileChannelInfoRequestEnd(builder) +} + +func (rcv *ProfileChannelInfoRequest) UnPackTo(t *ProfileChannelInfoRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.Channel = rcv.Channel() +} + +func (rcv *ProfileChannelInfoRequest) UnPack() *ProfileChannelInfoRequestT { + if rcv == nil { return nil } + t := &ProfileChannelInfoRequestT{} + rcv.UnPackTo(t) + return t +} + +type ProfileChannelInfoRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsProfileChannelInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ProfileChannelInfoRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsProfileChannelInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ProfileChannelInfoRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ProfileChannelInfoRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProfileChannelInfoRequest) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ProfileChannelInfoRequest) AddressType() Addresstype { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return Addresstype(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ProfileChannelInfoRequest) MutateAddressType(n Addresstype) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *ProfileChannelInfoRequest) Address() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ProfileChannelInfoRequest) MutateAddress(n uint16) bool { + return rcv._tab.MutateUint16Slot(6, n) +} + +func (rcv *ProfileChannelInfoRequest) Channel() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ProfileChannelInfoRequest) MutateChannel(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func ProfileChannelInfoRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func ProfileChannelInfoRequestAddAddressType(builder *flatbuffers.Builder, addressType Addresstype) { + builder.PrependByteSlot(0, byte(addressType), 0) +} +func ProfileChannelInfoRequestAddAddress(builder *flatbuffers.Builder, address uint16) { + builder.PrependUint16Slot(1, address, 0) +} +func ProfileChannelInfoRequestAddChannel(builder *flatbuffers.Builder, channel uint32) { + builder.PrependUint32Slot(2, channel, 0) +} +func ProfileChannelInfoRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoResponse.go new file mode 100644 index 0000000..78f056a --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProfileChannelInfoResponse.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProfileChannelInfoResponseT struct { + ProfileNo uint16 + AddInfo uint16 + DisplayName string +} + +func (t *ProfileChannelInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DisplayNameOffset := builder.CreateString(t.DisplayName) + ProfileChannelInfoResponseStart(builder) + ProfileChannelInfoResponseAddProfileNo(builder, t.ProfileNo) + ProfileChannelInfoResponseAddAddInfo(builder, t.AddInfo) + ProfileChannelInfoResponseAddDisplayName(builder, DisplayNameOffset) + return ProfileChannelInfoResponseEnd(builder) +} + +func (rcv *ProfileChannelInfoResponse) UnPackTo(t *ProfileChannelInfoResponseT) { + t.ProfileNo = rcv.ProfileNo() + t.AddInfo = rcv.AddInfo() + t.DisplayName = string(rcv.DisplayName()) +} + +func (rcv *ProfileChannelInfoResponse) UnPack() *ProfileChannelInfoResponseT { + if rcv == nil { return nil } + t := &ProfileChannelInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type ProfileChannelInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsProfileChannelInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ProfileChannelInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsProfileChannelInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *ProfileChannelInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ProfileChannelInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ProfileChannelInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProfileChannelInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ProfileChannelInfoResponse) ProfileNo() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ProfileChannelInfoResponse) MutateProfileNo(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func (rcv *ProfileChannelInfoResponse) AddInfo() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ProfileChannelInfoResponse) MutateAddInfo(n uint16) bool { + return rcv._tab.MutateUint16Slot(6, n) +} + +func (rcv *ProfileChannelInfoResponse) DisplayName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func ProfileChannelInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func ProfileChannelInfoResponseAddProfileNo(builder *flatbuffers.Builder, ProfileNo uint16) { + builder.PrependUint16Slot(0, ProfileNo, 0) +} +func ProfileChannelInfoResponseAddAddInfo(builder *flatbuffers.Builder, AddInfo uint16) { + builder.PrependUint16Slot(1, AddInfo, 0) +} +func ProfileChannelInfoResponseAddDisplayName(builder *flatbuffers.Builder, DisplayName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(DisplayName), 0) +} +func ProfileChannelInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatistic.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatistic.go new file mode 100644 index 0000000..2985de7 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatistic.go @@ -0,0 +1,75 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticT struct { + Read *ProtocolStatisticPeriodCountersT + Write *ProtocolStatisticPeriodCountersT +} + +func (t *ProtocolStatisticT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatistic(builder, t.Read.Total.NumRequests, t.Read.Total.NumBytes, t.Read.LastSecond.NumRequests, t.Read.LastSecond.NumBytes, t.Write.Total.NumRequests, t.Write.Total.NumBytes, t.Write.LastSecond.NumRequests, t.Write.LastSecond.NumBytes) +} +func (rcv *ProtocolStatistic) UnPackTo(t *ProtocolStatisticT) { + t.Read = rcv.Read(nil).UnPack() + t.Write = rcv.Write(nil).UnPack() +} + +func (rcv *ProtocolStatistic) UnPack() *ProtocolStatisticT { + if rcv == nil { return nil } + t := &ProtocolStatisticT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatistic struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatistic) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatistic) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatistic) Read(obj *ProtocolStatisticPeriodCounters) *ProtocolStatisticPeriodCounters { + if obj == nil { + obj = new(ProtocolStatisticPeriodCounters) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+0) + return obj +} +func (rcv *ProtocolStatistic) Write(obj *ProtocolStatisticPeriodCounters) *ProtocolStatisticPeriodCounters { + if obj == nil { + obj = new(ProtocolStatisticPeriodCounters) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+16) + return obj +} + +func CreateProtocolStatistic(builder *flatbuffers.Builder, read_total_numRequests uint32, read_total_numBytes uint32, read_lastSecond_numRequests uint32, read_lastSecond_numBytes uint32, write_total_numRequests uint32, write_total_numBytes uint32, write_lastSecond_numRequests uint32, write_lastSecond_numBytes uint32) flatbuffers.UOffsetT { + builder.Prep(4, 32) + builder.Prep(4, 16) + builder.Prep(4, 8) + builder.PrependUint32(write_lastSecond_numBytes) + builder.PrependUint32(write_lastSecond_numRequests) + builder.Prep(4, 8) + builder.PrependUint32(write_total_numBytes) + builder.PrependUint32(write_total_numRequests) + builder.Prep(4, 16) + builder.Prep(4, 8) + builder.PrependUint32(read_lastSecond_numBytes) + builder.PrependUint32(read_lastSecond_numRequests) + builder.Prep(4, 8) + builder.PrependUint32(read_total_numBytes) + builder.PrependUint32(read_total_numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticCounters.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticCounters.go new file mode 100644 index 0000000..448ba5d --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticCounters.go @@ -0,0 +1,62 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticCountersT struct { + NumRequests uint32 + NumBytes uint32 +} + +func (t *ProtocolStatisticCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatisticCounters(builder, t.NumRequests, t.NumBytes) +} +func (rcv *ProtocolStatisticCounters) UnPackTo(t *ProtocolStatisticCountersT) { + t.NumRequests = rcv.NumRequests() + t.NumBytes = rcv.NumBytes() +} + +func (rcv *ProtocolStatisticCounters) UnPack() *ProtocolStatisticCountersT { + if rcv == nil { return nil } + t := &ProtocolStatisticCountersT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatisticCounters struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatisticCounters) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatisticCounters) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatisticCounters) NumRequests() uint32 { + return rcv._tab.GetUint32(rcv._tab.Pos + flatbuffers.UOffsetT(0)) +} +func (rcv *ProtocolStatisticCounters) MutateNumRequests(n uint32) bool { + return rcv._tab.MutateUint32(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) +} + +func (rcv *ProtocolStatisticCounters) NumBytes() uint32 { + return rcv._tab.GetUint32(rcv._tab.Pos + flatbuffers.UOffsetT(4)) +} +func (rcv *ProtocolStatisticCounters) MutateNumBytes(n uint32) bool { + return rcv._tab.MutateUint32(rcv._tab.Pos+flatbuffers.UOffsetT(4), n) +} + +func CreateProtocolStatisticCounters(builder *flatbuffers.Builder, numRequests uint32, numBytes uint32) flatbuffers.UOffsetT { + builder.Prep(4, 8) + builder.PrependUint32(numBytes) + builder.PrependUint32(numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodCounters.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodCounters.go new file mode 100644 index 0000000..599f37f --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodCounters.go @@ -0,0 +1,67 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticPeriodCountersT struct { + Total *ProtocolStatisticCountersT + LastSecond *ProtocolStatisticCountersT +} + +func (t *ProtocolStatisticPeriodCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatisticPeriodCounters(builder, t.Total.NumRequests, t.Total.NumBytes, t.LastSecond.NumRequests, t.LastSecond.NumBytes) +} +func (rcv *ProtocolStatisticPeriodCounters) UnPackTo(t *ProtocolStatisticPeriodCountersT) { + t.Total = rcv.Total(nil).UnPack() + t.LastSecond = rcv.LastSecond(nil).UnPack() +} + +func (rcv *ProtocolStatisticPeriodCounters) UnPack() *ProtocolStatisticPeriodCountersT { + if rcv == nil { return nil } + t := &ProtocolStatisticPeriodCountersT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatisticPeriodCounters struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatisticPeriodCounters) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatisticPeriodCounters) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatisticPeriodCounters) Total(obj *ProtocolStatisticCounters) *ProtocolStatisticCounters { + if obj == nil { + obj = new(ProtocolStatisticCounters) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+0) + return obj +} +func (rcv *ProtocolStatisticPeriodCounters) LastSecond(obj *ProtocolStatisticCounters) *ProtocolStatisticCounters { + if obj == nil { + obj = new(ProtocolStatisticCounters) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+8) + return obj +} + +func CreateProtocolStatisticPeriodCounters(builder *flatbuffers.Builder, total_numRequests uint32, total_numBytes uint32, lastSecond_numRequests uint32, lastSecond_numBytes uint32) flatbuffers.UOffsetT { + builder.Prep(4, 16) + builder.Prep(4, 8) + builder.PrependUint32(lastSecond_numBytes) + builder.PrependUint32(lastSecond_numRequests) + builder.Prep(4, 8) + builder.PrependUint32(total_numBytes) + builder.PrependUint32(total_numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodReset.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodReset.go new file mode 100644 index 0000000..cf6ac49 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticPeriodReset.go @@ -0,0 +1,67 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticPeriodResetT struct { + Total *ProtocolStatisticResetFlagsT + LastSecond *ProtocolStatisticResetFlagsT +} + +func (t *ProtocolStatisticPeriodResetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatisticPeriodReset(builder, t.Total.NumRequests, t.Total.NumBytes, t.LastSecond.NumRequests, t.LastSecond.NumBytes) +} +func (rcv *ProtocolStatisticPeriodReset) UnPackTo(t *ProtocolStatisticPeriodResetT) { + t.Total = rcv.Total(nil).UnPack() + t.LastSecond = rcv.LastSecond(nil).UnPack() +} + +func (rcv *ProtocolStatisticPeriodReset) UnPack() *ProtocolStatisticPeriodResetT { + if rcv == nil { return nil } + t := &ProtocolStatisticPeriodResetT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatisticPeriodReset struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatisticPeriodReset) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatisticPeriodReset) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatisticPeriodReset) Total(obj *ProtocolStatisticResetFlags) *ProtocolStatisticResetFlags { + if obj == nil { + obj = new(ProtocolStatisticResetFlags) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+0) + return obj +} +func (rcv *ProtocolStatisticPeriodReset) LastSecond(obj *ProtocolStatisticResetFlags) *ProtocolStatisticResetFlags { + if obj == nil { + obj = new(ProtocolStatisticResetFlags) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+2) + return obj +} + +func CreateProtocolStatisticPeriodReset(builder *flatbuffers.Builder, total_numRequests bool, total_numBytes bool, lastSecond_numRequests bool, lastSecond_numBytes bool) flatbuffers.UOffsetT { + builder.Prep(1, 4) + builder.Prep(1, 2) + builder.PrependBool(lastSecond_numBytes) + builder.PrependBool(lastSecond_numRequests) + builder.Prep(1, 2) + builder.PrependBool(total_numBytes) + builder.PrependBool(total_numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticReset.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticReset.go new file mode 100644 index 0000000..533a5e9 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticReset.go @@ -0,0 +1,75 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticResetT struct { + Read *ProtocolStatisticPeriodResetT + Write *ProtocolStatisticPeriodResetT +} + +func (t *ProtocolStatisticResetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatisticReset(builder, t.Read.Total.NumRequests, t.Read.Total.NumBytes, t.Read.LastSecond.NumRequests, t.Read.LastSecond.NumBytes, t.Write.Total.NumRequests, t.Write.Total.NumBytes, t.Write.LastSecond.NumRequests, t.Write.LastSecond.NumBytes) +} +func (rcv *ProtocolStatisticReset) UnPackTo(t *ProtocolStatisticResetT) { + t.Read = rcv.Read(nil).UnPack() + t.Write = rcv.Write(nil).UnPack() +} + +func (rcv *ProtocolStatisticReset) UnPack() *ProtocolStatisticResetT { + if rcv == nil { return nil } + t := &ProtocolStatisticResetT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatisticReset struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatisticReset) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatisticReset) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatisticReset) Read(obj *ProtocolStatisticPeriodReset) *ProtocolStatisticPeriodReset { + if obj == nil { + obj = new(ProtocolStatisticPeriodReset) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+0) + return obj +} +func (rcv *ProtocolStatisticReset) Write(obj *ProtocolStatisticPeriodReset) *ProtocolStatisticPeriodReset { + if obj == nil { + obj = new(ProtocolStatisticPeriodReset) + } + obj.Init(rcv._tab.Bytes, rcv._tab.Pos+4) + return obj +} + +func CreateProtocolStatisticReset(builder *flatbuffers.Builder, read_total_numRequests bool, read_total_numBytes bool, read_lastSecond_numRequests bool, read_lastSecond_numBytes bool, write_total_numRequests bool, write_total_numBytes bool, write_lastSecond_numRequests bool, write_lastSecond_numBytes bool) flatbuffers.UOffsetT { + builder.Prep(1, 8) + builder.Prep(1, 4) + builder.Prep(1, 2) + builder.PrependBool(write_lastSecond_numBytes) + builder.PrependBool(write_lastSecond_numRequests) + builder.Prep(1, 2) + builder.PrependBool(write_total_numBytes) + builder.PrependBool(write_total_numRequests) + builder.Prep(1, 4) + builder.Prep(1, 2) + builder.PrependBool(read_lastSecond_numBytes) + builder.PrependBool(read_lastSecond_numRequests) + builder.Prep(1, 2) + builder.PrependBool(read_total_numBytes) + builder.PrependBool(read_total_numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticResetFlags.go b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticResetFlags.go new file mode 100644 index 0000000..37ad9dd --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/ProtocolStatisticResetFlags.go @@ -0,0 +1,62 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProtocolStatisticResetFlagsT struct { + NumRequests bool + NumBytes bool +} + +func (t *ProtocolStatisticResetFlagsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateProtocolStatisticResetFlags(builder, t.NumRequests, t.NumBytes) +} +func (rcv *ProtocolStatisticResetFlags) UnPackTo(t *ProtocolStatisticResetFlagsT) { + t.NumRequests = rcv.NumRequests() + t.NumBytes = rcv.NumBytes() +} + +func (rcv *ProtocolStatisticResetFlags) UnPack() *ProtocolStatisticResetFlagsT { + if rcv == nil { return nil } + t := &ProtocolStatisticResetFlagsT{} + rcv.UnPackTo(t) + return t +} + +type ProtocolStatisticResetFlags struct { + _tab flatbuffers.Struct +} + +func (rcv *ProtocolStatisticResetFlags) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProtocolStatisticResetFlags) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *ProtocolStatisticResetFlags) NumRequests() bool { + return rcv._tab.GetBool(rcv._tab.Pos + flatbuffers.UOffsetT(0)) +} +func (rcv *ProtocolStatisticResetFlags) MutateNumRequests(n bool) bool { + return rcv._tab.MutateBool(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) +} + +func (rcv *ProtocolStatisticResetFlags) NumBytes() bool { + return rcv._tab.GetBool(rcv._tab.Pos + flatbuffers.UOffsetT(1)) +} +func (rcv *ProtocolStatisticResetFlags) MutateNumBytes(n bool) bool { + return rcv._tab.MutateBool(rcv._tab.Pos+flatbuffers.UOffsetT(1), n) +} + +func CreateProtocolStatisticResetFlags(builder *flatbuffers.Builder, numRequests bool, numBytes bool) flatbuffers.UOffsetT { + builder.Prep(1, 2) + builder.PrependBool(numBytes) + builder.PrependBool(numRequests) + return builder.Offset() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/SDO.go b/pkg/fbs/comm/ethercat/master/fbs/SDO.go index 584ab27..348db35 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SDO.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SDO.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SDOT struct { + Request *SDORequestT + Response *SDOResponseT +} + +func (t *SDOT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SDOStart(builder) + SDOAddRequest(builder, requestOffset) + SDOAddResponse(builder, responseOffset) + return SDOEnd(builder) +} + +func (rcv *SDO) UnPackTo(t *SDOT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SDO) UnPack() *SDOT { + if rcv == nil { return nil } + t := &SDOT{} + rcv.UnPackTo(t) + return t +} + type SDO struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SDORequest.go b/pkg/fbs/comm/ethercat/master/fbs/SDORequest.go index 4d7e071..93572c5 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SDORequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SDORequest.go @@ -6,6 +6,50 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SDORequestT struct { + AddressType Addresstype + Address uint16 + ObjectIndex uint16 + SubIndex byte + Flags SDOFlags + Data []byte + MaxLength uint32 +} + +func (t *SDORequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + SDORequestStart(builder) + SDORequestAddAddressType(builder, t.AddressType) + SDORequestAddAddress(builder, t.Address) + SDORequestAddObjectIndex(builder, t.ObjectIndex) + SDORequestAddSubIndex(builder, t.SubIndex) + SDORequestAddFlags(builder, t.Flags) + SDORequestAddData(builder, dataOffset) + SDORequestAddMaxLength(builder, t.MaxLength) + return SDORequestEnd(builder) +} + +func (rcv *SDORequest) UnPackTo(t *SDORequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.ObjectIndex = rcv.ObjectIndex() + t.SubIndex = rcv.SubIndex() + t.Flags = rcv.Flags() + t.Data = rcv.DataBytes() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *SDORequest) UnPack() *SDORequestT { + if rcv == nil { return nil } + t := &SDORequestT{} + rcv.UnPackTo(t) + return t +} + type SDORequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SDOResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SDOResponse.go index 0d0be09..fdf69e1 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SDOResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SDOResponse.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SDOResponseT struct { + Data []byte +} + +func (t *SDOResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + SDOResponseStart(builder) + SDOResponseAddData(builder, dataOffset) + return SDOResponseEnd(builder) +} + +func (rcv *SDOResponse) UnPackTo(t *SDOResponseT) { + t.Data = rcv.DataBytes() +} + +func (rcv *SDOResponse) UnPack() *SDOResponseT { + if rcv == nil { return nil } + t := &SDOResponseT{} + rcv.UnPackTo(t) + return t +} + type SDOResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfo.go index f088b20..14905b2 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfo.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveConfigInfoT struct { + Request *AddressedRequestT + Response *SlaveConfigInfoResponseT +} + +func (t *SlaveConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveConfigInfoStart(builder) + SlaveConfigInfoAddRequest(builder, requestOffset) + SlaveConfigInfoAddResponse(builder, responseOffset) + return SlaveConfigInfoEnd(builder) +} + +func (rcv *SlaveConfigInfo) UnPackTo(t *SlaveConfigInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveConfigInfo) UnPack() *SlaveConfigInfoT { + if rcv == nil { return nil } + t := &SlaveConfigInfoT{} + rcv.UnPackTo(t) + return t +} + type SlaveConfigInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go index d2af1d6..e41d8d1 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go @@ -6,6 +6,177 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveConfigInfoResponseT struct { + AutoIncAddr uint16 + EthercatAddr uint16 + IdentifyAdo uint16 + IdentifyValue uint16 + SlaveHandle uint32 + HcGroupIdx uint32 + PreviousEthercatAddr uint16 + PreviousPort uint16 + SlaveIdentity *EthercatIdentityInfoT + SlaveName string + MbxProtocols uint32 + MbxStandard *EthercatMailboxInfoT + MbxBootstrap *EthercatMailboxInfoT + ProcessDataIn []*EthercatMemoryInfoT + ProcessDataOut []*EthercatMemoryInfoT + NumProcessVarsIn uint16 + NumProcessVarsOut uint16 + PortDescriptor byte + Reserved01 []byte + WkcStateDiagOffsIn []uint16 + WkcStateDiagOffsOut []uint16 + Reserved02 []uint32 + IsPresent bool + IsHcGroupPresent bool + DcSupport bool +} + +func (t *SlaveConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + slaveNameOffset := builder.CreateString(t.SlaveName) + processDataInOffset := flatbuffers.UOffsetT(0) + if t.ProcessDataIn != nil { + processDataInLength := len(t.ProcessDataIn) + SlaveConfigInfoResponseStartProcessDataInVector(builder, processDataInLength) + for j := processDataInLength - 1; j >= 0; j-- { + t.ProcessDataIn[j].Pack(builder) + } + processDataInOffset = builder.EndVector(processDataInLength) + } + processDataOutOffset := flatbuffers.UOffsetT(0) + if t.ProcessDataOut != nil { + processDataOutLength := len(t.ProcessDataOut) + SlaveConfigInfoResponseStartProcessDataOutVector(builder, processDataOutLength) + for j := processDataOutLength - 1; j >= 0; j-- { + t.ProcessDataOut[j].Pack(builder) + } + processDataOutOffset = builder.EndVector(processDataOutLength) + } + reserved01Offset := flatbuffers.UOffsetT(0) + if t.Reserved01 != nil { + reserved01Offset = builder.CreateByteString(t.Reserved01) + } + wkcStateDiagOffsInOffset := flatbuffers.UOffsetT(0) + if t.WkcStateDiagOffsIn != nil { + wkcStateDiagOffsInLength := len(t.WkcStateDiagOffsIn) + SlaveConfigInfoResponseStartWkcStateDiagOffsInVector(builder, wkcStateDiagOffsInLength) + for j := wkcStateDiagOffsInLength - 1; j >= 0; j-- { + builder.PrependUint16(t.WkcStateDiagOffsIn[j]) + } + wkcStateDiagOffsInOffset = builder.EndVector(wkcStateDiagOffsInLength) + } + wkcStateDiagOffsOutOffset := flatbuffers.UOffsetT(0) + if t.WkcStateDiagOffsOut != nil { + wkcStateDiagOffsOutLength := len(t.WkcStateDiagOffsOut) + SlaveConfigInfoResponseStartWkcStateDiagOffsOutVector(builder, wkcStateDiagOffsOutLength) + for j := wkcStateDiagOffsOutLength - 1; j >= 0; j-- { + builder.PrependUint16(t.WkcStateDiagOffsOut[j]) + } + wkcStateDiagOffsOutOffset = builder.EndVector(wkcStateDiagOffsOutLength) + } + reserved02Offset := flatbuffers.UOffsetT(0) + if t.Reserved02 != nil { + reserved02Length := len(t.Reserved02) + SlaveConfigInfoResponseStartReserved02Vector(builder, reserved02Length) + for j := reserved02Length - 1; j >= 0; j-- { + builder.PrependUint32(t.Reserved02[j]) + } + reserved02Offset = builder.EndVector(reserved02Length) + } + SlaveConfigInfoResponseStart(builder) + SlaveConfigInfoResponseAddAutoIncAddr(builder, t.AutoIncAddr) + SlaveConfigInfoResponseAddEthercatAddr(builder, t.EthercatAddr) + SlaveConfigInfoResponseAddIdentifyAdo(builder, t.IdentifyAdo) + SlaveConfigInfoResponseAddIdentifyValue(builder, t.IdentifyValue) + SlaveConfigInfoResponseAddSlaveHandle(builder, t.SlaveHandle) + SlaveConfigInfoResponseAddHcGroupIdx(builder, t.HcGroupIdx) + SlaveConfigInfoResponseAddPreviousEthercatAddr(builder, t.PreviousEthercatAddr) + SlaveConfigInfoResponseAddPreviousPort(builder, t.PreviousPort) + slaveIdentityOffset := t.SlaveIdentity.Pack(builder) + SlaveConfigInfoResponseAddSlaveIdentity(builder, slaveIdentityOffset) + SlaveConfigInfoResponseAddSlaveName(builder, slaveNameOffset) + SlaveConfigInfoResponseAddMbxProtocols(builder, t.MbxProtocols) + mbxStandardOffset := t.MbxStandard.Pack(builder) + SlaveConfigInfoResponseAddMbxStandard(builder, mbxStandardOffset) + mbxBootstrapOffset := t.MbxBootstrap.Pack(builder) + SlaveConfigInfoResponseAddMbxBootstrap(builder, mbxBootstrapOffset) + SlaveConfigInfoResponseAddProcessDataIn(builder, processDataInOffset) + SlaveConfigInfoResponseAddProcessDataOut(builder, processDataOutOffset) + SlaveConfigInfoResponseAddNumProcessVarsIn(builder, t.NumProcessVarsIn) + SlaveConfigInfoResponseAddNumProcessVarsOut(builder, t.NumProcessVarsOut) + SlaveConfigInfoResponseAddPortDescriptor(builder, t.PortDescriptor) + SlaveConfigInfoResponseAddReserved01(builder, reserved01Offset) + SlaveConfigInfoResponseAddWkcStateDiagOffsIn(builder, wkcStateDiagOffsInOffset) + SlaveConfigInfoResponseAddWkcStateDiagOffsOut(builder, wkcStateDiagOffsOutOffset) + SlaveConfigInfoResponseAddReserved02(builder, reserved02Offset) + SlaveConfigInfoResponseAddIsPresent(builder, t.IsPresent) + SlaveConfigInfoResponseAddIsHcGroupPresent(builder, t.IsHcGroupPresent) + SlaveConfigInfoResponseAddDcSupport(builder, t.DcSupport) + return SlaveConfigInfoResponseEnd(builder) +} + +func (rcv *SlaveConfigInfoResponse) UnPackTo(t *SlaveConfigInfoResponseT) { + t.AutoIncAddr = rcv.AutoIncAddr() + t.EthercatAddr = rcv.EthercatAddr() + t.IdentifyAdo = rcv.IdentifyAdo() + t.IdentifyValue = rcv.IdentifyValue() + t.SlaveHandle = rcv.SlaveHandle() + t.HcGroupIdx = rcv.HcGroupIdx() + t.PreviousEthercatAddr = rcv.PreviousEthercatAddr() + t.PreviousPort = rcv.PreviousPort() + t.SlaveIdentity = rcv.SlaveIdentity(nil).UnPack() + t.SlaveName = string(rcv.SlaveName()) + t.MbxProtocols = rcv.MbxProtocols() + t.MbxStandard = rcv.MbxStandard(nil).UnPack() + t.MbxBootstrap = rcv.MbxBootstrap(nil).UnPack() + processDataInLength := rcv.ProcessDataInLength() + t.ProcessDataIn = make([]*EthercatMemoryInfoT, processDataInLength) + for j := 0; j < processDataInLength; j++ { + x := EthercatMemoryInfo{} + rcv.ProcessDataIn(&x, j) + t.ProcessDataIn[j] = x.UnPack() + } + processDataOutLength := rcv.ProcessDataOutLength() + t.ProcessDataOut = make([]*EthercatMemoryInfoT, processDataOutLength) + for j := 0; j < processDataOutLength; j++ { + x := EthercatMemoryInfo{} + rcv.ProcessDataOut(&x, j) + t.ProcessDataOut[j] = x.UnPack() + } + t.NumProcessVarsIn = rcv.NumProcessVarsIn() + t.NumProcessVarsOut = rcv.NumProcessVarsOut() + t.PortDescriptor = rcv.PortDescriptor() + t.Reserved01 = rcv.Reserved01Bytes() + wkcStateDiagOffsInLength := rcv.WkcStateDiagOffsInLength() + t.WkcStateDiagOffsIn = make([]uint16, wkcStateDiagOffsInLength) + for j := 0; j < wkcStateDiagOffsInLength; j++ { + t.WkcStateDiagOffsIn[j] = rcv.WkcStateDiagOffsIn(j) + } + wkcStateDiagOffsOutLength := rcv.WkcStateDiagOffsOutLength() + t.WkcStateDiagOffsOut = make([]uint16, wkcStateDiagOffsOutLength) + for j := 0; j < wkcStateDiagOffsOutLength; j++ { + t.WkcStateDiagOffsOut[j] = rcv.WkcStateDiagOffsOut(j) + } + reserved02Length := rcv.Reserved02Length() + t.Reserved02 = make([]uint32, reserved02Length) + for j := 0; j < reserved02Length; j++ { + t.Reserved02[j] = rcv.Reserved02(j) + } + t.IsPresent = rcv.IsPresent() + t.IsHcGroupPresent = rcv.IsHcGroupPresent() + t.DcSupport = rcv.DcSupport() +} + +func (rcv *SlaveConfigInfoResponse) UnPack() *SlaveConfigInfoResponseT { + if rcv == nil { return nil } + t := &SlaveConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveConfigInfoResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveEeprom.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveEeprom.go index 729ebed..04a37d2 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveEeprom.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveEeprom.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveEepromT struct { + Request *SlaveEepromRequestT + Response *SlaveEepromResponseT +} + +func (t *SlaveEepromT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveEepromStart(builder) + SlaveEepromAddRequest(builder, requestOffset) + SlaveEepromAddResponse(builder, responseOffset) + return SlaveEepromEnd(builder) +} + +func (rcv *SlaveEeprom) UnPackTo(t *SlaveEepromT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveEeprom) UnPack() *SlaveEepromT { + if rcv == nil { return nil } + t := &SlaveEepromT{} + rcv.UnPackTo(t) + return t +} + type SlaveEeprom struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromRequest.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromRequest.go index ccb74a1..7a5df64 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromRequest.go @@ -6,6 +6,53 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveEepromRequestT struct { + AddressType Addresstype + Address uint16 + EepromOffset uint16 + Data []uint16 + MaxLength uint32 +} + +func (t *SlaveEepromRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataLength := len(t.Data) + SlaveEepromRequestStartDataVector(builder, dataLength) + for j := dataLength - 1; j >= 0; j-- { + builder.PrependUint16(t.Data[j]) + } + dataOffset = builder.EndVector(dataLength) + } + SlaveEepromRequestStart(builder) + SlaveEepromRequestAddAddressType(builder, t.AddressType) + SlaveEepromRequestAddAddress(builder, t.Address) + SlaveEepromRequestAddEepromOffset(builder, t.EepromOffset) + SlaveEepromRequestAddData(builder, dataOffset) + SlaveEepromRequestAddMaxLength(builder, t.MaxLength) + return SlaveEepromRequestEnd(builder) +} + +func (rcv *SlaveEepromRequest) UnPackTo(t *SlaveEepromRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.EepromOffset = rcv.EepromOffset() + dataLength := rcv.DataLength() + t.Data = make([]uint16, dataLength) + for j := 0; j < dataLength; j++ { + t.Data[j] = rcv.Data(j) + } + t.MaxLength = rcv.MaxLength() +} + +func (rcv *SlaveEepromRequest) UnPack() *SlaveEepromRequestT { + if rcv == nil { return nil } + t := &SlaveEepromRequestT{} + rcv.UnPackTo(t) + return t +} + type SlaveEepromRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromResponse.go index 6a2b025..c253ab7 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveEepromResponse.go @@ -6,6 +6,41 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveEepromResponseT struct { + Data []uint16 +} + +func (t *SlaveEepromResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataLength := len(t.Data) + SlaveEepromResponseStartDataVector(builder, dataLength) + for j := dataLength - 1; j >= 0; j-- { + builder.PrependUint16(t.Data[j]) + } + dataOffset = builder.EndVector(dataLength) + } + SlaveEepromResponseStart(builder) + SlaveEepromResponseAddData(builder, dataOffset) + return SlaveEepromResponseEnd(builder) +} + +func (rcv *SlaveEepromResponse) UnPackTo(t *SlaveEepromResponseT) { + dataLength := rcv.DataLength() + t.Data = make([]uint16, dataLength) + for j := 0; j < dataLength; j++ { + t.Data[j] = rcv.Data(j) + } +} + +func (rcv *SlaveEepromResponse) UnPack() *SlaveEepromResponseT { + if rcv == nil { return nil } + t := &SlaveEepromResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveEepromResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfo.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfo.go index a2dcf12..3ef6b40 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfo.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfo.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveOnlineInfoT struct { + Request *AddressedRequestT + Response *SlaveOnlineInfoResponseT +} + +func (t *SlaveOnlineInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveOnlineInfoStart(builder) + SlaveOnlineInfoAddRequest(builder, requestOffset) + SlaveOnlineInfoAddResponse(builder, responseOffset) + return SlaveOnlineInfoEnd(builder) +} + +func (rcv *SlaveOnlineInfo) UnPackTo(t *SlaveOnlineInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveOnlineInfo) UnPack() *SlaveOnlineInfoT { + if rcv == nil { return nil } + t := &SlaveOnlineInfoT{} + rcv.UnPackTo(t) + return t +} + type SlaveOnlineInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go index 93f8552..2a7bead 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go @@ -6,6 +6,133 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveOnlineInfoResponseT struct { + AutoIncAddr uint16 + EthercatAddr uint16 + StationAlias uint16 + IdentifyValue uint16 + SlaveHandle uint32 + PortSlaveHandles []uint32 + SlaveIdentity *EthercatIdentityInfoT + EscType byte + EscRevision byte + EscBuild uint16 + EscFeatures uint16 + PortDescriptor byte + Reserved01 byte + AlStatus uint16 + AlStatusCode uint16 + MbxProtocols uint16 + DlStatus uint16 + PortState uint16 + PreviousPort uint16 + SystemTimeDifference uint32 + SlaveDelay uint32 + PropagationDelay uint32 + Reserved02 []uint32 + DcSupport bool + Dc64Support bool + IsRefClock bool + LineCrossed bool +} + +func (t *SlaveOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + portSlaveHandlesOffset := flatbuffers.UOffsetT(0) + if t.PortSlaveHandles != nil { + portSlaveHandlesLength := len(t.PortSlaveHandles) + SlaveOnlineInfoResponseStartPortSlaveHandlesVector(builder, portSlaveHandlesLength) + for j := portSlaveHandlesLength - 1; j >= 0; j-- { + builder.PrependUint32(t.PortSlaveHandles[j]) + } + portSlaveHandlesOffset = builder.EndVector(portSlaveHandlesLength) + } + reserved02Offset := flatbuffers.UOffsetT(0) + if t.Reserved02 != nil { + reserved02Length := len(t.Reserved02) + SlaveOnlineInfoResponseStartReserved02Vector(builder, reserved02Length) + for j := reserved02Length - 1; j >= 0; j-- { + builder.PrependUint32(t.Reserved02[j]) + } + reserved02Offset = builder.EndVector(reserved02Length) + } + SlaveOnlineInfoResponseStart(builder) + SlaveOnlineInfoResponseAddAutoIncAddr(builder, t.AutoIncAddr) + SlaveOnlineInfoResponseAddEthercatAddr(builder, t.EthercatAddr) + SlaveOnlineInfoResponseAddStationAlias(builder, t.StationAlias) + SlaveOnlineInfoResponseAddIdentifyValue(builder, t.IdentifyValue) + SlaveOnlineInfoResponseAddSlaveHandle(builder, t.SlaveHandle) + SlaveOnlineInfoResponseAddPortSlaveHandles(builder, portSlaveHandlesOffset) + slaveIdentityOffset := t.SlaveIdentity.Pack(builder) + SlaveOnlineInfoResponseAddSlaveIdentity(builder, slaveIdentityOffset) + SlaveOnlineInfoResponseAddEscType(builder, t.EscType) + SlaveOnlineInfoResponseAddEscRevision(builder, t.EscRevision) + SlaveOnlineInfoResponseAddEscBuild(builder, t.EscBuild) + SlaveOnlineInfoResponseAddEscFeatures(builder, t.EscFeatures) + SlaveOnlineInfoResponseAddPortDescriptor(builder, t.PortDescriptor) + SlaveOnlineInfoResponseAddReserved01(builder, t.Reserved01) + SlaveOnlineInfoResponseAddAlStatus(builder, t.AlStatus) + SlaveOnlineInfoResponseAddAlStatusCode(builder, t.AlStatusCode) + SlaveOnlineInfoResponseAddMbxProtocols(builder, t.MbxProtocols) + SlaveOnlineInfoResponseAddDlStatus(builder, t.DlStatus) + SlaveOnlineInfoResponseAddPortState(builder, t.PortState) + SlaveOnlineInfoResponseAddPreviousPort(builder, t.PreviousPort) + SlaveOnlineInfoResponseAddSystemTimeDifference(builder, t.SystemTimeDifference) + SlaveOnlineInfoResponseAddSlaveDelay(builder, t.SlaveDelay) + SlaveOnlineInfoResponseAddPropagationDelay(builder, t.PropagationDelay) + SlaveOnlineInfoResponseAddReserved02(builder, reserved02Offset) + SlaveOnlineInfoResponseAddDcSupport(builder, t.DcSupport) + SlaveOnlineInfoResponseAddDc64Support(builder, t.Dc64Support) + SlaveOnlineInfoResponseAddIsRefClock(builder, t.IsRefClock) + SlaveOnlineInfoResponseAddLineCrossed(builder, t.LineCrossed) + return SlaveOnlineInfoResponseEnd(builder) +} + +func (rcv *SlaveOnlineInfoResponse) UnPackTo(t *SlaveOnlineInfoResponseT) { + t.AutoIncAddr = rcv.AutoIncAddr() + t.EthercatAddr = rcv.EthercatAddr() + t.StationAlias = rcv.StationAlias() + t.IdentifyValue = rcv.IdentifyValue() + t.SlaveHandle = rcv.SlaveHandle() + portSlaveHandlesLength := rcv.PortSlaveHandlesLength() + t.PortSlaveHandles = make([]uint32, portSlaveHandlesLength) + for j := 0; j < portSlaveHandlesLength; j++ { + t.PortSlaveHandles[j] = rcv.PortSlaveHandles(j) + } + t.SlaveIdentity = rcv.SlaveIdentity(nil).UnPack() + t.EscType = rcv.EscType() + t.EscRevision = rcv.EscRevision() + t.EscBuild = rcv.EscBuild() + t.EscFeatures = rcv.EscFeatures() + t.PortDescriptor = rcv.PortDescriptor() + t.Reserved01 = rcv.Reserved01() + t.AlStatus = rcv.AlStatus() + t.AlStatusCode = rcv.AlStatusCode() + t.MbxProtocols = rcv.MbxProtocols() + t.DlStatus = rcv.DlStatus() + t.PortState = rcv.PortState() + t.PreviousPort = rcv.PreviousPort() + t.SystemTimeDifference = rcv.SystemTimeDifference() + t.SlaveDelay = rcv.SlaveDelay() + t.PropagationDelay = rcv.PropagationDelay() + reserved02Length := rcv.Reserved02Length() + t.Reserved02 = make([]uint32, reserved02Length) + for j := 0; j < reserved02Length; j++ { + t.Reserved02[j] = rcv.Reserved02(j) + } + t.DcSupport = rcv.DcSupport() + t.Dc64Support = rcv.Dc64Support() + t.IsRefClock = rcv.IsRefClock() + t.LineCrossed = rcv.LineCrossed() +} + +func (rcv *SlaveOnlineInfoResponse) UnPack() *SlaveOnlineInfoResponseT { + if rcv == nil { return nil } + t := &SlaveOnlineInfoResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveOnlineInfoResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegister.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegister.go index 3deebec..8f4f93a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegister.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegister.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveRegisterT struct { + Request *SlaveRegisterRequestT + Response *SlaveRegisterResponseT +} + +func (t *SlaveRegisterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveRegisterStart(builder) + SlaveRegisterAddRequest(builder, requestOffset) + SlaveRegisterAddResponse(builder, responseOffset) + return SlaveRegisterEnd(builder) +} + +func (rcv *SlaveRegister) UnPackTo(t *SlaveRegisterT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveRegister) UnPack() *SlaveRegisterT { + if rcv == nil { return nil } + t := &SlaveRegisterT{} + rcv.UnPackTo(t) + return t +} + type SlaveRegister struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterRequest.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterRequest.go index c3b454f..5b8065c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterRequest.go @@ -6,6 +6,44 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveRegisterRequestT struct { + AddressType Addresstype + Address uint16 + RegisterOffset uint16 + Data []byte + MaxLength uint32 +} + +func (t *SlaveRegisterRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + SlaveRegisterRequestStart(builder) + SlaveRegisterRequestAddAddressType(builder, t.AddressType) + SlaveRegisterRequestAddAddress(builder, t.Address) + SlaveRegisterRequestAddRegisterOffset(builder, t.RegisterOffset) + SlaveRegisterRequestAddData(builder, dataOffset) + SlaveRegisterRequestAddMaxLength(builder, t.MaxLength) + return SlaveRegisterRequestEnd(builder) +} + +func (rcv *SlaveRegisterRequest) UnPackTo(t *SlaveRegisterRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.RegisterOffset = rcv.RegisterOffset() + t.Data = rcv.DataBytes() + t.MaxLength = rcv.MaxLength() +} + +func (rcv *SlaveRegisterRequest) UnPack() *SlaveRegisterRequestT { + if rcv == nil { return nil } + t := &SlaveRegisterRequestT{} + rcv.UnPackTo(t) + return t +} + type SlaveRegisterRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterResponse.go index 8edf7b4..a84043b 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveRegisterResponse.go @@ -6,6 +6,32 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveRegisterResponseT struct { + Data []byte +} + +func (t *SlaveRegisterResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataOffset = builder.CreateByteString(t.Data) + } + SlaveRegisterResponseStart(builder) + SlaveRegisterResponseAddData(builder, dataOffset) + return SlaveRegisterResponseEnd(builder) +} + +func (rcv *SlaveRegisterResponse) UnPackTo(t *SlaveRegisterResponseT) { + t.Data = rcv.DataBytes() +} + +func (rcv *SlaveRegisterResponse) UnPack() *SlaveRegisterResponseT { + if rcv == nil { return nil } + t := &SlaveRegisterResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveRegisterResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveState.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveState.go index 6a6979a..070646f 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveState.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveState.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStateT struct { + Request *SlaveStateRequestT + Response *SlaveStateResponseT +} + +func (t *SlaveStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveStateStart(builder) + SlaveStateAddRequest(builder, requestOffset) + SlaveStateAddResponse(builder, responseOffset) + return SlaveStateEnd(builder) +} + +func (rcv *SlaveState) UnPackTo(t *SlaveStateT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveState) UnPack() *SlaveStateT { + if rcv == nil { return nil } + t := &SlaveStateT{} + rcv.UnPackTo(t) + return t +} + type SlaveState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStateRequest.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStateRequest.go index 7d7aa4a..d4c6ed7 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStateRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStateRequest.go @@ -6,6 +6,34 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStateRequestT struct { + AddressType Addresstype + Address uint16 + NewState EthercatState +} + +func (t *SlaveStateRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStateRequestStart(builder) + SlaveStateRequestAddAddressType(builder, t.AddressType) + SlaveStateRequestAddAddress(builder, t.Address) + SlaveStateRequestAddNewState(builder, t.NewState) + return SlaveStateRequestEnd(builder) +} + +func (rcv *SlaveStateRequest) UnPackTo(t *SlaveStateRequestT) { + t.AddressType = rcv.AddressType() + t.Address = rcv.Address() + t.NewState = rcv.NewState() +} + +func (rcv *SlaveStateRequest) UnPack() *SlaveStateRequestT { + if rcv == nil { return nil } + t := &SlaveStateRequestT{} + rcv.UnPackTo(t) + return t +} + type SlaveStateRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStateResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStateResponse.go index 7393c25..d94ad45 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStateResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStateResponse.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStateResponseT struct { + CurrentState EthercatState + RequestedState EthercatState +} + +func (t *SlaveStateResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStateResponseStart(builder) + SlaveStateResponseAddCurrentState(builder, t.CurrentState) + SlaveStateResponseAddRequestedState(builder, t.RequestedState) + return SlaveStateResponseEnd(builder) +} + +func (rcv *SlaveStateResponse) UnPackTo(t *SlaveStateResponseT) { + t.CurrentState = rcv.CurrentState() + t.RequestedState = rcv.RequestedState() +} + +func (rcv *SlaveStateResponse) UnPack() *SlaveStateResponseT { + if rcv == nil { return nil } + t := &SlaveStateResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveStateResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCounters.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCounters.go index 3b24347..07ecf7f 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCounters.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCounters.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticCountersT struct { + Request *AddressedRequestT + Response *SlaveStatisticCountersResponseT +} + +func (t *SlaveStatisticCountersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveStatisticCountersStart(builder) + SlaveStatisticCountersAddRequest(builder, requestOffset) + SlaveStatisticCountersAddResponse(builder, responseOffset) + return SlaveStatisticCountersEnd(builder) +} + +func (rcv *SlaveStatisticCounters) UnPackTo(t *SlaveStatisticCountersT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveStatisticCounters) UnPack() *SlaveStatisticCountersT { + if rcv == nil { return nil } + t := &SlaveStatisticCountersT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticCounters struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCountersResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCountersResponse.go index 410f64e..00f1fe2 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCountersResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticCountersResponse.go @@ -6,6 +6,52 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticCountersResponseT struct { + AlStatusCode uint16 + ProcUnitErrorCounter byte + PdiErrorCounter byte + PortErrorCounters []*PortErrorCountersT +} + +func (t *SlaveStatisticCountersResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + portErrorCountersOffset := flatbuffers.UOffsetT(0) + if t.PortErrorCounters != nil { + portErrorCountersLength := len(t.PortErrorCounters) + SlaveStatisticCountersResponseStartPortErrorCountersVector(builder, portErrorCountersLength) + for j := portErrorCountersLength - 1; j >= 0; j-- { + t.PortErrorCounters[j].Pack(builder) + } + portErrorCountersOffset = builder.EndVector(portErrorCountersLength) + } + SlaveStatisticCountersResponseStart(builder) + SlaveStatisticCountersResponseAddAlStatusCode(builder, t.AlStatusCode) + SlaveStatisticCountersResponseAddProcUnitErrorCounter(builder, t.ProcUnitErrorCounter) + SlaveStatisticCountersResponseAddPdiErrorCounter(builder, t.PdiErrorCounter) + SlaveStatisticCountersResponseAddPortErrorCounters(builder, portErrorCountersOffset) + return SlaveStatisticCountersResponseEnd(builder) +} + +func (rcv *SlaveStatisticCountersResponse) UnPackTo(t *SlaveStatisticCountersResponseT) { + t.AlStatusCode = rcv.AlStatusCode() + t.ProcUnitErrorCounter = rcv.ProcUnitErrorCounter() + t.PdiErrorCounter = rcv.PdiErrorCounter() + portErrorCountersLength := rcv.PortErrorCountersLength() + t.PortErrorCounters = make([]*PortErrorCountersT, portErrorCountersLength) + for j := 0; j < portErrorCountersLength; j++ { + x := PortErrorCounters{} + rcv.PortErrorCounters(&x, j) + t.PortErrorCounters[j] = x.UnPack() + } +} + +func (rcv *SlaveStatisticCountersResponse) UnPack() *SlaveStatisticCountersResponseT { + if rcv == nil { return nil } + t := &SlaveStatisticCountersResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticCountersResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAuto.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAuto.go index eac24e7..95bd96f 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAuto.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAuto.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeAutoT struct { + Request *SlaveStatisticModeAutoRequestT + Response *SlaveStatisticModeAutoResponseT +} + +func (t *SlaveStatisticModeAutoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveStatisticModeAutoStart(builder) + SlaveStatisticModeAutoAddRequest(builder, requestOffset) + SlaveStatisticModeAutoAddResponse(builder, responseOffset) + return SlaveStatisticModeAutoEnd(builder) +} + +func (rcv *SlaveStatisticModeAuto) UnPackTo(t *SlaveStatisticModeAutoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveStatisticModeAuto) UnPack() *SlaveStatisticModeAutoT { + if rcv == nil { return nil } + t := &SlaveStatisticModeAutoT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeAuto struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoRequest.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoRequest.go index 3da4d8c..c00f14c 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoRequest.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeAutoRequestT struct { + Enable bool + IdleTime uint32 +} + +func (t *SlaveStatisticModeAutoRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStatisticModeAutoRequestStart(builder) + SlaveStatisticModeAutoRequestAddEnable(builder, t.Enable) + SlaveStatisticModeAutoRequestAddIdleTime(builder, t.IdleTime) + return SlaveStatisticModeAutoRequestEnd(builder) +} + +func (rcv *SlaveStatisticModeAutoRequest) UnPackTo(t *SlaveStatisticModeAutoRequestT) { + t.Enable = rcv.Enable() + t.IdleTime = rcv.IdleTime() +} + +func (rcv *SlaveStatisticModeAutoRequest) UnPack() *SlaveStatisticModeAutoRequestT { + if rcv == nil { return nil } + t := &SlaveStatisticModeAutoRequestT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeAutoRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoResponse.go index 07531da..62a5280 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeAutoResponse.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeAutoResponseT struct { + Enable bool + IdleTime uint32 +} + +func (t *SlaveStatisticModeAutoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStatisticModeAutoResponseStart(builder) + SlaveStatisticModeAutoResponseAddEnable(builder, t.Enable) + SlaveStatisticModeAutoResponseAddIdleTime(builder, t.IdleTime) + return SlaveStatisticModeAutoResponseEnd(builder) +} + +func (rcv *SlaveStatisticModeAutoResponse) UnPackTo(t *SlaveStatisticModeAutoResponseT) { + t.Enable = rcv.Enable() + t.IdleTime = rcv.IdleTime() +} + +func (rcv *SlaveStatisticModeAutoResponse) UnPack() *SlaveStatisticModeAutoResponseT { + if rcv == nil { return nil } + t := &SlaveStatisticModeAutoResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeAutoResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTrigger.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTrigger.go index 091f3d2..1bd7e09 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTrigger.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTrigger.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeSingleShotTriggerT struct { + Request *SlaveStatisticModeSingleShotTriggerRequestT + Response *SlaveStatisticModeSingleShotTriggerResponseT +} + +func (t *SlaveStatisticModeSingleShotTriggerT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + SlaveStatisticModeSingleShotTriggerStart(builder) + SlaveStatisticModeSingleShotTriggerAddRequest(builder, requestOffset) + SlaveStatisticModeSingleShotTriggerAddResponse(builder, responseOffset) + return SlaveStatisticModeSingleShotTriggerEnd(builder) +} + +func (rcv *SlaveStatisticModeSingleShotTrigger) UnPackTo(t *SlaveStatisticModeSingleShotTriggerT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *SlaveStatisticModeSingleShotTrigger) UnPack() *SlaveStatisticModeSingleShotTriggerT { + if rcv == nil { return nil } + t := &SlaveStatisticModeSingleShotTriggerT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeSingleShotTrigger struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerRequest.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerRequest.go index db34889..8df78fe 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerRequest.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerRequest.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeSingleShotTriggerRequestT struct { + Force bool +} + +func (t *SlaveStatisticModeSingleShotTriggerRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStatisticModeSingleShotTriggerRequestStart(builder) + SlaveStatisticModeSingleShotTriggerRequestAddForce(builder, t.Force) + return SlaveStatisticModeSingleShotTriggerRequestEnd(builder) +} + +func (rcv *SlaveStatisticModeSingleShotTriggerRequest) UnPackTo(t *SlaveStatisticModeSingleShotTriggerRequestT) { + t.Force = rcv.Force() +} + +func (rcv *SlaveStatisticModeSingleShotTriggerRequest) UnPack() *SlaveStatisticModeSingleShotTriggerRequestT { + if rcv == nil { return nil } + t := &SlaveStatisticModeSingleShotTriggerRequestT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeSingleShotTriggerRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerResponse.go index fb2b8ce..48d7ec8 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveStatisticModeSingleShotTriggerResponse.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SlaveStatisticModeSingleShotTriggerResponseT struct { + Forced bool + Discarded bool +} + +func (t *SlaveStatisticModeSingleShotTriggerResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SlaveStatisticModeSingleShotTriggerResponseStart(builder) + SlaveStatisticModeSingleShotTriggerResponseAddForced(builder, t.Forced) + SlaveStatisticModeSingleShotTriggerResponseAddDiscarded(builder, t.Discarded) + return SlaveStatisticModeSingleShotTriggerResponseEnd(builder) +} + +func (rcv *SlaveStatisticModeSingleShotTriggerResponse) UnPackTo(t *SlaveStatisticModeSingleShotTriggerResponseT) { + t.Forced = rcv.Forced() + t.Discarded = rcv.Discarded() +} + +func (rcv *SlaveStatisticModeSingleShotTriggerResponse) UnPack() *SlaveStatisticModeSingleShotTriggerResponseT { + if rcv == nil { return nil } + t := &SlaveStatisticModeSingleShotTriggerResponseT{} + rcv.UnPackTo(t) + return t +} + type SlaveStatisticModeSingleShotTriggerResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SyncMode.go b/pkg/fbs/comm/ethercat/master/fbs/SyncMode.go new file mode 100644 index 0000000..599a41b --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/SyncMode.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type SyncMode uint32 + +const ( + SyncModefreerun SyncMode = 0 + SyncModedcmAuto SyncMode = 1 + SyncModedcEnable SyncMode = 2 + SyncModedcmBusShift SyncMode = 3 + SyncModedcmMasterShift SyncMode = 4 + SyncModedcmLinkLayerRefClock SyncMode = 5 + SyncModeunknown SyncMode = 4294967295 +) + +var EnumNamesSyncMode = map[SyncMode]string{ + SyncModefreerun: "freerun", + SyncModedcmAuto: "dcmAuto", + SyncModedcEnable: "dcEnable", + SyncModedcmBusShift: "dcmBusShift", + SyncModedcmMasterShift: "dcmMasterShift", + SyncModedcmLinkLayerRefClock: "dcmLinkLayerRefClock", + SyncModeunknown: "unknown", +} + +var EnumValuesSyncMode = map[string]SyncMode{ + "freerun": SyncModefreerun, + "dcmAuto": SyncModedcmAuto, + "dcEnable": SyncModedcEnable, + "dcmBusShift": SyncModedcmBusShift, + "dcmMasterShift": SyncModedcmMasterShift, + "dcmLinkLayerRefClock": SyncModedcmLinkLayerRefClock, + "unknown": SyncModeunknown, +} + +func (v SyncMode) String() string { + if s, ok := EnumNamesSyncMode[v]; ok { + return s + } + return "SyncMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TopologyState.go b/pkg/fbs/comm/ethercat/master/fbs/TopologyState.go new file mode 100644 index 0000000..32adcfd --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TopologyState.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type TopologyState uint32 + +const ( + TopologyStateunknown TopologyState = 0 + TopologyStatevalid TopologyState = 1 + TopologyStatepending TopologyState = 2 +) + +var EnumNamesTopologyState = map[TopologyState]string{ + TopologyStateunknown: "unknown", + TopologyStatevalid: "valid", + TopologyStatepending: "pending", +} + +var EnumValuesTopologyState = map[string]TopologyState{ + "unknown": TopologyStateunknown, + "valid": TopologyStatevalid, + "pending": TopologyStatepending, +} + +func (v TopologyState) String() string { + if s, ok := EnumNamesTopologyState[v]; ok { + return s + } + return "TopologyState(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TopologyStatus.go b/pkg/fbs/comm/ethercat/master/fbs/TopologyStatus.go new file mode 100644 index 0000000..d6f95d9 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TopologyStatus.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TopologyStatusT struct { + Response *TopologyStatusResponseT +} + +func (t *TopologyStatusT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + TopologyStatusStart(builder) + TopologyStatusAddResponse(builder, responseOffset) + return TopologyStatusEnd(builder) +} + +func (rcv *TopologyStatus) UnPackTo(t *TopologyStatusT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *TopologyStatus) UnPack() *TopologyStatusT { + if rcv == nil { return nil } + t := &TopologyStatusT{} + rcv.UnPackTo(t) + return t +} + +type TopologyStatus struct { + _tab flatbuffers.Table +} + +func GetRootAsTopologyStatus(buf []byte, offset flatbuffers.UOffsetT) *TopologyStatus { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TopologyStatus{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTopologyStatus(buf []byte, offset flatbuffers.UOffsetT) *TopologyStatus { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TopologyStatus{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TopologyStatus) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TopologyStatus) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TopologyStatus) Response(obj *TopologyStatusResponse) *TopologyStatusResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TopologyStatusResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func TopologyStatusStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TopologyStatusAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func TopologyStatusEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TopologyStatusResponse.go b/pkg/fbs/comm/ethercat/master/fbs/TopologyStatusResponse.go new file mode 100644 index 0000000..43632c8 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TopologyStatusResponse.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TopologyStatusResponseT struct { + State TopologyState + NumChanges uint32 +} + +func (t *TopologyStatusResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TopologyStatusResponseStart(builder) + TopologyStatusResponseAddState(builder, t.State) + TopologyStatusResponseAddNumChanges(builder, t.NumChanges) + return TopologyStatusResponseEnd(builder) +} + +func (rcv *TopologyStatusResponse) UnPackTo(t *TopologyStatusResponseT) { + t.State = rcv.State() + t.NumChanges = rcv.NumChanges() +} + +func (rcv *TopologyStatusResponse) UnPack() *TopologyStatusResponseT { + if rcv == nil { return nil } + t := &TopologyStatusResponseT{} + rcv.UnPackTo(t) + return t +} + +type TopologyStatusResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsTopologyStatusResponse(buf []byte, offset flatbuffers.UOffsetT) *TopologyStatusResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TopologyStatusResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTopologyStatusResponse(buf []byte, offset flatbuffers.UOffsetT) *TopologyStatusResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TopologyStatusResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TopologyStatusResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TopologyStatusResponse) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TopologyStatusResponse) State() TopologyState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return TopologyState(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *TopologyStatusResponse) MutateState(n TopologyState) bool { + return rcv._tab.MutateUint32Slot(4, uint32(n)) +} + +func (rcv *TopologyStatusResponse) NumChanges() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TopologyStatusResponse) MutateNumChanges(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func TopologyStatusResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func TopologyStatusResponseAddState(builder *flatbuffers.Builder, state TopologyState) { + builder.PrependUint32Slot(0, uint32(state), 0) +} +func TopologyStatusResponseAddNumChanges(builder *flatbuffers.Builder, numChanges uint32) { + builder.PrependUint32Slot(1, numChanges, 0) +} +func TopologyStatusResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/taskInfo.go b/pkg/fbs/comm/ethercat/master/fbs/taskInfo.go new file mode 100644 index 0000000..4009c05 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/taskInfo.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + common__scheduler__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/fbs" +) + +type taskInfoT struct { + Task *common__scheduler__fbs.TaskT + Counter uint64 +} + +func (t *taskInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskOffset := t.Task.Pack(builder) + taskInfoStart(builder) + taskInfoAddTask(builder, taskOffset) + taskInfoAddCounter(builder, t.Counter) + return taskInfoEnd(builder) +} + +func (rcv *taskInfo) UnPackTo(t *taskInfoT) { + t.Task = rcv.Task(nil).UnPack() + t.Counter = rcv.Counter() +} + +func (rcv *taskInfo) UnPack() *taskInfoT { + if rcv == nil { return nil } + t := &taskInfoT{} + rcv.UnPackTo(t) + return t +} + +type taskInfo struct { + _tab flatbuffers.Table +} + +func GetRootAstaskInfo(buf []byte, offset flatbuffers.UOffsetT) *taskInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &taskInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAstaskInfo(buf []byte, offset flatbuffers.UOffsetT) *taskInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &taskInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *taskInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *taskInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *taskInfo) Task(obj *common__scheduler__fbs.Task) *common__scheduler__fbs.Task { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(common__scheduler__fbs.Task) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *taskInfo) Counter() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *taskInfo) MutateCounter(n uint64) bool { + return rcv._tab.MutateUint64Slot(6, n) +} + +func taskInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func taskInfoAddTask(builder *flatbuffers.Builder, task flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(task), 0) +} +func taskInfoAddCounter(builder *flatbuffers.Builder, counter uint64) { + builder.PrependUint64Slot(1, counter, 0) +} +func taskInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/client/ClientConfiguration.go b/pkg/fbs/comm/opcua/client/ClientConfiguration.go index 7b67eed..a0227bf 100644 --- a/pkg/fbs/comm/opcua/client/ClientConfiguration.go +++ b/pkg/fbs/comm/opcua/client/ClientConfiguration.go @@ -6,6 +6,44 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ClientConfigurationT struct { + Name string + EndpointUrl string + SessionConfiguration *SessionConfigurationT + TimeoutConfiguration *TimeoutConfigurationT + Persistent bool +} + +func (t *ClientConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + endpointUrlOffset := builder.CreateString(t.EndpointUrl) + sessionConfigurationOffset := t.SessionConfiguration.Pack(builder) + timeoutConfigurationOffset := t.TimeoutConfiguration.Pack(builder) + ClientConfigurationStart(builder) + ClientConfigurationAddName(builder, nameOffset) + ClientConfigurationAddEndpointUrl(builder, endpointUrlOffset) + ClientConfigurationAddSessionConfiguration(builder, sessionConfigurationOffset) + ClientConfigurationAddTimeoutConfiguration(builder, timeoutConfigurationOffset) + ClientConfigurationAddPersistent(builder, t.Persistent) + return ClientConfigurationEnd(builder) +} + +func (rcv *ClientConfiguration) UnPackTo(t *ClientConfigurationT) { + t.Name = string(rcv.Name()) + t.EndpointUrl = string(rcv.EndpointUrl()) + t.SessionConfiguration = rcv.SessionConfiguration(nil).UnPack() + t.TimeoutConfiguration = rcv.TimeoutConfiguration(nil).UnPack() + t.Persistent = rcv.Persistent() +} + +func (rcv *ClientConfiguration) UnPack() *ClientConfigurationT { + if rcv == nil { return nil } + t := &ClientConfigurationT{} + rcv.UnPackTo(t) + return t +} + type ClientConfiguration struct { _tab flatbuffers.Table } @@ -75,8 +113,20 @@ func (rcv *ClientConfiguration) TimeoutConfiguration(obj *TimeoutConfiguration) return nil } +func (rcv *ClientConfiguration) Persistent() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *ClientConfiguration) MutatePersistent(n bool) bool { + return rcv._tab.MutateBoolSlot(12, n) +} + func ClientConfigurationStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(5) } func ClientConfigurationAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) @@ -90,6 +140,9 @@ func ClientConfigurationAddSessionConfiguration(builder *flatbuffers.Builder, se func ClientConfigurationAddTimeoutConfiguration(builder *flatbuffers.Builder, timeoutConfiguration flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(timeoutConfiguration), 0) } +func ClientConfigurationAddPersistent(builder *flatbuffers.Builder, persistent bool) { + builder.PrependBoolSlot(4, persistent, false) +} func ClientConfigurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/opcua/client/DlResultToUaStatusCode.go b/pkg/fbs/comm/opcua/client/DlResultToUaStatusCode.go index fc38179..35118f3 100644 --- a/pkg/fbs/comm/opcua/client/DlResultToUaStatusCode.go +++ b/pkg/fbs/comm/opcua/client/DlResultToUaStatusCode.go @@ -6,6 +6,39 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DlResultToUaStatusCodeT struct { + DlResult uint32 + UaStatusCode uint32 + UaStatusCodeName string + UaStatusCodeDescr string +} + +func (t *DlResultToUaStatusCodeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + uaStatusCodeNameOffset := builder.CreateString(t.UaStatusCodeName) + uaStatusCodeDescrOffset := builder.CreateString(t.UaStatusCodeDescr) + DlResultToUaStatusCodeStart(builder) + DlResultToUaStatusCodeAddDlResult(builder, t.DlResult) + DlResultToUaStatusCodeAddUaStatusCode(builder, t.UaStatusCode) + DlResultToUaStatusCodeAddUaStatusCodeName(builder, uaStatusCodeNameOffset) + DlResultToUaStatusCodeAddUaStatusCodeDescr(builder, uaStatusCodeDescrOffset) + return DlResultToUaStatusCodeEnd(builder) +} + +func (rcv *DlResultToUaStatusCode) UnPackTo(t *DlResultToUaStatusCodeT) { + t.DlResult = rcv.DlResult() + t.UaStatusCode = rcv.UaStatusCode() + t.UaStatusCodeName = string(rcv.UaStatusCodeName()) + t.UaStatusCodeDescr = string(rcv.UaStatusCodeDescr()) +} + +func (rcv *DlResultToUaStatusCode) UnPack() *DlResultToUaStatusCodeT { + if rcv == nil { return nil } + t := &DlResultToUaStatusCodeT{} + rcv.UnPackTo(t) + return t +} + type DlResultToUaStatusCode struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/ErrorCodeMapping.go b/pkg/fbs/comm/opcua/client/ErrorCodeMapping.go index 7eedfad..ec056a5 100644 --- a/pkg/fbs/comm/opcua/client/ErrorCodeMapping.go +++ b/pkg/fbs/comm/opcua/client/ErrorCodeMapping.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ErrorCodeMappingT struct { + ListDlResultToUaStatusCode []*DlResultToUaStatusCodeT +} + +func (t *ErrorCodeMappingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + listDlResultToUaStatusCodeOffset := flatbuffers.UOffsetT(0) + if t.ListDlResultToUaStatusCode != nil { + listDlResultToUaStatusCodeLength := len(t.ListDlResultToUaStatusCode) + listDlResultToUaStatusCodeOffsets := make([]flatbuffers.UOffsetT, listDlResultToUaStatusCodeLength) + for j := 0; j < listDlResultToUaStatusCodeLength; j++ { + listDlResultToUaStatusCodeOffsets[j] = t.ListDlResultToUaStatusCode[j].Pack(builder) + } + ErrorCodeMappingStartListDlResultToUaStatusCodeVector(builder, listDlResultToUaStatusCodeLength) + for j := listDlResultToUaStatusCodeLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(listDlResultToUaStatusCodeOffsets[j]) + } + listDlResultToUaStatusCodeOffset = builder.EndVector(listDlResultToUaStatusCodeLength) + } + ErrorCodeMappingStart(builder) + ErrorCodeMappingAddListDlResultToUaStatusCode(builder, listDlResultToUaStatusCodeOffset) + return ErrorCodeMappingEnd(builder) +} + +func (rcv *ErrorCodeMapping) UnPackTo(t *ErrorCodeMappingT) { + listDlResultToUaStatusCodeLength := rcv.ListDlResultToUaStatusCodeLength() + t.ListDlResultToUaStatusCode = make([]*DlResultToUaStatusCodeT, listDlResultToUaStatusCodeLength) + for j := 0; j < listDlResultToUaStatusCodeLength; j++ { + x := DlResultToUaStatusCode{} + rcv.ListDlResultToUaStatusCode(&x, j) + t.ListDlResultToUaStatusCode[j] = x.UnPack() + } +} + +func (rcv *ErrorCodeMapping) UnPack() *ErrorCodeMappingT { + if rcv == nil { return nil } + t := &ErrorCodeMappingT{} + rcv.UnPackTo(t) + return t +} + type ErrorCodeMapping struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/MessageSecurityMode.go b/pkg/fbs/comm/opcua/client/MessageSecurityMode.go index 52c34b1..ab59ed5 100644 --- a/pkg/fbs/comm/opcua/client/MessageSecurityMode.go +++ b/pkg/fbs/comm/opcua/client/MessageSecurityMode.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MessageSecurityModeT struct { + MessageSecurityMode EnumMessageSecurityMode +} + +func (t *MessageSecurityModeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MessageSecurityModeStart(builder) + MessageSecurityModeAddMessageSecurityMode(builder, t.MessageSecurityMode) + return MessageSecurityModeEnd(builder) +} + +func (rcv *MessageSecurityMode) UnPackTo(t *MessageSecurityModeT) { + t.MessageSecurityMode = rcv.MessageSecurityMode() +} + +func (rcv *MessageSecurityMode) UnPack() *MessageSecurityModeT { + if rcv == nil { return nil } + t := &MessageSecurityModeT{} + rcv.UnPackTo(t) + return t +} + type MessageSecurityMode struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/SecurityPolicy.go b/pkg/fbs/comm/opcua/client/SecurityPolicy.go index 8a5b1f5..fcf062a 100644 --- a/pkg/fbs/comm/opcua/client/SecurityPolicy.go +++ b/pkg/fbs/comm/opcua/client/SecurityPolicy.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SecurityPolicyT struct { + SecurityPolicy EnumSecurityPolicy +} + +func (t *SecurityPolicyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SecurityPolicyStart(builder) + SecurityPolicyAddSecurityPolicy(builder, t.SecurityPolicy) + return SecurityPolicyEnd(builder) +} + +func (rcv *SecurityPolicy) UnPackTo(t *SecurityPolicyT) { + t.SecurityPolicy = rcv.SecurityPolicy() +} + +func (rcv *SecurityPolicy) UnPack() *SecurityPolicyT { + if rcv == nil { return nil } + t := &SecurityPolicyT{} + rcv.UnPackTo(t) + return t +} + type SecurityPolicy struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/SessionConfiguration.go b/pkg/fbs/comm/opcua/client/SessionConfiguration.go index 09f222c..d135c12 100644 --- a/pkg/fbs/comm/opcua/client/SessionConfiguration.go +++ b/pkg/fbs/comm/opcua/client/SessionConfiguration.go @@ -6,6 +6,57 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type SessionConfigurationT struct { + UserToken *UserIdentityTokenT + MessageSecurityMode *MessageSecurityModeT + SecurityPolicy *SecurityPolicyT + LocaleIds []string +} + +func (t *SessionConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + userTokenOffset := t.UserToken.Pack(builder) + messageSecurityModeOffset := t.MessageSecurityMode.Pack(builder) + securityPolicyOffset := t.SecurityPolicy.Pack(builder) + localeIdsOffset := flatbuffers.UOffsetT(0) + if t.LocaleIds != nil { + localeIdsLength := len(t.LocaleIds) + localeIdsOffsets := make([]flatbuffers.UOffsetT, localeIdsLength) + for j := 0; j < localeIdsLength; j++ { + localeIdsOffsets[j] = builder.CreateString(t.LocaleIds[j]) + } + SessionConfigurationStartLocaleIdsVector(builder, localeIdsLength) + for j := localeIdsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(localeIdsOffsets[j]) + } + localeIdsOffset = builder.EndVector(localeIdsLength) + } + SessionConfigurationStart(builder) + SessionConfigurationAddUserToken(builder, userTokenOffset) + SessionConfigurationAddMessageSecurityMode(builder, messageSecurityModeOffset) + SessionConfigurationAddSecurityPolicy(builder, securityPolicyOffset) + SessionConfigurationAddLocaleIds(builder, localeIdsOffset) + return SessionConfigurationEnd(builder) +} + +func (rcv *SessionConfiguration) UnPackTo(t *SessionConfigurationT) { + t.UserToken = rcv.UserToken(nil).UnPack() + t.MessageSecurityMode = rcv.MessageSecurityMode(nil).UnPack() + t.SecurityPolicy = rcv.SecurityPolicy(nil).UnPack() + localeIdsLength := rcv.LocaleIdsLength() + t.LocaleIds = make([]string, localeIdsLength) + for j := 0; j < localeIdsLength; j++ { + t.LocaleIds[j] = string(rcv.LocaleIds(j)) + } +} + +func (rcv *SessionConfiguration) UnPack() *SessionConfigurationT { + if rcv == nil { return nil } + t := &SessionConfigurationT{} + rcv.UnPackTo(t) + return t +} + type SessionConfiguration struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/State.go b/pkg/fbs/comm/opcua/client/State.go index 721c5c2..f53cff2 100644 --- a/pkg/fbs/comm/opcua/client/State.go +++ b/pkg/fbs/comm/opcua/client/State.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type StateT struct { + State ConnectionState +} + +func (t *StateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + StateStart(builder) + StateAddState(builder, t.State) + return StateEnd(builder) +} + +func (rcv *State) UnPackTo(t *StateT) { + t.State = rcv.State() +} + +func (rcv *State) UnPack() *StateT { + if rcv == nil { return nil } + t := &StateT{} + rcv.UnPackTo(t) + return t +} + type State struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/TimeoutConfiguration.go b/pkg/fbs/comm/opcua/client/TimeoutConfiguration.go index 14cf4e5..b1db30e 100644 --- a/pkg/fbs/comm/opcua/client/TimeoutConfiguration.go +++ b/pkg/fbs/comm/opcua/client/TimeoutConfiguration.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TimeoutConfigurationT struct { + BrowseCallTimeout uint32 + DiscoveryTimeout uint32 + PublishTimeout uint32 + ReadCallTimeout uint32 + SessionTimeout float64 + WatchdogTimeout uint32 + WriteCallTimeout uint32 + CallCallTimeout uint32 +} + +func (t *TimeoutConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TimeoutConfigurationStart(builder) + TimeoutConfigurationAddBrowseCallTimeout(builder, t.BrowseCallTimeout) + TimeoutConfigurationAddDiscoveryTimeout(builder, t.DiscoveryTimeout) + TimeoutConfigurationAddPublishTimeout(builder, t.PublishTimeout) + TimeoutConfigurationAddReadCallTimeout(builder, t.ReadCallTimeout) + TimeoutConfigurationAddSessionTimeout(builder, t.SessionTimeout) + TimeoutConfigurationAddWatchdogTimeout(builder, t.WatchdogTimeout) + TimeoutConfigurationAddWriteCallTimeout(builder, t.WriteCallTimeout) + TimeoutConfigurationAddCallCallTimeout(builder, t.CallCallTimeout) + return TimeoutConfigurationEnd(builder) +} + +func (rcv *TimeoutConfiguration) UnPackTo(t *TimeoutConfigurationT) { + t.BrowseCallTimeout = rcv.BrowseCallTimeout() + t.DiscoveryTimeout = rcv.DiscoveryTimeout() + t.PublishTimeout = rcv.PublishTimeout() + t.ReadCallTimeout = rcv.ReadCallTimeout() + t.SessionTimeout = rcv.SessionTimeout() + t.WatchdogTimeout = rcv.WatchdogTimeout() + t.WriteCallTimeout = rcv.WriteCallTimeout() + t.CallCallTimeout = rcv.CallCallTimeout() +} + +func (rcv *TimeoutConfiguration) UnPack() *TimeoutConfigurationT { + if rcv == nil { return nil } + t := &TimeoutConfigurationT{} + rcv.UnPackTo(t) + return t +} + type TimeoutConfiguration struct { _tab flatbuffers.Table } @@ -117,8 +160,20 @@ func (rcv *TimeoutConfiguration) MutateWriteCallTimeout(n uint32) bool { return rcv._tab.MutateUint32Slot(16, n) } +func (rcv *TimeoutConfiguration) CallCallTimeout() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 10000 +} + +func (rcv *TimeoutConfiguration) MutateCallCallTimeout(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + func TimeoutConfigurationStart(builder *flatbuffers.Builder) { - builder.StartObject(7) + builder.StartObject(8) } func TimeoutConfigurationAddBrowseCallTimeout(builder *flatbuffers.Builder, browseCallTimeout uint32) { builder.PrependUint32Slot(0, browseCallTimeout, 10000) @@ -141,6 +196,9 @@ func TimeoutConfigurationAddWatchdogTimeout(builder *flatbuffers.Builder, watchd func TimeoutConfigurationAddWriteCallTimeout(builder *flatbuffers.Builder, writeCallTimeout uint32) { builder.PrependUint32Slot(6, writeCallTimeout, 10000) } +func TimeoutConfigurationAddCallCallTimeout(builder *flatbuffers.Builder, callCallTimeout uint32) { + builder.PrependUint32Slot(7, callCallTimeout, 10000) +} func TimeoutConfigurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/opcua/client/TokenAnonymous.go b/pkg/fbs/comm/opcua/client/TokenAnonymous.go index ee694c9..4c09d3e 100644 --- a/pkg/fbs/comm/opcua/client/TokenAnonymous.go +++ b/pkg/fbs/comm/opcua/client/TokenAnonymous.go @@ -6,6 +6,25 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TokenAnonymousT struct { +} + +func (t *TokenAnonymousT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TokenAnonymousStart(builder) + return TokenAnonymousEnd(builder) +} + +func (rcv *TokenAnonymous) UnPackTo(t *TokenAnonymousT) { +} + +func (rcv *TokenAnonymous) UnPack() *TokenAnonymousT { + if rcv == nil { return nil } + t := &TokenAnonymousT{} + rcv.UnPackTo(t) + return t +} + type TokenAnonymous struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/TokenCert.go b/pkg/fbs/comm/opcua/client/TokenCert.go index 6a71a33..abc7949 100644 --- a/pkg/fbs/comm/opcua/client/TokenCert.go +++ b/pkg/fbs/comm/opcua/client/TokenCert.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TokenCertT struct { + Location string + Name string +} + +func (t *TokenCertT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + locationOffset := builder.CreateString(t.Location) + nameOffset := builder.CreateString(t.Name) + TokenCertStart(builder) + TokenCertAddLocation(builder, locationOffset) + TokenCertAddName(builder, nameOffset) + return TokenCertEnd(builder) +} + +func (rcv *TokenCert) UnPackTo(t *TokenCertT) { + t.Location = string(rcv.Location()) + t.Name = string(rcv.Name()) +} + +func (rcv *TokenCert) UnPack() *TokenCertT { + if rcv == nil { return nil } + t := &TokenCertT{} + rcv.UnPackTo(t) + return t +} + type TokenCert struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/TokenUserPassword.go b/pkg/fbs/comm/opcua/client/TokenUserPassword.go index efcd7a5..759bbcc 100644 --- a/pkg/fbs/comm/opcua/client/TokenUserPassword.go +++ b/pkg/fbs/comm/opcua/client/TokenUserPassword.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TokenUserPasswordT struct { + Username string + Password string +} + +func (t *TokenUserPasswordT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + usernameOffset := builder.CreateString(t.Username) + passwordOffset := builder.CreateString(t.Password) + TokenUserPasswordStart(builder) + TokenUserPasswordAddUsername(builder, usernameOffset) + TokenUserPasswordAddPassword(builder, passwordOffset) + return TokenUserPasswordEnd(builder) +} + +func (rcv *TokenUserPassword) UnPackTo(t *TokenUserPasswordT) { + t.Username = string(rcv.Username()) + t.Password = string(rcv.Password()) +} + +func (rcv *TokenUserPassword) UnPack() *TokenUserPasswordT { + if rcv == nil { return nil } + t := &TokenUserPasswordT{} + rcv.UnPackTo(t) + return t +} + type TokenUserPassword struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/UserIdentityToken.go b/pkg/fbs/comm/opcua/client/UserIdentityToken.go index 1fe69f0..96ee25d 100644 --- a/pkg/fbs/comm/opcua/client/UserIdentityToken.go +++ b/pkg/fbs/comm/opcua/client/UserIdentityToken.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UserIdentityTokenT struct { + UserIdentityToken *UserIdentityTokenUnionT +} + +func (t *UserIdentityTokenT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + userIdentityTokenOffset := t.UserIdentityToken.Pack(builder) + + UserIdentityTokenStart(builder) + if t.UserIdentityToken != nil { + UserIdentityTokenAddUserIdentityTokenType(builder, t.UserIdentityToken.Type) + } + UserIdentityTokenAddUserIdentityToken(builder, userIdentityTokenOffset) + return UserIdentityTokenEnd(builder) +} + +func (rcv *UserIdentityToken) UnPackTo(t *UserIdentityTokenT) { + userIdentityTokenTable := flatbuffers.Table{} + if rcv.UserIdentityToken(&userIdentityTokenTable) { + t.UserIdentityToken = rcv.UserIdentityTokenType().UnPack(userIdentityTokenTable) + } +} + +func (rcv *UserIdentityToken) UnPack() *UserIdentityTokenT { + if rcv == nil { return nil } + t := &UserIdentityTokenT{} + rcv.UnPackTo(t) + return t +} + type UserIdentityToken struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/comm/opcua/client/UserIdentityTokenUnion.go b/pkg/fbs/comm/opcua/client/UserIdentityTokenUnion.go index e954991..79d6668 100644 --- a/pkg/fbs/comm/opcua/client/UserIdentityTokenUnion.go +++ b/pkg/fbs/comm/opcua/client/UserIdentityTokenUnion.go @@ -2,7 +2,11 @@ package client -import "strconv" +import ( + "strconv" + + flatbuffers "github.com/google/flatbuffers/go" +) type UserIdentityTokenUnion byte @@ -33,3 +37,38 @@ func (v UserIdentityTokenUnion) String() string { } return "UserIdentityTokenUnion(" + strconv.FormatInt(int64(v), 10) + ")" } + +type UserIdentityTokenUnionT struct { + Type UserIdentityTokenUnion + Value interface{} +} + +func (t *UserIdentityTokenUnionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case UserIdentityTokenUnionTokenAnonymous: + return t.Value.(*TokenAnonymousT).Pack(builder) + case UserIdentityTokenUnionTokenUserPassword: + return t.Value.(*TokenUserPasswordT).Pack(builder) + case UserIdentityTokenUnionTokenCert: + return t.Value.(*TokenCertT).Pack(builder) + } + return 0 +} + +func (rcv UserIdentityTokenUnion) UnPack(table flatbuffers.Table) *UserIdentityTokenUnionT { + switch rcv { + case UserIdentityTokenUnionTokenAnonymous: + x := TokenAnonymous{_tab: table} + return &UserIdentityTokenUnionT{ Type: UserIdentityTokenUnionTokenAnonymous, Value: x.UnPack() } + case UserIdentityTokenUnionTokenUserPassword: + x := TokenUserPassword{_tab: table} + return &UserIdentityTokenUnionT{ Type: UserIdentityTokenUnionTokenUserPassword, Value: x.UnPack() } + case UserIdentityTokenUnionTokenCert: + x := TokenCert{_tab: table} + return &UserIdentityTokenUnionT{ Type: UserIdentityTokenUnionTokenCert, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/comm/opcua/server/ArrayOfCertificateConfigType.go b/pkg/fbs/comm/opcua/server/ArrayOfCertificateConfigType.go new file mode 100644 index 0000000..787105d --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ArrayOfCertificateConfigType.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfCertificateConfigTypeT struct { + CertificateConfigArray []*CertificateConfigTypeT +} + +func (t *ArrayOfCertificateConfigTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + certificateConfigArrayOffset := flatbuffers.UOffsetT(0) + if t.CertificateConfigArray != nil { + certificateConfigArrayLength := len(t.CertificateConfigArray) + certificateConfigArrayOffsets := make([]flatbuffers.UOffsetT, certificateConfigArrayLength) + for j := 0; j < certificateConfigArrayLength; j++ { + certificateConfigArrayOffsets[j] = t.CertificateConfigArray[j].Pack(builder) + } + ArrayOfCertificateConfigTypeStartCertificateConfigArrayVector(builder, certificateConfigArrayLength) + for j := certificateConfigArrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(certificateConfigArrayOffsets[j]) + } + certificateConfigArrayOffset = builder.EndVector(certificateConfigArrayLength) + } + ArrayOfCertificateConfigTypeStart(builder) + ArrayOfCertificateConfigTypeAddCertificateConfigArray(builder, certificateConfigArrayOffset) + return ArrayOfCertificateConfigTypeEnd(builder) +} + +func (rcv *ArrayOfCertificateConfigType) UnPackTo(t *ArrayOfCertificateConfigTypeT) { + certificateConfigArrayLength := rcv.CertificateConfigArrayLength() + t.CertificateConfigArray = make([]*CertificateConfigTypeT, certificateConfigArrayLength) + for j := 0; j < certificateConfigArrayLength; j++ { + x := CertificateConfigType{} + rcv.CertificateConfigArray(&x, j) + t.CertificateConfigArray[j] = x.UnPack() + } +} + +func (rcv *ArrayOfCertificateConfigType) UnPack() *ArrayOfCertificateConfigTypeT { + if rcv == nil { return nil } + t := &ArrayOfCertificateConfigTypeT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfCertificateConfigType struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfCertificateConfigType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfCertificateConfigType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfCertificateConfigType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfCertificateConfigType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfCertificateConfigType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfCertificateConfigType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfCertificateConfigType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfCertificateConfigType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfCertificateConfigType) CertificateConfigArray(obj *CertificateConfigType, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *ArrayOfCertificateConfigType) CertificateConfigArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfCertificateConfigTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfCertificateConfigTypeAddCertificateConfigArray(builder *flatbuffers.Builder, certificateConfigArray flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(certificateConfigArray), 0) +} +func ArrayOfCertificateConfigTypeStartCertificateConfigArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfCertificateConfigTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ArrayOfObjectPoolDiagType.go b/pkg/fbs/comm/opcua/server/ArrayOfObjectPoolDiagType.go new file mode 100644 index 0000000..b2d32c5 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ArrayOfObjectPoolDiagType.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfObjectPoolDiagTypeT struct { + ObjectPoolDiagArray []*ObjectPoolDiagTypeT +} + +func (t *ArrayOfObjectPoolDiagTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objectPoolDiagArrayOffset := flatbuffers.UOffsetT(0) + if t.ObjectPoolDiagArray != nil { + objectPoolDiagArrayLength := len(t.ObjectPoolDiagArray) + objectPoolDiagArrayOffsets := make([]flatbuffers.UOffsetT, objectPoolDiagArrayLength) + for j := 0; j < objectPoolDiagArrayLength; j++ { + objectPoolDiagArrayOffsets[j] = t.ObjectPoolDiagArray[j].Pack(builder) + } + ArrayOfObjectPoolDiagTypeStartObjectPoolDiagArrayVector(builder, objectPoolDiagArrayLength) + for j := objectPoolDiagArrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(objectPoolDiagArrayOffsets[j]) + } + objectPoolDiagArrayOffset = builder.EndVector(objectPoolDiagArrayLength) + } + ArrayOfObjectPoolDiagTypeStart(builder) + ArrayOfObjectPoolDiagTypeAddObjectPoolDiagArray(builder, objectPoolDiagArrayOffset) + return ArrayOfObjectPoolDiagTypeEnd(builder) +} + +func (rcv *ArrayOfObjectPoolDiagType) UnPackTo(t *ArrayOfObjectPoolDiagTypeT) { + objectPoolDiagArrayLength := rcv.ObjectPoolDiagArrayLength() + t.ObjectPoolDiagArray = make([]*ObjectPoolDiagTypeT, objectPoolDiagArrayLength) + for j := 0; j < objectPoolDiagArrayLength; j++ { + x := ObjectPoolDiagType{} + rcv.ObjectPoolDiagArray(&x, j) + t.ObjectPoolDiagArray[j] = x.UnPack() + } +} + +func (rcv *ArrayOfObjectPoolDiagType) UnPack() *ArrayOfObjectPoolDiagTypeT { + if rcv == nil { return nil } + t := &ArrayOfObjectPoolDiagTypeT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfObjectPoolDiagType struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfObjectPoolDiagType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfObjectPoolDiagType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfObjectPoolDiagType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfObjectPoolDiagType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfObjectPoolDiagType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfObjectPoolDiagType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfObjectPoolDiagType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfObjectPoolDiagType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfObjectPoolDiagType) ObjectPoolDiagArray(obj *ObjectPoolDiagType, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *ArrayOfObjectPoolDiagType) ObjectPoolDiagArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfObjectPoolDiagTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfObjectPoolDiagTypeAddObjectPoolDiagArray(builder *flatbuffers.Builder, objectPoolDiagArray flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objectPoolDiagArray), 0) +} +func ArrayOfObjectPoolDiagTypeStartObjectPoolDiagArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfObjectPoolDiagTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ArrayOfSecConfigType.go b/pkg/fbs/comm/opcua/server/ArrayOfSecConfigType.go new file mode 100644 index 0000000..bfe00ae --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ArrayOfSecConfigType.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfSecConfigTypeT struct { + SecConfigArray []*SecConfigTypeT +} + +func (t *ArrayOfSecConfigTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + secConfigArrayOffset := flatbuffers.UOffsetT(0) + if t.SecConfigArray != nil { + secConfigArrayLength := len(t.SecConfigArray) + secConfigArrayOffsets := make([]flatbuffers.UOffsetT, secConfigArrayLength) + for j := 0; j < secConfigArrayLength; j++ { + secConfigArrayOffsets[j] = t.SecConfigArray[j].Pack(builder) + } + ArrayOfSecConfigTypeStartSecConfigArrayVector(builder, secConfigArrayLength) + for j := secConfigArrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(secConfigArrayOffsets[j]) + } + secConfigArrayOffset = builder.EndVector(secConfigArrayLength) + } + ArrayOfSecConfigTypeStart(builder) + ArrayOfSecConfigTypeAddSecConfigArray(builder, secConfigArrayOffset) + return ArrayOfSecConfigTypeEnd(builder) +} + +func (rcv *ArrayOfSecConfigType) UnPackTo(t *ArrayOfSecConfigTypeT) { + secConfigArrayLength := rcv.SecConfigArrayLength() + t.SecConfigArray = make([]*SecConfigTypeT, secConfigArrayLength) + for j := 0; j < secConfigArrayLength; j++ { + x := SecConfigType{} + rcv.SecConfigArray(&x, j) + t.SecConfigArray[j] = x.UnPack() + } +} + +func (rcv *ArrayOfSecConfigType) UnPack() *ArrayOfSecConfigTypeT { + if rcv == nil { return nil } + t := &ArrayOfSecConfigTypeT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfSecConfigType struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfSecConfigType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfSecConfigType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfSecConfigType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfSecConfigType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfSecConfigType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfSecConfigType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfSecConfigType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfSecConfigType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfSecConfigType) SecConfigArray(obj *SecConfigType, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *ArrayOfSecConfigType) SecConfigArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfSecConfigTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfSecConfigTypeAddSecConfigArray(builder *flatbuffers.Builder, secConfigArray flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(secConfigArray), 0) +} +func ArrayOfSecConfigTypeStartSecConfigArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfSecConfigTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ArrayOfUserTokenType.go b/pkg/fbs/comm/opcua/server/ArrayOfUserTokenType.go new file mode 100644 index 0000000..d30c330 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ArrayOfUserTokenType.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfUserTokenTypeT struct { + UserTokenArray []*UserTokenTypeT +} + +func (t *ArrayOfUserTokenTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + userTokenArrayOffset := flatbuffers.UOffsetT(0) + if t.UserTokenArray != nil { + userTokenArrayLength := len(t.UserTokenArray) + userTokenArrayOffsets := make([]flatbuffers.UOffsetT, userTokenArrayLength) + for j := 0; j < userTokenArrayLength; j++ { + userTokenArrayOffsets[j] = t.UserTokenArray[j].Pack(builder) + } + ArrayOfUserTokenTypeStartUserTokenArrayVector(builder, userTokenArrayLength) + for j := userTokenArrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(userTokenArrayOffsets[j]) + } + userTokenArrayOffset = builder.EndVector(userTokenArrayLength) + } + ArrayOfUserTokenTypeStart(builder) + ArrayOfUserTokenTypeAddUserTokenArray(builder, userTokenArrayOffset) + return ArrayOfUserTokenTypeEnd(builder) +} + +func (rcv *ArrayOfUserTokenType) UnPackTo(t *ArrayOfUserTokenTypeT) { + userTokenArrayLength := rcv.UserTokenArrayLength() + t.UserTokenArray = make([]*UserTokenTypeT, userTokenArrayLength) + for j := 0; j < userTokenArrayLength; j++ { + x := UserTokenType{} + rcv.UserTokenArray(&x, j) + t.UserTokenArray[j] = x.UnPack() + } +} + +func (rcv *ArrayOfUserTokenType) UnPack() *ArrayOfUserTokenTypeT { + if rcv == nil { return nil } + t := &ArrayOfUserTokenTypeT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfUserTokenType struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfUserTokenType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfUserTokenType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfUserTokenType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfUserTokenType(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfUserTokenType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfUserTokenType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfUserTokenType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfUserTokenType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfUserTokenType) UserTokenArray(obj *UserTokenType, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *ArrayOfUserTokenType) UserTokenArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfUserTokenTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfUserTokenTypeAddUserTokenArray(builder *flatbuffers.Builder, userTokenArray flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(userTokenArray), 0) +} +func ArrayOfUserTokenTypeStartUserTokenArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfUserTokenTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/BuildInfoType.go b/pkg/fbs/comm/opcua/server/BuildInfoType.go new file mode 100644 index 0000000..c5cabe4 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/BuildInfoType.go @@ -0,0 +1,153 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BuildInfoTypeT struct { + BuildDate uint64 + BuildNumber string + ManufacturerName string + ProductName string + ProductUri string + SoftwareVersion string +} + +func (t *BuildInfoTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + buildNumberOffset := builder.CreateString(t.BuildNumber) + manufacturerNameOffset := builder.CreateString(t.ManufacturerName) + productNameOffset := builder.CreateString(t.ProductName) + productUriOffset := builder.CreateString(t.ProductUri) + softwareVersionOffset := builder.CreateString(t.SoftwareVersion) + BuildInfoTypeStart(builder) + BuildInfoTypeAddBuildDate(builder, t.BuildDate) + BuildInfoTypeAddBuildNumber(builder, buildNumberOffset) + BuildInfoTypeAddManufacturerName(builder, manufacturerNameOffset) + BuildInfoTypeAddProductName(builder, productNameOffset) + BuildInfoTypeAddProductUri(builder, productUriOffset) + BuildInfoTypeAddSoftwareVersion(builder, softwareVersionOffset) + return BuildInfoTypeEnd(builder) +} + +func (rcv *BuildInfoType) UnPackTo(t *BuildInfoTypeT) { + t.BuildDate = rcv.BuildDate() + t.BuildNumber = string(rcv.BuildNumber()) + t.ManufacturerName = string(rcv.ManufacturerName()) + t.ProductName = string(rcv.ProductName()) + t.ProductUri = string(rcv.ProductUri()) + t.SoftwareVersion = string(rcv.SoftwareVersion()) +} + +func (rcv *BuildInfoType) UnPack() *BuildInfoTypeT { + if rcv == nil { return nil } + t := &BuildInfoTypeT{} + rcv.UnPackTo(t) + return t +} + +type BuildInfoType struct { + _tab flatbuffers.Table +} + +func GetRootAsBuildInfoType(buf []byte, offset flatbuffers.UOffsetT) *BuildInfoType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BuildInfoType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBuildInfoType(buf []byte, offset flatbuffers.UOffsetT) *BuildInfoType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BuildInfoType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *BuildInfoType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BuildInfoType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BuildInfoType) BuildDate() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *BuildInfoType) MutateBuildDate(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func (rcv *BuildInfoType) BuildNumber() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *BuildInfoType) ManufacturerName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *BuildInfoType) ProductName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *BuildInfoType) ProductUri() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *BuildInfoType) SoftwareVersion() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func BuildInfoTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func BuildInfoTypeAddBuildDate(builder *flatbuffers.Builder, buildDate uint64) { + builder.PrependUint64Slot(0, buildDate, 0) +} +func BuildInfoTypeAddBuildNumber(builder *flatbuffers.Builder, buildNumber flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(buildNumber), 0) +} +func BuildInfoTypeAddManufacturerName(builder *flatbuffers.Builder, manufacturerName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(manufacturerName), 0) +} +func BuildInfoTypeAddProductName(builder *flatbuffers.Builder, productName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(productName), 0) +} +func BuildInfoTypeAddProductUri(builder *flatbuffers.Builder, productUri flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(productUri), 0) +} +func BuildInfoTypeAddSoftwareVersion(builder *flatbuffers.Builder, softwareVersion flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(softwareVersion), 0) +} +func BuildInfoTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/CertificateConfigType.go b/pkg/fbs/comm/opcua/server/CertificateConfigType.go new file mode 100644 index 0000000..a5ec031 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/CertificateConfigType.go @@ -0,0 +1,210 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CertificateConfigTypeT struct { + Certificate string + Key string + Store uint32 + DaysValid uint32 + Algorithm string + KeyUsage string + KeyLength uint32 + IssuerIndex uint32 + Create bool +} + +func (t *CertificateConfigTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + certificateOffset := builder.CreateString(t.Certificate) + keyOffset := builder.CreateString(t.Key) + algorithmOffset := builder.CreateString(t.Algorithm) + keyUsageOffset := builder.CreateString(t.KeyUsage) + CertificateConfigTypeStart(builder) + CertificateConfigTypeAddCertificate(builder, certificateOffset) + CertificateConfigTypeAddKey(builder, keyOffset) + CertificateConfigTypeAddStore(builder, t.Store) + CertificateConfigTypeAddDaysValid(builder, t.DaysValid) + CertificateConfigTypeAddAlgorithm(builder, algorithmOffset) + CertificateConfigTypeAddKeyUsage(builder, keyUsageOffset) + CertificateConfigTypeAddKeyLength(builder, t.KeyLength) + CertificateConfigTypeAddIssuerIndex(builder, t.IssuerIndex) + CertificateConfigTypeAddCreate(builder, t.Create) + return CertificateConfigTypeEnd(builder) +} + +func (rcv *CertificateConfigType) UnPackTo(t *CertificateConfigTypeT) { + t.Certificate = string(rcv.Certificate()) + t.Key = string(rcv.Key()) + t.Store = rcv.Store() + t.DaysValid = rcv.DaysValid() + t.Algorithm = string(rcv.Algorithm()) + t.KeyUsage = string(rcv.KeyUsage()) + t.KeyLength = rcv.KeyLength() + t.IssuerIndex = rcv.IssuerIndex() + t.Create = rcv.Create() +} + +func (rcv *CertificateConfigType) UnPack() *CertificateConfigTypeT { + if rcv == nil { return nil } + t := &CertificateConfigTypeT{} + rcv.UnPackTo(t) + return t +} + +type CertificateConfigType struct { + _tab flatbuffers.Table +} + +func GetRootAsCertificateConfigType(buf []byte, offset flatbuffers.UOffsetT) *CertificateConfigType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CertificateConfigType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCertificateConfigType(buf []byte, offset flatbuffers.UOffsetT) *CertificateConfigType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CertificateConfigType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CertificateConfigType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CertificateConfigType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CertificateConfigType) Certificate() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CertificateConfigType) Key() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CertificateConfigType) Store() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CertificateConfigType) MutateStore(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *CertificateConfigType) DaysValid() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CertificateConfigType) MutateDaysValid(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func (rcv *CertificateConfigType) Algorithm() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CertificateConfigType) KeyUsage() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CertificateConfigType) KeyLength() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CertificateConfigType) MutateKeyLength(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +func (rcv *CertificateConfigType) IssuerIndex() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CertificateConfigType) MutateIssuerIndex(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + +func (rcv *CertificateConfigType) Create() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *CertificateConfigType) MutateCreate(n bool) bool { + return rcv._tab.MutateBoolSlot(20, n) +} + +func CertificateConfigTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(9) +} +func CertificateConfigTypeAddCertificate(builder *flatbuffers.Builder, certificate flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(certificate), 0) +} +func CertificateConfigTypeAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(key), 0) +} +func CertificateConfigTypeAddStore(builder *flatbuffers.Builder, store uint32) { + builder.PrependUint32Slot(2, store, 0) +} +func CertificateConfigTypeAddDaysValid(builder *flatbuffers.Builder, daysValid uint32) { + builder.PrependUint32Slot(3, daysValid, 0) +} +func CertificateConfigTypeAddAlgorithm(builder *flatbuffers.Builder, algorithm flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(algorithm), 0) +} +func CertificateConfigTypeAddKeyUsage(builder *flatbuffers.Builder, keyUsage flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(keyUsage), 0) +} +func CertificateConfigTypeAddKeyLength(builder *flatbuffers.Builder, keyLength uint32) { + builder.PrependUint32Slot(6, keyLength, 0) +} +func CertificateConfigTypeAddIssuerIndex(builder *flatbuffers.Builder, issuerIndex uint32) { + builder.PrependUint32Slot(7, issuerIndex, 0) +} +func CertificateConfigTypeAddCreate(builder *flatbuffers.Builder, create bool) { + builder.PrependBoolSlot(8, create, false) +} +func CertificateConfigTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/EnumServerState.go b/pkg/fbs/comm/opcua/server/EnumServerState.go new file mode 100644 index 0000000..67c2259 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/EnumServerState.go @@ -0,0 +1,50 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import "strconv" + +type EnumServerState int32 + +const ( + EnumServerStateRUNNING EnumServerState = 0 + EnumServerStateFAILED EnumServerState = 1 + EnumServerStateNOCONFIGURATION EnumServerState = 2 + EnumServerStateSUSPENDED EnumServerState = 3 + EnumServerStateSHUTDOWN EnumServerState = 4 + EnumServerStateTEST EnumServerState = 5 + EnumServerStateCOMMUNICATIONFAULT EnumServerState = 6 + EnumServerStateUNKNOWN EnumServerState = 7 + EnumServerStateMAX_ENUM_VALUE EnumServerState = 2147483647 +) + +var EnumNamesEnumServerState = map[EnumServerState]string{ + EnumServerStateRUNNING: "RUNNING", + EnumServerStateFAILED: "FAILED", + EnumServerStateNOCONFIGURATION: "NOCONFIGURATION", + EnumServerStateSUSPENDED: "SUSPENDED", + EnumServerStateSHUTDOWN: "SHUTDOWN", + EnumServerStateTEST: "TEST", + EnumServerStateCOMMUNICATIONFAULT: "COMMUNICATIONFAULT", + EnumServerStateUNKNOWN: "UNKNOWN", + EnumServerStateMAX_ENUM_VALUE: "MAX_ENUM_VALUE", +} + +var EnumValuesEnumServerState = map[string]EnumServerState{ + "RUNNING": EnumServerStateRUNNING, + "FAILED": EnumServerStateFAILED, + "NOCONFIGURATION": EnumServerStateNOCONFIGURATION, + "SUSPENDED": EnumServerStateSUSPENDED, + "SHUTDOWN": EnumServerStateSHUTDOWN, + "TEST": EnumServerStateTEST, + "COMMUNICATIONFAULT": EnumServerStateCOMMUNICATIONFAULT, + "UNKNOWN": EnumServerStateUNKNOWN, + "MAX_ENUM_VALUE": EnumServerStateMAX_ENUM_VALUE, +} + +func (v EnumServerState) String() string { + if s, ok := EnumNamesEnumServerState[v]; ok { + return s + } + return "EnumServerState(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/server/HeapDiagType.go b/pkg/fbs/comm/opcua/server/HeapDiagType.go new file mode 100644 index 0000000..3a20087 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/HeapDiagType.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type HeapDiagTypeT struct { + UsedMemory uint32 + MaxUsedMemory uint32 +} + +func (t *HeapDiagTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + HeapDiagTypeStart(builder) + HeapDiagTypeAddUsedMemory(builder, t.UsedMemory) + HeapDiagTypeAddMaxUsedMemory(builder, t.MaxUsedMemory) + return HeapDiagTypeEnd(builder) +} + +func (rcv *HeapDiagType) UnPackTo(t *HeapDiagTypeT) { + t.UsedMemory = rcv.UsedMemory() + t.MaxUsedMemory = rcv.MaxUsedMemory() +} + +func (rcv *HeapDiagType) UnPack() *HeapDiagTypeT { + if rcv == nil { return nil } + t := &HeapDiagTypeT{} + rcv.UnPackTo(t) + return t +} + +type HeapDiagType struct { + _tab flatbuffers.Table +} + +func GetRootAsHeapDiagType(buf []byte, offset flatbuffers.UOffsetT) *HeapDiagType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HeapDiagType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsHeapDiagType(buf []byte, offset flatbuffers.UOffsetT) *HeapDiagType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HeapDiagType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *HeapDiagType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HeapDiagType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *HeapDiagType) UsedMemory() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *HeapDiagType) MutateUsedMemory(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *HeapDiagType) MaxUsedMemory() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *HeapDiagType) MutateMaxUsedMemory(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func HeapDiagTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func HeapDiagTypeAddUsedMemory(builder *flatbuffers.Builder, usedMemory uint32) { + builder.PrependUint32Slot(0, usedMemory, 0) +} +func HeapDiagTypeAddMaxUsedMemory(builder *flatbuffers.Builder, maxUsedMemory uint32) { + builder.PrependUint32Slot(1, maxUsedMemory, 0) +} +func HeapDiagTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ObjectPoolDiagType.go b/pkg/fbs/comm/opcua/server/ObjectPoolDiagType.go new file mode 100644 index 0000000..d8b50af --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ObjectPoolDiagType.go @@ -0,0 +1,129 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ObjectPoolDiagTypeT struct { + Name string + UsedObjects uint32 + MaxUsedObjects uint32 + NumObjects uint32 +} + +func (t *ObjectPoolDiagTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + ObjectPoolDiagTypeStart(builder) + ObjectPoolDiagTypeAddName(builder, nameOffset) + ObjectPoolDiagTypeAddUsedObjects(builder, t.UsedObjects) + ObjectPoolDiagTypeAddMaxUsedObjects(builder, t.MaxUsedObjects) + ObjectPoolDiagTypeAddNumObjects(builder, t.NumObjects) + return ObjectPoolDiagTypeEnd(builder) +} + +func (rcv *ObjectPoolDiagType) UnPackTo(t *ObjectPoolDiagTypeT) { + t.Name = string(rcv.Name()) + t.UsedObjects = rcv.UsedObjects() + t.MaxUsedObjects = rcv.MaxUsedObjects() + t.NumObjects = rcv.NumObjects() +} + +func (rcv *ObjectPoolDiagType) UnPack() *ObjectPoolDiagTypeT { + if rcv == nil { return nil } + t := &ObjectPoolDiagTypeT{} + rcv.UnPackTo(t) + return t +} + +type ObjectPoolDiagType struct { + _tab flatbuffers.Table +} + +func GetRootAsObjectPoolDiagType(buf []byte, offset flatbuffers.UOffsetT) *ObjectPoolDiagType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ObjectPoolDiagType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsObjectPoolDiagType(buf []byte, offset flatbuffers.UOffsetT) *ObjectPoolDiagType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ObjectPoolDiagType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ObjectPoolDiagType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ObjectPoolDiagType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ObjectPoolDiagType) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *ObjectPoolDiagType) UsedObjects() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ObjectPoolDiagType) MutateUsedObjects(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *ObjectPoolDiagType) MaxUsedObjects() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ObjectPoolDiagType) MutateMaxUsedObjects(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *ObjectPoolDiagType) NumObjects() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ObjectPoolDiagType) MutateNumObjects(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func ObjectPoolDiagTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func ObjectPoolDiagTypeAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func ObjectPoolDiagTypeAddUsedObjects(builder *flatbuffers.Builder, usedObjects uint32) { + builder.PrependUint32Slot(1, usedObjects, 0) +} +func ObjectPoolDiagTypeAddMaxUsedObjects(builder *flatbuffers.Builder, maxUsedObjects uint32) { + builder.PrependUint32Slot(2, maxUsedObjects, 0) +} +func ObjectPoolDiagTypeAddNumObjects(builder *flatbuffers.Builder, numObjects uint32) { + builder.PrependUint32Slot(3, numObjects, 0) +} +func ObjectPoolDiagTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/SecConfigType.go b/pkg/fbs/comm/opcua/server/SecConfigType.go new file mode 100644 index 0000000..1aa0605 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/SecConfigType.go @@ -0,0 +1,132 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SecConfigTypeT struct { + PolicyId uint32 + ModeNone bool + ModeSign bool + ModeSignAndEncrypt bool +} + +func (t *SecConfigTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SecConfigTypeStart(builder) + SecConfigTypeAddPolicyId(builder, t.PolicyId) + SecConfigTypeAddModeNone(builder, t.ModeNone) + SecConfigTypeAddModeSign(builder, t.ModeSign) + SecConfigTypeAddModeSignAndEncrypt(builder, t.ModeSignAndEncrypt) + return SecConfigTypeEnd(builder) +} + +func (rcv *SecConfigType) UnPackTo(t *SecConfigTypeT) { + t.PolicyId = rcv.PolicyId() + t.ModeNone = rcv.ModeNone() + t.ModeSign = rcv.ModeSign() + t.ModeSignAndEncrypt = rcv.ModeSignAndEncrypt() +} + +func (rcv *SecConfigType) UnPack() *SecConfigTypeT { + if rcv == nil { return nil } + t := &SecConfigTypeT{} + rcv.UnPackTo(t) + return t +} + +type SecConfigType struct { + _tab flatbuffers.Table +} + +func GetRootAsSecConfigType(buf []byte, offset flatbuffers.UOffsetT) *SecConfigType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SecConfigType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsSecConfigType(buf []byte, offset flatbuffers.UOffsetT) *SecConfigType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SecConfigType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *SecConfigType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SecConfigType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SecConfigType) PolicyId() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SecConfigType) MutatePolicyId(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *SecConfigType) ModeNone() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SecConfigType) MutateModeNone(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *SecConfigType) ModeSign() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SecConfigType) MutateModeSign(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func (rcv *SecConfigType) ModeSignAndEncrypt() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SecConfigType) MutateModeSignAndEncrypt(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func SecConfigTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func SecConfigTypeAddPolicyId(builder *flatbuffers.Builder, policyId uint32) { + builder.PrependUint32Slot(0, policyId, 0) +} +func SecConfigTypeAddModeNone(builder *flatbuffers.Builder, modeNone bool) { + builder.PrependBoolSlot(1, modeNone, false) +} +func SecConfigTypeAddModeSign(builder *flatbuffers.Builder, modeSign bool) { + builder.PrependBoolSlot(2, modeSign, false) +} +func SecConfigTypeAddModeSignAndEncrypt(builder *flatbuffers.Builder, modeSignAndEncrypt bool) { + builder.PrependBoolSlot(3, modeSignAndEncrypt, false) +} +func SecConfigTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ServerDiagnosticsSummaryType.go b/pkg/fbs/comm/opcua/server/ServerDiagnosticsSummaryType.go new file mode 100644 index 0000000..3f1a4cc --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ServerDiagnosticsSummaryType.go @@ -0,0 +1,276 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ServerDiagnosticsSummaryTypeT struct { + CumulatedSessionCount uint32 + CumulatedSubscriptionCount uint32 + CurrentSessonCount uint32 + CurrentSubscriptionCount uint32 + PublishingIntervalCount uint32 + RejectedRequestsCount uint32 + RejectedSessionCount uint32 + SecurityRejectedRequestsCount uint32 + SecurityRejectedSessionCount uint32 + ServerViewCount uint32 + SessionAbortCount uint32 + SessionTimeoutCount uint32 +} + +func (t *ServerDiagnosticsSummaryTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ServerDiagnosticsSummaryTypeStart(builder) + ServerDiagnosticsSummaryTypeAddCumulatedSessionCount(builder, t.CumulatedSessionCount) + ServerDiagnosticsSummaryTypeAddCumulatedSubscriptionCount(builder, t.CumulatedSubscriptionCount) + ServerDiagnosticsSummaryTypeAddCurrentSessonCount(builder, t.CurrentSessonCount) + ServerDiagnosticsSummaryTypeAddCurrentSubscriptionCount(builder, t.CurrentSubscriptionCount) + ServerDiagnosticsSummaryTypeAddPublishingIntervalCount(builder, t.PublishingIntervalCount) + ServerDiagnosticsSummaryTypeAddRejectedRequestsCount(builder, t.RejectedRequestsCount) + ServerDiagnosticsSummaryTypeAddRejectedSessionCount(builder, t.RejectedSessionCount) + ServerDiagnosticsSummaryTypeAddSecurityRejectedRequestsCount(builder, t.SecurityRejectedRequestsCount) + ServerDiagnosticsSummaryTypeAddSecurityRejectedSessionCount(builder, t.SecurityRejectedSessionCount) + ServerDiagnosticsSummaryTypeAddServerViewCount(builder, t.ServerViewCount) + ServerDiagnosticsSummaryTypeAddSessionAbortCount(builder, t.SessionAbortCount) + ServerDiagnosticsSummaryTypeAddSessionTimeoutCount(builder, t.SessionTimeoutCount) + return ServerDiagnosticsSummaryTypeEnd(builder) +} + +func (rcv *ServerDiagnosticsSummaryType) UnPackTo(t *ServerDiagnosticsSummaryTypeT) { + t.CumulatedSessionCount = rcv.CumulatedSessionCount() + t.CumulatedSubscriptionCount = rcv.CumulatedSubscriptionCount() + t.CurrentSessonCount = rcv.CurrentSessonCount() + t.CurrentSubscriptionCount = rcv.CurrentSubscriptionCount() + t.PublishingIntervalCount = rcv.PublishingIntervalCount() + t.RejectedRequestsCount = rcv.RejectedRequestsCount() + t.RejectedSessionCount = rcv.RejectedSessionCount() + t.SecurityRejectedRequestsCount = rcv.SecurityRejectedRequestsCount() + t.SecurityRejectedSessionCount = rcv.SecurityRejectedSessionCount() + t.ServerViewCount = rcv.ServerViewCount() + t.SessionAbortCount = rcv.SessionAbortCount() + t.SessionTimeoutCount = rcv.SessionTimeoutCount() +} + +func (rcv *ServerDiagnosticsSummaryType) UnPack() *ServerDiagnosticsSummaryTypeT { + if rcv == nil { return nil } + t := &ServerDiagnosticsSummaryTypeT{} + rcv.UnPackTo(t) + return t +} + +type ServerDiagnosticsSummaryType struct { + _tab flatbuffers.Table +} + +func GetRootAsServerDiagnosticsSummaryType(buf []byte, offset flatbuffers.UOffsetT) *ServerDiagnosticsSummaryType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ServerDiagnosticsSummaryType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsServerDiagnosticsSummaryType(buf []byte, offset flatbuffers.UOffsetT) *ServerDiagnosticsSummaryType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ServerDiagnosticsSummaryType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ServerDiagnosticsSummaryType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ServerDiagnosticsSummaryType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ServerDiagnosticsSummaryType) CumulatedSessionCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateCumulatedSessionCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *ServerDiagnosticsSummaryType) CumulatedSubscriptionCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateCumulatedSubscriptionCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *ServerDiagnosticsSummaryType) CurrentSessonCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateCurrentSessonCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *ServerDiagnosticsSummaryType) CurrentSubscriptionCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateCurrentSubscriptionCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +func (rcv *ServerDiagnosticsSummaryType) PublishingIntervalCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutatePublishingIntervalCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func (rcv *ServerDiagnosticsSummaryType) RejectedRequestsCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateRejectedRequestsCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(14, n) +} + +func (rcv *ServerDiagnosticsSummaryType) RejectedSessionCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateRejectedSessionCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +func (rcv *ServerDiagnosticsSummaryType) SecurityRejectedRequestsCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateSecurityRejectedRequestsCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + +func (rcv *ServerDiagnosticsSummaryType) SecurityRejectedSessionCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateSecurityRejectedSessionCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(20, n) +} + +func (rcv *ServerDiagnosticsSummaryType) ServerViewCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateServerViewCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(22, n) +} + +func (rcv *ServerDiagnosticsSummaryType) SessionAbortCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateSessionAbortCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(24, n) +} + +func (rcv *ServerDiagnosticsSummaryType) SessionTimeoutCount() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerDiagnosticsSummaryType) MutateSessionTimeoutCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(26, n) +} + +func ServerDiagnosticsSummaryTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(12) +} +func ServerDiagnosticsSummaryTypeAddCumulatedSessionCount(builder *flatbuffers.Builder, cumulatedSessionCount uint32) { + builder.PrependUint32Slot(0, cumulatedSessionCount, 0) +} +func ServerDiagnosticsSummaryTypeAddCumulatedSubscriptionCount(builder *flatbuffers.Builder, cumulatedSubscriptionCount uint32) { + builder.PrependUint32Slot(1, cumulatedSubscriptionCount, 0) +} +func ServerDiagnosticsSummaryTypeAddCurrentSessonCount(builder *flatbuffers.Builder, currentSessonCount uint32) { + builder.PrependUint32Slot(2, currentSessonCount, 0) +} +func ServerDiagnosticsSummaryTypeAddCurrentSubscriptionCount(builder *flatbuffers.Builder, currentSubscriptionCount uint32) { + builder.PrependUint32Slot(3, currentSubscriptionCount, 0) +} +func ServerDiagnosticsSummaryTypeAddPublishingIntervalCount(builder *flatbuffers.Builder, publishingIntervalCount uint32) { + builder.PrependUint32Slot(4, publishingIntervalCount, 0) +} +func ServerDiagnosticsSummaryTypeAddRejectedRequestsCount(builder *flatbuffers.Builder, rejectedRequestsCount uint32) { + builder.PrependUint32Slot(5, rejectedRequestsCount, 0) +} +func ServerDiagnosticsSummaryTypeAddRejectedSessionCount(builder *flatbuffers.Builder, rejectedSessionCount uint32) { + builder.PrependUint32Slot(6, rejectedSessionCount, 0) +} +func ServerDiagnosticsSummaryTypeAddSecurityRejectedRequestsCount(builder *flatbuffers.Builder, securityRejectedRequestsCount uint32) { + builder.PrependUint32Slot(7, securityRejectedRequestsCount, 0) +} +func ServerDiagnosticsSummaryTypeAddSecurityRejectedSessionCount(builder *flatbuffers.Builder, securityRejectedSessionCount uint32) { + builder.PrependUint32Slot(8, securityRejectedSessionCount, 0) +} +func ServerDiagnosticsSummaryTypeAddServerViewCount(builder *flatbuffers.Builder, serverViewCount uint32) { + builder.PrependUint32Slot(9, serverViewCount, 0) +} +func ServerDiagnosticsSummaryTypeAddSessionAbortCount(builder *flatbuffers.Builder, sessionAbortCount uint32) { + builder.PrependUint32Slot(10, sessionAbortCount, 0) +} +func ServerDiagnosticsSummaryTypeAddSessionTimeoutCount(builder *flatbuffers.Builder, sessionTimeoutCount uint32) { + builder.PrependUint32Slot(11, sessionTimeoutCount, 0) +} +func ServerDiagnosticsSummaryTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ServerStateType.go b/pkg/fbs/comm/opcua/server/ServerStateType.go new file mode 100644 index 0000000..9cc56da --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ServerStateType.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ServerStateTypeT struct { + State EnumServerState +} + +func (t *ServerStateTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ServerStateTypeStart(builder) + ServerStateTypeAddState(builder, t.State) + return ServerStateTypeEnd(builder) +} + +func (rcv *ServerStateType) UnPackTo(t *ServerStateTypeT) { + t.State = rcv.State() +} + +func (rcv *ServerStateType) UnPack() *ServerStateTypeT { + if rcv == nil { return nil } + t := &ServerStateTypeT{} + rcv.UnPackTo(t) + return t +} + +type ServerStateType struct { + _tab flatbuffers.Table +} + +func GetRootAsServerStateType(buf []byte, offset flatbuffers.UOffsetT) *ServerStateType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ServerStateType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsServerStateType(buf []byte, offset flatbuffers.UOffsetT) *ServerStateType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ServerStateType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ServerStateType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ServerStateType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ServerStateType) State() EnumServerState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return EnumServerState(rcv._tab.GetInt32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ServerStateType) MutateState(n EnumServerState) bool { + return rcv._tab.MutateInt32Slot(4, int32(n)) +} + +func ServerStateTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ServerStateTypeAddState(builder *flatbuffers.Builder, state EnumServerState) { + builder.PrependInt32Slot(0, int32(state), 0) +} +func ServerStateTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/ServerStatusType.go b/pkg/fbs/comm/opcua/server/ServerStatusType.go new file mode 100644 index 0000000..5c59076 --- /dev/null +++ b/pkg/fbs/comm/opcua/server/ServerStatusType.go @@ -0,0 +1,167 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package server + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ServerStatusTypeT struct { + BuildInfo *BuildInfoTypeT + CurrentTime uint32 + SecondsTillShutdown uint32 + ShutdownReason string + StartTime uint32 + State EnumServerState +} + +func (t *ServerStatusTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + buildInfoOffset := t.BuildInfo.Pack(builder) + shutdownReasonOffset := builder.CreateString(t.ShutdownReason) + ServerStatusTypeStart(builder) + ServerStatusTypeAddBuildInfo(builder, buildInfoOffset) + ServerStatusTypeAddCurrentTime(builder, t.CurrentTime) + ServerStatusTypeAddSecondsTillShutdown(builder, t.SecondsTillShutdown) + ServerStatusTypeAddShutdownReason(builder, shutdownReasonOffset) + ServerStatusTypeAddStartTime(builder, t.StartTime) + ServerStatusTypeAddState(builder, t.State) + return ServerStatusTypeEnd(builder) +} + +func (rcv *ServerStatusType) UnPackTo(t *ServerStatusTypeT) { + t.BuildInfo = rcv.BuildInfo(nil).UnPack() + t.CurrentTime = rcv.CurrentTime() + t.SecondsTillShutdown = rcv.SecondsTillShutdown() + t.ShutdownReason = string(rcv.ShutdownReason()) + t.StartTime = rcv.StartTime() + t.State = rcv.State() +} + +func (rcv *ServerStatusType) UnPack() *ServerStatusTypeT { + if rcv == nil { return nil } + t := &ServerStatusTypeT{} + rcv.UnPackTo(t) + return t +} + +type ServerStatusType struct { + _tab flatbuffers.Table +} + +func GetRootAsServerStatusType(buf []byte, offset flatbuffers.UOffsetT) *ServerStatusType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ServerStatusType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsServerStatusType(buf []byte, offset flatbuffers.UOffsetT) *ServerStatusType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ServerStatusType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ServerStatusType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ServerStatusType) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ServerStatusType) BuildInfo(obj *BuildInfoType) *BuildInfoType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(BuildInfoType) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *ServerStatusType) CurrentTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerStatusType) MutateCurrentTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *ServerStatusType) SecondsTillShutdown() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerStatusType) MutateSecondsTillShutdown(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func (rcv *ServerStatusType) ShutdownReason() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *ServerStatusType) StartTime() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ServerStatusType) MutateStartTime(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +func (rcv *ServerStatusType) State() EnumServerState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return EnumServerState(rcv._tab.GetInt32(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ServerStatusType) MutateState(n EnumServerState) bool { + return rcv._tab.MutateInt32Slot(14, int32(n)) +} + +func ServerStatusTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func ServerStatusTypeAddBuildInfo(builder *flatbuffers.Builder, buildInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(buildInfo), 0) +} +func ServerStatusTypeAddCurrentTime(builder *flatbuffers.Builder, currentTime uint32) { + builder.PrependUint32Slot(1, currentTime, 0) +} +func ServerStatusTypeAddSecondsTillShutdown(builder *flatbuffers.Builder, secondsTillShutdown uint32) { + builder.PrependUint32Slot(2, secondsTillShutdown, 0) +} +func ServerStatusTypeAddShutdownReason(builder *flatbuffers.Builder, shutdownReason flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(shutdownReason), 0) +} +func ServerStatusTypeAddStartTime(builder *flatbuffers.Builder, startTime uint32) { + builder.PrependUint32Slot(4, startTime, 0) +} +func ServerStatusTypeAddState(builder *flatbuffers.Builder, state EnumServerState) { + builder.PrependInt32Slot(5, int32(state), 0) +} +func ServerStatusTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/server/UserTokenType.go b/pkg/fbs/comm/opcua/server/UserTokenType.go index b7da005..f56a8bb 100644 --- a/pkg/fbs/comm/opcua/server/UserTokenType.go +++ b/pkg/fbs/comm/opcua/server/UserTokenType.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type UserTokenTypeT struct { + Type uint32 + PolicyId uint32 +} + +func (t *UserTokenTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UserTokenTypeStart(builder) + UserTokenTypeAddType(builder, t.Type) + UserTokenTypeAddPolicyId(builder, t.PolicyId) + return UserTokenTypeEnd(builder) +} + +func (rcv *UserTokenType) UnPackTo(t *UserTokenTypeT) { + t.Type = rcv.Type() + t.PolicyId = rcv.PolicyId() +} + +func (rcv *UserTokenType) UnPack() *UserTokenTypeT { + if rcv == nil { return nil } + t := &UserTokenTypeT{} + rcv.UnPackTo(t) + return t +} + type UserTokenType struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/ClassConfig.go b/pkg/fbs/common/log/diagnosis/fbs/ClassConfig.go index 4f5f611..27858c3 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/ClassConfig.go +++ b/pkg/fbs/common/log/diagnosis/fbs/ClassConfig.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ClassConfigT struct { + ClassConfig Class +} + +func (t *ClassConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ClassConfigStart(builder) + ClassConfigAddClassConfig(builder, t.ClassConfig) + return ClassConfigEnd(builder) +} + +func (rcv *ClassConfig) UnPackTo(t *ClassConfigT) { + t.ClassConfig = rcv.ClassConfig() +} + +func (rcv *ClassConfig) UnPack() *ClassConfigT { + if rcv == nil { return nil } + t := &ClassConfigT{} + rcv.UnPackTo(t) + return t +} + type ClassConfig struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/DetailedDiagnostic.go b/pkg/fbs/common/log/diagnosis/fbs/DetailedDiagnostic.go index 5170b13..de23f6c 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/DetailedDiagnostic.go +++ b/pkg/fbs/common/log/diagnosis/fbs/DetailedDiagnostic.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DetailedDiagnosticT struct { + Number string + Version uint32 + Text string +} + +func (t *DetailedDiagnosticT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + numberOffset := builder.CreateString(t.Number) + textOffset := builder.CreateString(t.Text) + DetailedDiagnosticStart(builder) + DetailedDiagnosticAddNumber(builder, numberOffset) + DetailedDiagnosticAddVersion(builder, t.Version) + DetailedDiagnosticAddText(builder, textOffset) + return DetailedDiagnosticEnd(builder) +} + +func (rcv *DetailedDiagnostic) UnPackTo(t *DetailedDiagnosticT) { + t.Number = string(rcv.Number()) + t.Version = rcv.Version() + t.Text = string(rcv.Text()) +} + +func (rcv *DetailedDiagnostic) UnPack() *DetailedDiagnosticT { + if rcv == nil { return nil } + t := &DetailedDiagnosticT{} + rcv.UnPackTo(t) + return t +} + type DetailedDiagnostic struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElement.go b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElement.go index ec1ac68..d6ac5f4 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElement.go +++ b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElement.go @@ -6,6 +6,35 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagnosisElementT struct { + DiagnosisNumber uint32 + Version byte + TextEnglish string +} + +func (t *DiagnosisElementT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + textEnglishOffset := builder.CreateString(t.TextEnglish) + DiagnosisElementStart(builder) + DiagnosisElementAddDiagnosisNumber(builder, t.DiagnosisNumber) + DiagnosisElementAddVersion(builder, t.Version) + DiagnosisElementAddTextEnglish(builder, textEnglishOffset) + return DiagnosisElementEnd(builder) +} + +func (rcv *DiagnosisElement) UnPackTo(t *DiagnosisElementT) { + t.DiagnosisNumber = rcv.DiagnosisNumber() + t.Version = rcv.Version() + t.TextEnglish = string(rcv.TextEnglish()) +} + +func (rcv *DiagnosisElement) UnPack() *DiagnosisElementT { + if rcv == nil { return nil } + t := &DiagnosisElementT{} + rcv.UnPackTo(t) + return t +} + type DiagnosisElement struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElements.go b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElements.go index 181a779..740765f 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElements.go +++ b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisElements.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagnosisElementsT struct { + DiagnosisElements []*DiagnosisElementT +} + +func (t *DiagnosisElementsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + diagnosisElementsOffset := flatbuffers.UOffsetT(0) + if t.DiagnosisElements != nil { + diagnosisElementsLength := len(t.DiagnosisElements) + diagnosisElementsOffsets := make([]flatbuffers.UOffsetT, diagnosisElementsLength) + for j := 0; j < diagnosisElementsLength; j++ { + diagnosisElementsOffsets[j] = t.DiagnosisElements[j].Pack(builder) + } + DiagnosisElementsStartDiagnosisElementsVector(builder, diagnosisElementsLength) + for j := diagnosisElementsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(diagnosisElementsOffsets[j]) + } + diagnosisElementsOffset = builder.EndVector(diagnosisElementsLength) + } + DiagnosisElementsStart(builder) + DiagnosisElementsAddDiagnosisElements(builder, diagnosisElementsOffset) + return DiagnosisElementsEnd(builder) +} + +func (rcv *DiagnosisElements) UnPackTo(t *DiagnosisElementsT) { + diagnosisElementsLength := rcv.DiagnosisElementsLength() + t.DiagnosisElements = make([]*DiagnosisElementT, diagnosisElementsLength) + for j := 0; j < diagnosisElementsLength; j++ { + x := DiagnosisElement{} + rcv.DiagnosisElements(&x, j) + t.DiagnosisElements[j] = x.UnPack() + } +} + +func (rcv *DiagnosisElements) UnPack() *DiagnosisElementsT { + if rcv == nil { return nil } + t := &DiagnosisElementsT{} + rcv.UnPackTo(t) + return t +} + type DiagnosisElements struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentification.go b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentification.go index 7a9be72..e621204 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentification.go +++ b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentification.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagnosisIdentificationT struct { + MainDiagnosisNumber string + DetailedDiagnosisNumber string + Entity string +} + +func (t *DiagnosisIdentificationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mainDiagnosisNumberOffset := builder.CreateString(t.MainDiagnosisNumber) + detailedDiagnosisNumberOffset := builder.CreateString(t.DetailedDiagnosisNumber) + entityOffset := builder.CreateString(t.Entity) + DiagnosisIdentificationStart(builder) + DiagnosisIdentificationAddMainDiagnosisNumber(builder, mainDiagnosisNumberOffset) + DiagnosisIdentificationAddDetailedDiagnosisNumber(builder, detailedDiagnosisNumberOffset) + DiagnosisIdentificationAddEntity(builder, entityOffset) + return DiagnosisIdentificationEnd(builder) +} + +func (rcv *DiagnosisIdentification) UnPackTo(t *DiagnosisIdentificationT) { + t.MainDiagnosisNumber = string(rcv.MainDiagnosisNumber()) + t.DetailedDiagnosisNumber = string(rcv.DetailedDiagnosisNumber()) + t.Entity = string(rcv.Entity()) +} + +func (rcv *DiagnosisIdentification) UnPack() *DiagnosisIdentificationT { + if rcv == nil { return nil } + t := &DiagnosisIdentificationT{} + rcv.UnPackTo(t) + return t +} + type DiagnosisIdentification struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentificationWithTimestamp.go b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentificationWithTimestamp.go index d2ec1cb..5aaf12c 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentificationWithTimestamp.go +++ b/pkg/fbs/common/log/diagnosis/fbs/DiagnosisIdentificationWithTimestamp.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagnosisIdentificationWithTimestampT struct { + DiagnosisIdentification *DiagnosisIdentificationT + Timestamp string +} + +func (t *DiagnosisIdentificationWithTimestampT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + diagnosisIdentificationOffset := t.DiagnosisIdentification.Pack(builder) + timestampOffset := builder.CreateString(t.Timestamp) + DiagnosisIdentificationWithTimestampStart(builder) + DiagnosisIdentificationWithTimestampAddDiagnosisIdentification(builder, diagnosisIdentificationOffset) + DiagnosisIdentificationWithTimestampAddTimestamp(builder, timestampOffset) + return DiagnosisIdentificationWithTimestampEnd(builder) +} + +func (rcv *DiagnosisIdentificationWithTimestamp) UnPackTo(t *DiagnosisIdentificationWithTimestampT) { + t.DiagnosisIdentification = rcv.DiagnosisIdentification(nil).UnPack() + t.Timestamp = string(rcv.Timestamp()) +} + +func (rcv *DiagnosisIdentificationWithTimestamp) UnPack() *DiagnosisIdentificationWithTimestampT { + if rcv == nil { return nil } + t := &DiagnosisIdentificationWithTimestampT{} + rcv.UnPackTo(t) + return t +} + type DiagnosisIdentificationWithTimestamp struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/EventType1.go b/pkg/fbs/common/log/diagnosis/fbs/EventType1.go index f853d25..e15f51e 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/EventType1.go +++ b/pkg/fbs/common/log/diagnosis/fbs/EventType1.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EventType1T struct { + EventCounter uint64 +} + +func (t *EventType1T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + EventType1Start(builder) + EventType1AddEventCounter(builder, t.EventCounter) + return EventType1End(builder) +} + +func (rcv *EventType1) UnPackTo(t *EventType1T) { + t.EventCounter = rcv.EventCounter() +} + +func (rcv *EventType1) UnPack() *EventType1T { + if rcv == nil { return nil } + t := &EventType1T{} + rcv.UnPackTo(t) + return t +} + type EventType1 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/EventType2.go b/pkg/fbs/common/log/diagnosis/fbs/EventType2.go index 9377b47..e2928a8 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/EventType2.go +++ b/pkg/fbs/common/log/diagnosis/fbs/EventType2.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EventType2T struct { + EventCounter uint64 +} + +func (t *EventType2T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + EventType2Start(builder) + EventType2AddEventCounter(builder, t.EventCounter) + return EventType2End(builder) +} + +func (rcv *EventType2) UnPackTo(t *EventType2T) { + t.EventCounter = rcv.EventCounter() +} + +func (rcv *EventType2) UnPack() *EventType2T { + if rcv == nil { return nil } + t := &EventType2T{} + rcv.UnPackTo(t) + return t +} + type EventType2 struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/GetDetailedDiagnosisText.go b/pkg/fbs/common/log/diagnosis/fbs/GetDetailedDiagnosisText.go index 37d5628..c200f49 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/GetDetailedDiagnosisText.go +++ b/pkg/fbs/common/log/diagnosis/fbs/GetDetailedDiagnosisText.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type GetDetailedDiagnosisTextT struct { + DetailedDiagnosisNumber string + RelatedMainDiagnosisNumber string +} + +func (t *GetDetailedDiagnosisTextT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + detailedDiagnosisNumberOffset := builder.CreateString(t.DetailedDiagnosisNumber) + relatedMainDiagnosisNumberOffset := builder.CreateString(t.RelatedMainDiagnosisNumber) + GetDetailedDiagnosisTextStart(builder) + GetDetailedDiagnosisTextAddDetailedDiagnosisNumber(builder, detailedDiagnosisNumberOffset) + GetDetailedDiagnosisTextAddRelatedMainDiagnosisNumber(builder, relatedMainDiagnosisNumberOffset) + return GetDetailedDiagnosisTextEnd(builder) +} + +func (rcv *GetDetailedDiagnosisText) UnPackTo(t *GetDetailedDiagnosisTextT) { + t.DetailedDiagnosisNumber = string(rcv.DetailedDiagnosisNumber()) + t.RelatedMainDiagnosisNumber = string(rcv.RelatedMainDiagnosisNumber()) +} + +func (rcv *GetDetailedDiagnosisText) UnPack() *GetDetailedDiagnosisTextT { + if rcv == nil { return nil } + t := &GetDetailedDiagnosisTextT{} + rcv.UnPackTo(t) + return t +} + type GetDetailedDiagnosisText struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/GetMainDiagnosisText.go b/pkg/fbs/common/log/diagnosis/fbs/GetMainDiagnosisText.go index cb7fb0b..b8b148b 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/GetMainDiagnosisText.go +++ b/pkg/fbs/common/log/diagnosis/fbs/GetMainDiagnosisText.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type GetMainDiagnosisTextT struct { + MainDiagnosisNumber string +} + +func (t *GetMainDiagnosisTextT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mainDiagnosisNumberOffset := builder.CreateString(t.MainDiagnosisNumber) + GetMainDiagnosisTextStart(builder) + GetMainDiagnosisTextAddMainDiagnosisNumber(builder, mainDiagnosisNumberOffset) + return GetMainDiagnosisTextEnd(builder) +} + +func (rcv *GetMainDiagnosisText) UnPackTo(t *GetMainDiagnosisTextT) { + t.MainDiagnosisNumber = string(rcv.MainDiagnosisNumber()) +} + +func (rcv *GetMainDiagnosisText) UnPack() *GetMainDiagnosisTextT { + if rcv == nil { return nil } + t := &GetMainDiagnosisTextT{} + rcv.UnPackTo(t) + return t +} + type GetMainDiagnosisText struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/ListDiagnosisIdentificationWithTimestamp.go b/pkg/fbs/common/log/diagnosis/fbs/ListDiagnosisIdentificationWithTimestamp.go index 8c5b874..92cfa2f 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/ListDiagnosisIdentificationWithTimestamp.go +++ b/pkg/fbs/common/log/diagnosis/fbs/ListDiagnosisIdentificationWithTimestamp.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ListDiagnosisIdentificationWithTimestampT struct { + ListDiagnosisIdentificationWithTimestamp []*DiagnosisIdentificationWithTimestampT +} + +func (t *ListDiagnosisIdentificationWithTimestampT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + listDiagnosisIdentificationWithTimestampOffset := flatbuffers.UOffsetT(0) + if t.ListDiagnosisIdentificationWithTimestamp != nil { + listDiagnosisIdentificationWithTimestampLength := len(t.ListDiagnosisIdentificationWithTimestamp) + listDiagnosisIdentificationWithTimestampOffsets := make([]flatbuffers.UOffsetT, listDiagnosisIdentificationWithTimestampLength) + for j := 0; j < listDiagnosisIdentificationWithTimestampLength; j++ { + listDiagnosisIdentificationWithTimestampOffsets[j] = t.ListDiagnosisIdentificationWithTimestamp[j].Pack(builder) + } + ListDiagnosisIdentificationWithTimestampStartListDiagnosisIdentificationWithTimestampVector(builder, listDiagnosisIdentificationWithTimestampLength) + for j := listDiagnosisIdentificationWithTimestampLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(listDiagnosisIdentificationWithTimestampOffsets[j]) + } + listDiagnosisIdentificationWithTimestampOffset = builder.EndVector(listDiagnosisIdentificationWithTimestampLength) + } + ListDiagnosisIdentificationWithTimestampStart(builder) + ListDiagnosisIdentificationWithTimestampAddListDiagnosisIdentificationWithTimestamp(builder, listDiagnosisIdentificationWithTimestampOffset) + return ListDiagnosisIdentificationWithTimestampEnd(builder) +} + +func (rcv *ListDiagnosisIdentificationWithTimestamp) UnPackTo(t *ListDiagnosisIdentificationWithTimestampT) { + listDiagnosisIdentificationWithTimestampLength := rcv.ListDiagnosisIdentificationWithTimestampLength() + t.ListDiagnosisIdentificationWithTimestamp = make([]*DiagnosisIdentificationWithTimestampT, listDiagnosisIdentificationWithTimestampLength) + for j := 0; j < listDiagnosisIdentificationWithTimestampLength; j++ { + x := DiagnosisIdentificationWithTimestamp{} + rcv.ListDiagnosisIdentificationWithTimestamp(&x, j) + t.ListDiagnosisIdentificationWithTimestamp[j] = x.UnPack() + } +} + +func (rcv *ListDiagnosisIdentificationWithTimestamp) UnPack() *ListDiagnosisIdentificationWithTimestampT { + if rcv == nil { return nil } + t := &ListDiagnosisIdentificationWithTimestampT{} + rcv.UnPackTo(t) + return t +} + type ListDiagnosisIdentificationWithTimestamp struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/LogParameters.go b/pkg/fbs/common/log/diagnosis/fbs/LogParameters.go index 2e430d2..decbac0 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/LogParameters.go +++ b/pkg/fbs/common/log/diagnosis/fbs/LogParameters.go @@ -6,6 +6,64 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LogParametersT struct { + MainDiagnosisCode string + DetailedDiagnosisCode string + UserId string + Entity string + Origin string + UnitName string + FileName string + FunctionName string + LineNumber uint32 + DynamicDescription string +} + +func (t *LogParametersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mainDiagnosisCodeOffset := builder.CreateString(t.MainDiagnosisCode) + detailedDiagnosisCodeOffset := builder.CreateString(t.DetailedDiagnosisCode) + userIdOffset := builder.CreateString(t.UserId) + entityOffset := builder.CreateString(t.Entity) + originOffset := builder.CreateString(t.Origin) + unitNameOffset := builder.CreateString(t.UnitName) + fileNameOffset := builder.CreateString(t.FileName) + functionNameOffset := builder.CreateString(t.FunctionName) + dynamicDescriptionOffset := builder.CreateString(t.DynamicDescription) + LogParametersStart(builder) + LogParametersAddMainDiagnosisCode(builder, mainDiagnosisCodeOffset) + LogParametersAddDetailedDiagnosisCode(builder, detailedDiagnosisCodeOffset) + LogParametersAddUserId(builder, userIdOffset) + LogParametersAddEntity(builder, entityOffset) + LogParametersAddOrigin(builder, originOffset) + LogParametersAddUnitName(builder, unitNameOffset) + LogParametersAddFileName(builder, fileNameOffset) + LogParametersAddFunctionName(builder, functionNameOffset) + LogParametersAddLineNumber(builder, t.LineNumber) + LogParametersAddDynamicDescription(builder, dynamicDescriptionOffset) + return LogParametersEnd(builder) +} + +func (rcv *LogParameters) UnPackTo(t *LogParametersT) { + t.MainDiagnosisCode = string(rcv.MainDiagnosisCode()) + t.DetailedDiagnosisCode = string(rcv.DetailedDiagnosisCode()) + t.UserId = string(rcv.UserId()) + t.Entity = string(rcv.Entity()) + t.Origin = string(rcv.Origin()) + t.UnitName = string(rcv.UnitName()) + t.FileName = string(rcv.FileName()) + t.FunctionName = string(rcv.FunctionName()) + t.LineNumber = rcv.LineNumber() + t.DynamicDescription = string(rcv.DynamicDescription()) +} + +func (rcv *LogParameters) UnPack() *LogParametersT { + if rcv == nil { return nil } + t := &LogParametersT{} + rcv.UnPackTo(t) + return t +} + type LogParameters struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/MainDiagnostic.go b/pkg/fbs/common/log/diagnosis/fbs/MainDiagnostic.go index 330b79c..afe69fe 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/MainDiagnostic.go +++ b/pkg/fbs/common/log/diagnosis/fbs/MainDiagnostic.go @@ -6,6 +6,58 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type MainDiagnosticT struct { + Number string + Version uint32 + Text string + DetailedDiagnostics []*DetailedDiagnosticT +} + +func (t *MainDiagnosticT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + numberOffset := builder.CreateString(t.Number) + textOffset := builder.CreateString(t.Text) + detailedDiagnosticsOffset := flatbuffers.UOffsetT(0) + if t.DetailedDiagnostics != nil { + detailedDiagnosticsLength := len(t.DetailedDiagnostics) + detailedDiagnosticsOffsets := make([]flatbuffers.UOffsetT, detailedDiagnosticsLength) + for j := 0; j < detailedDiagnosticsLength; j++ { + detailedDiagnosticsOffsets[j] = t.DetailedDiagnostics[j].Pack(builder) + } + MainDiagnosticStartDetailedDiagnosticsVector(builder, detailedDiagnosticsLength) + for j := detailedDiagnosticsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(detailedDiagnosticsOffsets[j]) + } + detailedDiagnosticsOffset = builder.EndVector(detailedDiagnosticsLength) + } + MainDiagnosticStart(builder) + MainDiagnosticAddNumber(builder, numberOffset) + MainDiagnosticAddVersion(builder, t.Version) + MainDiagnosticAddText(builder, textOffset) + MainDiagnosticAddDetailedDiagnostics(builder, detailedDiagnosticsOffset) + return MainDiagnosticEnd(builder) +} + +func (rcv *MainDiagnostic) UnPackTo(t *MainDiagnosticT) { + t.Number = string(rcv.Number()) + t.Version = rcv.Version() + t.Text = string(rcv.Text()) + detailedDiagnosticsLength := rcv.DetailedDiagnosticsLength() + t.DetailedDiagnostics = make([]*DetailedDiagnosticT, detailedDiagnosticsLength) + for j := 0; j < detailedDiagnosticsLength; j++ { + x := DetailedDiagnostic{} + rcv.DetailedDiagnostics(&x, j) + t.DetailedDiagnostics[j] = x.UnPack() + } +} + +func (rcv *MainDiagnostic) UnPack() *MainDiagnosticT { + if rcv == nil { return nil } + t := &MainDiagnosticT{} + rcv.UnPackTo(t) + return t +} + type MainDiagnostic struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/PendingDiagnosticState.go b/pkg/fbs/common/log/diagnosis/fbs/PendingDiagnosticState.go new file mode 100644 index 0000000..e3dd1e3 --- /dev/null +++ b/pkg/fbs/common/log/diagnosis/fbs/PendingDiagnosticState.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type PendingDiagnosticStateT struct { + PendingDiagnosticState State +} + +func (t *PendingDiagnosticStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + PendingDiagnosticStateStart(builder) + PendingDiagnosticStateAddPendingDiagnosticState(builder, t.PendingDiagnosticState) + return PendingDiagnosticStateEnd(builder) +} + +func (rcv *PendingDiagnosticState) UnPackTo(t *PendingDiagnosticStateT) { + t.PendingDiagnosticState = rcv.PendingDiagnosticState() +} + +func (rcv *PendingDiagnosticState) UnPack() *PendingDiagnosticStateT { + if rcv == nil { return nil } + t := &PendingDiagnosticStateT{} + rcv.UnPackTo(t) + return t +} + +type PendingDiagnosticState struct { + _tab flatbuffers.Table +} + +func GetRootAsPendingDiagnosticState(buf []byte, offset flatbuffers.UOffsetT) *PendingDiagnosticState { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &PendingDiagnosticState{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPendingDiagnosticState(buf []byte, offset flatbuffers.UOffsetT) *PendingDiagnosticState { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &PendingDiagnosticState{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *PendingDiagnosticState) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *PendingDiagnosticState) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *PendingDiagnosticState) PendingDiagnosticState() State { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return State(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *PendingDiagnosticState) MutatePendingDiagnosticState(n State) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func PendingDiagnosticStateStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func PendingDiagnosticStateAddPendingDiagnosticState(builder *flatbuffers.Builder, pendingDiagnosticState State) { + builder.PrependInt8Slot(0, int8(pendingDiagnosticState), 0) +} +func PendingDiagnosticStateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/log/diagnosis/fbs/RegistrationFile.go b/pkg/fbs/common/log/diagnosis/fbs/RegistrationFile.go index 257bcdc..1feccaf 100644 --- a/pkg/fbs/common/log/diagnosis/fbs/RegistrationFile.go +++ b/pkg/fbs/common/log/diagnosis/fbs/RegistrationFile.go @@ -6,6 +6,59 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type RegistrationFileT struct { + Language string + Product string + Component string + MainDiagnostics []*MainDiagnosticT +} + +func (t *RegistrationFileT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + languageOffset := builder.CreateString(t.Language) + productOffset := builder.CreateString(t.Product) + componentOffset := builder.CreateString(t.Component) + mainDiagnosticsOffset := flatbuffers.UOffsetT(0) + if t.MainDiagnostics != nil { + mainDiagnosticsLength := len(t.MainDiagnostics) + mainDiagnosticsOffsets := make([]flatbuffers.UOffsetT, mainDiagnosticsLength) + for j := 0; j < mainDiagnosticsLength; j++ { + mainDiagnosticsOffsets[j] = t.MainDiagnostics[j].Pack(builder) + } + RegistrationFileStartMainDiagnosticsVector(builder, mainDiagnosticsLength) + for j := mainDiagnosticsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(mainDiagnosticsOffsets[j]) + } + mainDiagnosticsOffset = builder.EndVector(mainDiagnosticsLength) + } + RegistrationFileStart(builder) + RegistrationFileAddLanguage(builder, languageOffset) + RegistrationFileAddProduct(builder, productOffset) + RegistrationFileAddComponent(builder, componentOffset) + RegistrationFileAddMainDiagnostics(builder, mainDiagnosticsOffset) + return RegistrationFileEnd(builder) +} + +func (rcv *RegistrationFile) UnPackTo(t *RegistrationFileT) { + t.Language = string(rcv.Language()) + t.Product = string(rcv.Product()) + t.Component = string(rcv.Component()) + mainDiagnosticsLength := rcv.MainDiagnosticsLength() + t.MainDiagnostics = make([]*MainDiagnosticT, mainDiagnosticsLength) + for j := 0; j < mainDiagnosticsLength; j++ { + x := MainDiagnostic{} + rcv.MainDiagnostics(&x, j) + t.MainDiagnostics[j] = x.UnPack() + } +} + +func (rcv *RegistrationFile) UnPack() *RegistrationFileT { + if rcv == nil { return nil } + t := &RegistrationFileT{} + rcv.UnPackTo(t) + return t +} + type RegistrationFile struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/diagnosis/fbs/State.go b/pkg/fbs/common/log/diagnosis/fbs/State.go new file mode 100644 index 0000000..042982b --- /dev/null +++ b/pkg/fbs/common/log/diagnosis/fbs/State.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +type State int8 + +const ( + StateACTIVE State = 0 + StateRESET State = 1 + StateNOT_CONTAINED State = 2 +) + +var EnumNamesState = map[State]string{ + StateACTIVE: "ACTIVE", + StateRESET: "RESET", + StateNOT_CONTAINED: "NOT_CONTAINED", +} + +var EnumValuesState = map[string]State{ + "ACTIVE": StateACTIVE, + "RESET": StateRESET, + "NOT_CONTAINED": StateNOT_CONTAINED, +} + +func (v State) String() string { + if s, ok := EnumNamesState[v]; ok { + return s + } + return "State(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/log/trace/fbs/EnablingState.go b/pkg/fbs/common/log/trace/fbs/EnablingState.go index 34b0a51..4e29154 100644 --- a/pkg/fbs/common/log/trace/fbs/EnablingState.go +++ b/pkg/fbs/common/log/trace/fbs/EnablingState.go @@ -6,6 +6,38 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EnablingStateT struct { + UnitName string + Messages bool + Warnings bool + Errors bool +} + +func (t *EnablingStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + unitNameOffset := builder.CreateString(t.UnitName) + EnablingStateStart(builder) + EnablingStateAddUnitName(builder, unitNameOffset) + EnablingStateAddMessages(builder, t.Messages) + EnablingStateAddWarnings(builder, t.Warnings) + EnablingStateAddErrors(builder, t.Errors) + return EnablingStateEnd(builder) +} + +func (rcv *EnablingState) UnPackTo(t *EnablingStateT) { + t.UnitName = string(rcv.UnitName()) + t.Messages = rcv.Messages() + t.Warnings = rcv.Warnings() + t.Errors = rcv.Errors() +} + +func (rcv *EnablingState) UnPack() *EnablingStateT { + if rcv == nil { return nil } + t := &EnablingStateT{} + rcv.UnPackTo(t) + return t +} + type EnablingState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/log/trace/fbs/EnablingStates.go b/pkg/fbs/common/log/trace/fbs/EnablingStates.go index 96df46a..360d80b 100644 --- a/pkg/fbs/common/log/trace/fbs/EnablingStates.go +++ b/pkg/fbs/common/log/trace/fbs/EnablingStates.go @@ -6,6 +6,51 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type EnablingStatesT struct { + EnablingStates []*EnablingStateT + MachineIdentification string +} + +func (t *EnablingStatesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + enablingStatesOffset := flatbuffers.UOffsetT(0) + if t.EnablingStates != nil { + enablingStatesLength := len(t.EnablingStates) + enablingStatesOffsets := make([]flatbuffers.UOffsetT, enablingStatesLength) + for j := 0; j < enablingStatesLength; j++ { + enablingStatesOffsets[j] = t.EnablingStates[j].Pack(builder) + } + EnablingStatesStartEnablingStatesVector(builder, enablingStatesLength) + for j := enablingStatesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(enablingStatesOffsets[j]) + } + enablingStatesOffset = builder.EndVector(enablingStatesLength) + } + machineIdentificationOffset := builder.CreateString(t.MachineIdentification) + EnablingStatesStart(builder) + EnablingStatesAddEnablingStates(builder, enablingStatesOffset) + EnablingStatesAddMachineIdentification(builder, machineIdentificationOffset) + return EnablingStatesEnd(builder) +} + +func (rcv *EnablingStates) UnPackTo(t *EnablingStatesT) { + enablingStatesLength := rcv.EnablingStatesLength() + t.EnablingStates = make([]*EnablingStateT, enablingStatesLength) + for j := 0; j < enablingStatesLength; j++ { + x := EnablingState{} + rcv.EnablingStates(&x, j) + t.EnablingStates[j] = x.UnPack() + } + t.MachineIdentification = string(rcv.MachineIdentification()) +} + +func (rcv *EnablingStates) UnPack() *EnablingStatesT { + if rcv == nil { return nil } + t := &EnablingStatesT{} + rcv.UnPackTo(t) + return t +} + type EnablingStates struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/controls/fbs/AdminControls.go b/pkg/fbs/common/scheduler/controls/fbs/AdminControls.go index 953898c..b160d19 100644 --- a/pkg/fbs/common/scheduler/controls/fbs/AdminControls.go +++ b/pkg/fbs/common/scheduler/controls/fbs/AdminControls.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type AdminControlsT struct { + Control *ControlsT +} + +func (t *AdminControlsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + controlOffset := t.Control.Pack(builder) + + AdminControlsStart(builder) + if t.Control != nil { + AdminControlsAddControlType(builder, t.Control.Type) + } + AdminControlsAddControl(builder, controlOffset) + return AdminControlsEnd(builder) +} + +func (rcv *AdminControls) UnPackTo(t *AdminControlsT) { + controlTable := flatbuffers.Table{} + if rcv.Control(&controlTable) { + t.Control = rcv.ControlType().UnPack(controlTable) + } +} + +func (rcv *AdminControls) UnPack() *AdminControlsT { + if rcv == nil { return nil } + t := &AdminControlsT{} + rcv.UnPackTo(t) + return t +} + type AdminControls struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/controls/fbs/Controls.go b/pkg/fbs/common/scheduler/controls/fbs/Controls.go index ea2e5af..fd54792 100644 --- a/pkg/fbs/common/scheduler/controls/fbs/Controls.go +++ b/pkg/fbs/common/scheduler/controls/fbs/Controls.go @@ -2,7 +2,11 @@ package fbs -import "strconv" +import ( + "strconv" + + flatbuffers "github.com/google/flatbuffers/go" +) type Controls byte @@ -27,3 +31,28 @@ func (v Controls) String() string { } return "Controls(" + strconv.FormatInt(int64(v), 10) + ")" } + +type ControlsT struct { + Type Controls + Value interface{} +} + +func (t *ControlsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case ControlsDebug: + return t.Value.(*DebugT).Pack(builder) + } + return 0 +} + +func (rcv Controls) UnPack(table flatbuffers.Table) *ControlsT { + switch rcv { + case ControlsDebug: + x := Debug{_tab: table} + return &ControlsT{ Type: ControlsDebug, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/common/scheduler/controls/fbs/Debug.go b/pkg/fbs/common/scheduler/controls/fbs/Debug.go index 20e2337..b90a5a8 100644 --- a/pkg/fbs/common/scheduler/controls/fbs/Debug.go +++ b/pkg/fbs/common/scheduler/controls/fbs/Debug.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DebugT struct { + Machine string +} + +func (t *DebugT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + machineOffset := builder.CreateString(t.Machine) + DebugStart(builder) + DebugAddMachine(builder, machineOffset) + return DebugEnd(builder) +} + +func (rcv *Debug) UnPackTo(t *DebugT) { + t.Machine = string(rcv.Machine()) +} + +func (rcv *Debug) UnPack() *DebugT { + if rcv == nil { return nil } + t := &DebugT{} + rcv.UnPackTo(t) + return t +} + type Debug struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Admin.go b/pkg/fbs/common/scheduler/fbs/Admin.go index 0e8302b..d38abef 100644 --- a/pkg/fbs/common/scheduler/fbs/Admin.go +++ b/pkg/fbs/common/scheduler/fbs/Admin.go @@ -5,9 +5,55 @@ package fbs import ( flatbuffers "github.com/google/flatbuffers/go" - common__scheduler__controls__fbs "common/scheduler/controls/fbs" + common__scheduler__controls__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/controls/fbs" ) +type AdminT struct { + StartupState CurrentState + StartupTimeout uint32 + StartupErrorReaction CurrentErrorReaction + TriggerSource CurrentTrigger + ControlDebug *common__scheduler__controls__fbs.ControlsT + CpuInfo *CpuInfoT +} + +func (t *AdminT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + controlDebugOffset := t.ControlDebug.Pack(builder) + + cpuInfoOffset := t.CpuInfo.Pack(builder) + AdminStart(builder) + AdminAddStartupState(builder, t.StartupState) + AdminAddStartupTimeout(builder, t.StartupTimeout) + AdminAddStartupErrorReaction(builder, t.StartupErrorReaction) + AdminAddTriggerSource(builder, t.TriggerSource) + if t.ControlDebug != nil { + AdminAddControlDebugType(builder, t.ControlDebug.Type) + } + AdminAddControlDebug(builder, controlDebugOffset) + AdminAddCpuInfo(builder, cpuInfoOffset) + return AdminEnd(builder) +} + +func (rcv *Admin) UnPackTo(t *AdminT) { + t.StartupState = rcv.StartupState() + t.StartupTimeout = rcv.StartupTimeout() + t.StartupErrorReaction = rcv.StartupErrorReaction() + t.TriggerSource = rcv.TriggerSource() + controlDebugTable := flatbuffers.Table{} + if rcv.ControlDebug(&controlDebugTable) { + t.ControlDebug = rcv.ControlDebugType().UnPack(controlDebugTable) + } + t.CpuInfo = rcv.CpuInfo(nil).UnPack() +} + +func (rcv *Admin) UnPack() *AdminT { + if rcv == nil { return nil } + t := &AdminT{} + rcv.UnPackTo(t) + return t +} + type Admin struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Callable.go b/pkg/fbs/common/scheduler/fbs/Callable.go index 16ae28a..a7fb1c8 100644 --- a/pkg/fbs/common/scheduler/fbs/Callable.go +++ b/pkg/fbs/common/scheduler/fbs/Callable.go @@ -6,6 +6,67 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CallableT struct { + Name string + Index uint32 + Arguments []string + Id string + Alias string + Sync *SyncPointsT + Watchdog CallableWdgConfig +} + +func (t *CallableT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + argumentsOffset := flatbuffers.UOffsetT(0) + if t.Arguments != nil { + argumentsLength := len(t.Arguments) + argumentsOffsets := make([]flatbuffers.UOffsetT, argumentsLength) + for j := 0; j < argumentsLength; j++ { + argumentsOffsets[j] = builder.CreateString(t.Arguments[j]) + } + CallableStartArgumentsVector(builder, argumentsLength) + for j := argumentsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(argumentsOffsets[j]) + } + argumentsOffset = builder.EndVector(argumentsLength) + } + idOffset := builder.CreateString(t.Id) + aliasOffset := builder.CreateString(t.Alias) + syncOffset := t.Sync.Pack(builder) + CallableStart(builder) + CallableAddName(builder, nameOffset) + CallableAddIndex(builder, t.Index) + CallableAddArguments(builder, argumentsOffset) + CallableAddId(builder, idOffset) + CallableAddAlias(builder, aliasOffset) + CallableAddSync(builder, syncOffset) + CallableAddWatchdog(builder, t.Watchdog) + return CallableEnd(builder) +} + +func (rcv *Callable) UnPackTo(t *CallableT) { + t.Name = string(rcv.Name()) + t.Index = rcv.Index() + argumentsLength := rcv.ArgumentsLength() + t.Arguments = make([]string, argumentsLength) + for j := 0; j < argumentsLength; j++ { + t.Arguments[j] = string(rcv.Arguments(j)) + } + t.Id = string(rcv.Id()) + t.Alias = string(rcv.Alias()) + t.Sync = rcv.Sync(nil).UnPack() + t.Watchdog = rcv.Watchdog() +} + +func (rcv *Callable) UnPack() *CallableT { + if rcv == nil { return nil } + t := &CallableT{} + rcv.UnPackTo(t) + return t +} + type Callable struct { _tab flatbuffers.Table } @@ -33,6 +94,7 @@ func (rcv *Callable) Table() flatbuffers.Table { return rcv._tab } +/// singleton (callable factory name) func (rcv *Callable) Name() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -41,6 +103,8 @@ func (rcv *Callable) Name() []byte { return nil } +/// singleton (callable factory name) +/// call index 1 (highest) to maximum type range (default: 0 = lowest) func (rcv *Callable) Index() uint32 { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { @@ -49,10 +113,12 @@ func (rcv *Callable) Index() uint32 { return 0 } +/// call index 1 (highest) to maximum type range (default: 0 = lowest) func (rcv *Callable) MutateIndex(n uint32) bool { return rcv._tab.MutateUint32Slot(6, n) } +/// values to initialize the callable func (rcv *Callable) Arguments(j int) []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { @@ -70,6 +136,8 @@ func (rcv *Callable) ArgumentsLength() int { return 0 } +/// values to initialize the callable +/// desired callable ID (digits only, if unused - recommented - ID will set by system) func (rcv *Callable) Id() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { @@ -78,8 +146,48 @@ func (rcv *Callable) Id() []byte { return nil } +/// desired callable ID (digits only, if unused - recommented - ID will set by system) +/// alias, human readable callable ID +func (rcv *Callable) Alias() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// alias, human readable callable ID +/// sync points to get callables in order +func (rcv *Callable) Sync(obj *SyncPoints) *SyncPoints { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(SyncPoints) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// sync points to get callables in order +/// influence task and hardware watchdog handling +func (rcv *Callable) Watchdog() CallableWdgConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return CallableWdgConfig(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 3 +} + +/// influence task and hardware watchdog handling +func (rcv *Callable) MutateWatchdog(n CallableWdgConfig) bool { + return rcv._tab.MutateInt8Slot(16, int8(n)) +} + func CallableStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(7) } func CallableAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) @@ -96,6 +204,15 @@ func CallableStartArgumentsVector(builder *flatbuffers.Builder, numElems int) fl func CallableAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(id), 0) } +func CallableAddAlias(builder *flatbuffers.Builder, alias flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(alias), 0) +} +func CallableAddSync(builder *flatbuffers.Builder, sync flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(sync), 0) +} +func CallableAddWatchdog(builder *flatbuffers.Builder, watchdog CallableWdgConfig) { + builder.PrependInt8Slot(6, int8(watchdog), 3) +} func CallableEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/common/scheduler/fbs/CallableConfiguration.go b/pkg/fbs/common/scheduler/fbs/CallableConfiguration.go new file mode 100644 index 0000000..00dde46 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/CallableConfiguration.go @@ -0,0 +1,186 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CallableConfigurationT struct { + Alias string + Sync *SyncPointsT + Arguments []string + Watchdog CallableWdgConfig + Task *TaskSpecsT +} + +func (t *CallableConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + aliasOffset := builder.CreateString(t.Alias) + syncOffset := t.Sync.Pack(builder) + argumentsOffset := flatbuffers.UOffsetT(0) + if t.Arguments != nil { + argumentsLength := len(t.Arguments) + argumentsOffsets := make([]flatbuffers.UOffsetT, argumentsLength) + for j := 0; j < argumentsLength; j++ { + argumentsOffsets[j] = builder.CreateString(t.Arguments[j]) + } + CallableConfigurationStartArgumentsVector(builder, argumentsLength) + for j := argumentsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(argumentsOffsets[j]) + } + argumentsOffset = builder.EndVector(argumentsLength) + } + taskOffset := t.Task.Pack(builder) + CallableConfigurationStart(builder) + CallableConfigurationAddAlias(builder, aliasOffset) + CallableConfigurationAddSync(builder, syncOffset) + CallableConfigurationAddArguments(builder, argumentsOffset) + CallableConfigurationAddWatchdog(builder, t.Watchdog) + CallableConfigurationAddTask(builder, taskOffset) + return CallableConfigurationEnd(builder) +} + +func (rcv *CallableConfiguration) UnPackTo(t *CallableConfigurationT) { + t.Alias = string(rcv.Alias()) + t.Sync = rcv.Sync(nil).UnPack() + argumentsLength := rcv.ArgumentsLength() + t.Arguments = make([]string, argumentsLength) + for j := 0; j < argumentsLength; j++ { + t.Arguments[j] = string(rcv.Arguments(j)) + } + t.Watchdog = rcv.Watchdog() + t.Task = rcv.Task(nil).UnPack() +} + +func (rcv *CallableConfiguration) UnPack() *CallableConfigurationT { + if rcv == nil { return nil } + t := &CallableConfigurationT{} + rcv.UnPackTo(t) + return t +} + +type CallableConfiguration struct { + _tab flatbuffers.Table +} + +func GetRootAsCallableConfiguration(buf []byte, offset flatbuffers.UOffsetT) *CallableConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CallableConfiguration{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCallableConfiguration(buf []byte, offset flatbuffers.UOffsetT) *CallableConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CallableConfiguration{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CallableConfiguration) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CallableConfiguration) Table() flatbuffers.Table { + return rcv._tab +} + +/// user defined name of callable to label it human readable, must be unique for these factory +func (rcv *CallableConfiguration) Alias() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// user defined name of callable to label it human readable, must be unique for these factory +/// sync points to get callables in order +func (rcv *CallableConfiguration) Sync(obj *SyncPoints) *SyncPoints { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(SyncPoints) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// sync points to get callables in order +/// values to initialize the callable +func (rcv *CallableConfiguration) Arguments(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *CallableConfiguration) ArgumentsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// values to initialize the callable +/// influence task and hardware watchdog handling +func (rcv *CallableConfiguration) Watchdog() CallableWdgConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return CallableWdgConfig(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 3 +} + +/// influence task and hardware watchdog handling +func (rcv *CallableConfiguration) MutateWatchdog(n CallableWdgConfig) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + +/// task specifications to defined callable environment, used as defaults +func (rcv *CallableConfiguration) Task(obj *TaskSpecs) *TaskSpecs { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskSpecs) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// task specifications to defined callable environment, used as defaults +func CallableConfigurationStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func CallableConfigurationAddAlias(builder *flatbuffers.Builder, alias flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(alias), 0) +} +func CallableConfigurationAddSync(builder *flatbuffers.Builder, sync flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(sync), 0) +} +func CallableConfigurationAddArguments(builder *flatbuffers.Builder, arguments flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(arguments), 0) +} +func CallableConfigurationStartArgumentsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CallableConfigurationAddWatchdog(builder *flatbuffers.Builder, watchdog CallableWdgConfig) { + builder.PrependInt8Slot(3, int8(watchdog), 3) +} +func CallableConfigurationAddTask(builder *flatbuffers.Builder, task flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(task), 0) +} +func CallableConfigurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs/CallableConfigurations.go b/pkg/fbs/common/scheduler/fbs/CallableConfigurations.go new file mode 100644 index 0000000..bea72f1 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/CallableConfigurations.go @@ -0,0 +1,110 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CallableConfigurationsT struct { + Configurations []*CallableConfigurationT +} + +func (t *CallableConfigurationsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + configurationsOffset := flatbuffers.UOffsetT(0) + if t.Configurations != nil { + configurationsLength := len(t.Configurations) + configurationsOffsets := make([]flatbuffers.UOffsetT, configurationsLength) + for j := 0; j < configurationsLength; j++ { + configurationsOffsets[j] = t.Configurations[j].Pack(builder) + } + CallableConfigurationsStartConfigurationsVector(builder, configurationsLength) + for j := configurationsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(configurationsOffsets[j]) + } + configurationsOffset = builder.EndVector(configurationsLength) + } + CallableConfigurationsStart(builder) + CallableConfigurationsAddConfigurations(builder, configurationsOffset) + return CallableConfigurationsEnd(builder) +} + +func (rcv *CallableConfigurations) UnPackTo(t *CallableConfigurationsT) { + configurationsLength := rcv.ConfigurationsLength() + t.Configurations = make([]*CallableConfigurationT, configurationsLength) + for j := 0; j < configurationsLength; j++ { + x := CallableConfiguration{} + rcv.Configurations(&x, j) + t.Configurations[j] = x.UnPack() + } +} + +func (rcv *CallableConfigurations) UnPack() *CallableConfigurationsT { + if rcv == nil { return nil } + t := &CallableConfigurationsT{} + rcv.UnPackTo(t) + return t +} + +type CallableConfigurations struct { + _tab flatbuffers.Table +} + +func GetRootAsCallableConfigurations(buf []byte, offset flatbuffers.UOffsetT) *CallableConfigurations { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CallableConfigurations{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCallableConfigurations(buf []byte, offset flatbuffers.UOffsetT) *CallableConfigurations { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CallableConfigurations{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CallableConfigurations) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CallableConfigurations) Table() flatbuffers.Table { + return rcv._tab +} + +/// callable configurations of a factory +func (rcv *CallableConfigurations) Configurations(obj *CallableConfiguration, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *CallableConfigurations) ConfigurationsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// callable configurations of a factory +func CallableConfigurationsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func CallableConfigurationsAddConfigurations(builder *flatbuffers.Builder, configurations flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(configurations), 0) +} +func CallableConfigurationsStartConfigurationsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CallableConfigurationsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs/CallableWdgConfig.go b/pkg/fbs/common/scheduler/fbs/CallableWdgConfig.go new file mode 100644 index 0000000..fb36a16 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/CallableWdgConfig.go @@ -0,0 +1,39 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import "strconv" + +/// WDG_HW_TASK = task and hardware watchdog activated (default) +/// WDG_HW = hardware watchdog acivated; don't care about task watchdog +/// WDG_NONE = neither task or hardware watchdog is needed +/// WDG_DEFAULT = don't care about neither task or hardware watchdog, use of default value +type CallableWdgConfig int8 + +const ( + CallableWdgConfigWDG_HW_TASK CallableWdgConfig = 0 + CallableWdgConfigWDG_HW CallableWdgConfig = 1 + CallableWdgConfigWDG_NONE CallableWdgConfig = 2 + CallableWdgConfigWDG_DEFAULT CallableWdgConfig = 3 +) + +var EnumNamesCallableWdgConfig = map[CallableWdgConfig]string{ + CallableWdgConfigWDG_HW_TASK: "WDG_HW_TASK", + CallableWdgConfigWDG_HW: "WDG_HW", + CallableWdgConfigWDG_NONE: "WDG_NONE", + CallableWdgConfigWDG_DEFAULT: "WDG_DEFAULT", +} + +var EnumValuesCallableWdgConfig = map[string]CallableWdgConfig{ + "WDG_HW_TASK": CallableWdgConfigWDG_HW_TASK, + "WDG_HW": CallableWdgConfigWDG_HW, + "WDG_NONE": CallableWdgConfigWDG_NONE, + "WDG_DEFAULT": CallableWdgConfigWDG_DEFAULT, +} + +func (v CallableWdgConfig) String() string { + if s, ok := EnumNamesCallableWdgConfig[v]; ok { + return s + } + return "CallableWdgConfig(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/scheduler/fbs/CpuInfo.go b/pkg/fbs/common/scheduler/fbs/CpuInfo.go index 879a203..90500b0 100644 --- a/pkg/fbs/common/scheduler/fbs/CpuInfo.go +++ b/pkg/fbs/common/scheduler/fbs/CpuInfo.go @@ -6,6 +6,123 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CpuInfoT struct { + CpuCoresTotal []uint32 + CpuCoresActive []uint32 + CpuCoresRealtime []uint32 + CpuCoresNonRealtime []uint32 + CpuCoreRealtimeMax int32 + CpuCoreRealtimeMin int32 + CpuCoreRealtimeDefault int32 + CpuCoreNonRealtimeMax int32 + CpuCoreNonRealtimeMin int32 + CpuCoreNonRealtimeDefault int32 + VariationId string + CpuCoreHwWdg uint32 + CpuCorePtpTimer uint32 + CpuCoreScheduler uint32 + CpuCoreAutomation uint32 +} + +func (t *CpuInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cpuCoresTotalOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresTotal != nil { + cpuCoresTotalLength := len(t.CpuCoresTotal) + CpuInfoStartCpuCoresTotalVector(builder, cpuCoresTotalLength) + for j := cpuCoresTotalLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresTotal[j]) + } + cpuCoresTotalOffset = builder.EndVector(cpuCoresTotalLength) + } + cpuCoresActiveOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresActive != nil { + cpuCoresActiveLength := len(t.CpuCoresActive) + CpuInfoStartCpuCoresActiveVector(builder, cpuCoresActiveLength) + for j := cpuCoresActiveLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresActive[j]) + } + cpuCoresActiveOffset = builder.EndVector(cpuCoresActiveLength) + } + cpuCoresRealtimeOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresRealtime != nil { + cpuCoresRealtimeLength := len(t.CpuCoresRealtime) + CpuInfoStartCpuCoresRealtimeVector(builder, cpuCoresRealtimeLength) + for j := cpuCoresRealtimeLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresRealtime[j]) + } + cpuCoresRealtimeOffset = builder.EndVector(cpuCoresRealtimeLength) + } + cpuCoresNonRealtimeOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresNonRealtime != nil { + cpuCoresNonRealtimeLength := len(t.CpuCoresNonRealtime) + CpuInfoStartCpuCoresNonRealtimeVector(builder, cpuCoresNonRealtimeLength) + for j := cpuCoresNonRealtimeLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresNonRealtime[j]) + } + cpuCoresNonRealtimeOffset = builder.EndVector(cpuCoresNonRealtimeLength) + } + variationIdOffset := builder.CreateString(t.VariationId) + CpuInfoStart(builder) + CpuInfoAddCpuCoresTotal(builder, cpuCoresTotalOffset) + CpuInfoAddCpuCoresActive(builder, cpuCoresActiveOffset) + CpuInfoAddCpuCoresRealtime(builder, cpuCoresRealtimeOffset) + CpuInfoAddCpuCoresNonRealtime(builder, cpuCoresNonRealtimeOffset) + CpuInfoAddCpuCoreRealtimeMax(builder, t.CpuCoreRealtimeMax) + CpuInfoAddCpuCoreRealtimeMin(builder, t.CpuCoreRealtimeMin) + CpuInfoAddCpuCoreRealtimeDefault(builder, t.CpuCoreRealtimeDefault) + CpuInfoAddCpuCoreNonRealtimeMax(builder, t.CpuCoreNonRealtimeMax) + CpuInfoAddCpuCoreNonRealtimeMin(builder, t.CpuCoreNonRealtimeMin) + CpuInfoAddCpuCoreNonRealtimeDefault(builder, t.CpuCoreNonRealtimeDefault) + CpuInfoAddVariationId(builder, variationIdOffset) + CpuInfoAddCpuCoreHwWdg(builder, t.CpuCoreHwWdg) + CpuInfoAddCpuCorePtpTimer(builder, t.CpuCorePtpTimer) + CpuInfoAddCpuCoreScheduler(builder, t.CpuCoreScheduler) + CpuInfoAddCpuCoreAutomation(builder, t.CpuCoreAutomation) + return CpuInfoEnd(builder) +} + +func (rcv *CpuInfo) UnPackTo(t *CpuInfoT) { + cpuCoresTotalLength := rcv.CpuCoresTotalLength() + t.CpuCoresTotal = make([]uint32, cpuCoresTotalLength) + for j := 0; j < cpuCoresTotalLength; j++ { + t.CpuCoresTotal[j] = rcv.CpuCoresTotal(j) + } + cpuCoresActiveLength := rcv.CpuCoresActiveLength() + t.CpuCoresActive = make([]uint32, cpuCoresActiveLength) + for j := 0; j < cpuCoresActiveLength; j++ { + t.CpuCoresActive[j] = rcv.CpuCoresActive(j) + } + cpuCoresRealtimeLength := rcv.CpuCoresRealtimeLength() + t.CpuCoresRealtime = make([]uint32, cpuCoresRealtimeLength) + for j := 0; j < cpuCoresRealtimeLength; j++ { + t.CpuCoresRealtime[j] = rcv.CpuCoresRealtime(j) + } + cpuCoresNonRealtimeLength := rcv.CpuCoresNonRealtimeLength() + t.CpuCoresNonRealtime = make([]uint32, cpuCoresNonRealtimeLength) + for j := 0; j < cpuCoresNonRealtimeLength; j++ { + t.CpuCoresNonRealtime[j] = rcv.CpuCoresNonRealtime(j) + } + t.CpuCoreRealtimeMax = rcv.CpuCoreRealtimeMax() + t.CpuCoreRealtimeMin = rcv.CpuCoreRealtimeMin() + t.CpuCoreRealtimeDefault = rcv.CpuCoreRealtimeDefault() + t.CpuCoreNonRealtimeMax = rcv.CpuCoreNonRealtimeMax() + t.CpuCoreNonRealtimeMin = rcv.CpuCoreNonRealtimeMin() + t.CpuCoreNonRealtimeDefault = rcv.CpuCoreNonRealtimeDefault() + t.VariationId = string(rcv.VariationId()) + t.CpuCoreHwWdg = rcv.CpuCoreHwWdg() + t.CpuCorePtpTimer = rcv.CpuCorePtpTimer() + t.CpuCoreScheduler = rcv.CpuCoreScheduler() + t.CpuCoreAutomation = rcv.CpuCoreAutomation() +} + +func (rcv *CpuInfo) UnPack() *CpuInfoT { + if rcv == nil { return nil } + t := &CpuInfoT{} + rcv.UnPackTo(t) + return t +} + type CpuInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/DataRt.go b/pkg/fbs/common/scheduler/fbs/DataRt.go index fd0cd80..bdcd95c 100644 --- a/pkg/fbs/common/scheduler/fbs/DataRt.go +++ b/pkg/fbs/common/scheduler/fbs/DataRt.go @@ -6,6 +6,31 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DataRtT struct { + StartTime uint64 + Counter uint64 +} + +func (t *DataRtT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DataRtStart(builder) + DataRtAddStartTime(builder, t.StartTime) + DataRtAddCounter(builder, t.Counter) + return DataRtEnd(builder) +} + +func (rcv *DataRt) UnPackTo(t *DataRtT) { + t.StartTime = rcv.StartTime() + t.Counter = rcv.Counter() +} + +func (rcv *DataRt) UnPack() *DataRtT { + if rcv == nil { return nil } + t := &DataRtT{} + rcv.UnPackTo(t) + return t +} + type DataRt struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Duration.go b/pkg/fbs/common/scheduler/fbs/Duration.go index d8b32ee..0fee711 100644 --- a/pkg/fbs/common/scheduler/fbs/Duration.go +++ b/pkg/fbs/common/scheduler/fbs/Duration.go @@ -6,6 +6,37 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DurationT struct { + Minimum uint64 + Maximum uint64 + Average uint64 + Active bool +} + +func (t *DurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DurationStart(builder) + DurationAddMinimum(builder, t.Minimum) + DurationAddMaximum(builder, t.Maximum) + DurationAddAverage(builder, t.Average) + DurationAddActive(builder, t.Active) + return DurationEnd(builder) +} + +func (rcv *Duration) UnPackTo(t *DurationT) { + t.Minimum = rcv.Minimum() + t.Maximum = rcv.Maximum() + t.Average = rcv.Average() + t.Active = rcv.Active() +} + +func (rcv *Duration) UnPack() *DurationT { + if rcv == nil { return nil } + t := &DurationT{} + rcv.UnPackTo(t) + return t +} + type Duration struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/DurationRt.go b/pkg/fbs/common/scheduler/fbs/DurationRt.go index fae3891..4551ec9 100644 --- a/pkg/fbs/common/scheduler/fbs/DurationRt.go +++ b/pkg/fbs/common/scheduler/fbs/DurationRt.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DurationRtT struct { + Total uint64 + Task uint64 + Other uint64 + Equidistance uint64 + Deviation uint64 + Counter uint64 + Samplerate uint64 + Remaining uint64 +} + +func (t *DurationRtT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DurationRtStart(builder) + DurationRtAddTotal(builder, t.Total) + DurationRtAddTask(builder, t.Task) + DurationRtAddOther(builder, t.Other) + DurationRtAddEquidistance(builder, t.Equidistance) + DurationRtAddDeviation(builder, t.Deviation) + DurationRtAddCounter(builder, t.Counter) + DurationRtAddSamplerate(builder, t.Samplerate) + DurationRtAddRemaining(builder, t.Remaining) + return DurationRtEnd(builder) +} + +func (rcv *DurationRt) UnPackTo(t *DurationRtT) { + t.Total = rcv.Total() + t.Task = rcv.Task() + t.Other = rcv.Other() + t.Equidistance = rcv.Equidistance() + t.Deviation = rcv.Deviation() + t.Counter = rcv.Counter() + t.Samplerate = rcv.Samplerate() + t.Remaining = rcv.Remaining() +} + +func (rcv *DurationRt) UnPack() *DurationRtT { + if rcv == nil { return nil } + t := &DurationRtT{} + rcv.UnPackTo(t) + return t +} + type DurationRt struct { _tab flatbuffers.Table } @@ -117,8 +160,20 @@ func (rcv *DurationRt) MutateSamplerate(n uint64) bool { return rcv._tab.MutateUint64Slot(16, n) } +func (rcv *DurationRt) Remaining() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DurationRt) MutateRemaining(n uint64) bool { + return rcv._tab.MutateUint64Slot(18, n) +} + func DurationRtStart(builder *flatbuffers.Builder) { - builder.StartObject(7) + builder.StartObject(8) } func DurationRtAddTotal(builder *flatbuffers.Builder, total uint64) { builder.PrependUint64Slot(0, total, 0) @@ -141,6 +196,9 @@ func DurationRtAddCounter(builder *flatbuffers.Builder, counter uint64) { func DurationRtAddSamplerate(builder *flatbuffers.Builder, samplerate uint64) { builder.PrependUint64Slot(6, samplerate, 0) } +func DurationRtAddRemaining(builder *flatbuffers.Builder, remaining uint64) { + builder.PrependUint64Slot(7, remaining, 0) +} func DurationRtEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/common/scheduler/fbs/DurationTimer.go b/pkg/fbs/common/scheduler/fbs/DurationTimer.go index 98fcd02..85e34da 100644 --- a/pkg/fbs/common/scheduler/fbs/DurationTimer.go +++ b/pkg/fbs/common/scheduler/fbs/DurationTimer.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DurationTimerT struct { + Timer Timer +} + +func (t *DurationTimerT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DurationTimerStart(builder) + DurationTimerAddTimer(builder, t.Timer) + return DurationTimerEnd(builder) +} + +func (rcv *DurationTimer) UnPackTo(t *DurationTimerT) { + t.Timer = rcv.Timer() +} + +func (rcv *DurationTimer) UnPack() *DurationTimerT { + if rcv == nil { return nil } + t := &DurationTimerT{} + rcv.UnPackTo(t) + return t +} + type DurationTimer struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Histogram.go b/pkg/fbs/common/scheduler/fbs/Histogram.go index 2508e72..dd15878 100644 --- a/pkg/fbs/common/scheduler/fbs/Histogram.go +++ b/pkg/fbs/common/scheduler/fbs/Histogram.go @@ -6,6 +6,44 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type HistogramT struct { + Scale uint64 + Values []uint64 +} + +func (t *HistogramT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valuesOffset := flatbuffers.UOffsetT(0) + if t.Values != nil { + valuesLength := len(t.Values) + HistogramStartValuesVector(builder, valuesLength) + for j := valuesLength - 1; j >= 0; j-- { + builder.PrependUint64(t.Values[j]) + } + valuesOffset = builder.EndVector(valuesLength) + } + HistogramStart(builder) + HistogramAddScale(builder, t.Scale) + HistogramAddValues(builder, valuesOffset) + return HistogramEnd(builder) +} + +func (rcv *Histogram) UnPackTo(t *HistogramT) { + t.Scale = rcv.Scale() + valuesLength := rcv.ValuesLength() + t.Values = make([]uint64, valuesLength) + for j := 0; j < valuesLength; j++ { + t.Values[j] = rcv.Values(j) + } +} + +func (rcv *Histogram) UnPack() *HistogramT { + if rcv == nil { return nil } + t := &HistogramT{} + rcv.UnPackTo(t) + return t +} + type Histogram struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Program.go b/pkg/fbs/common/scheduler/fbs/Program.go index 20b8465..65faeef 100644 --- a/pkg/fbs/common/scheduler/fbs/Program.go +++ b/pkg/fbs/common/scheduler/fbs/Program.go @@ -5,9 +5,58 @@ package fbs import ( flatbuffers "github.com/google/flatbuffers/go" - common__scheduler__watchdog__fbs "common/scheduler/watchdog/fbs" + common__scheduler__watchdog__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/watchdog/fbs" ) +type ProgramT struct { + Task *TaskT + Callables []*CallableT + Watchdog *common__scheduler__watchdog__fbs.WatchdogT +} + +func (t *ProgramT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskOffset := t.Task.Pack(builder) + callablesOffset := flatbuffers.UOffsetT(0) + if t.Callables != nil { + callablesLength := len(t.Callables) + callablesOffsets := make([]flatbuffers.UOffsetT, callablesLength) + for j := 0; j < callablesLength; j++ { + callablesOffsets[j] = t.Callables[j].Pack(builder) + } + ProgramStartCallablesVector(builder, callablesLength) + for j := callablesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(callablesOffsets[j]) + } + callablesOffset = builder.EndVector(callablesLength) + } + watchdogOffset := t.Watchdog.Pack(builder) + ProgramStart(builder) + ProgramAddTask(builder, taskOffset) + ProgramAddCallables(builder, callablesOffset) + ProgramAddWatchdog(builder, watchdogOffset) + return ProgramEnd(builder) +} + +func (rcv *Program) UnPackTo(t *ProgramT) { + t.Task = rcv.Task(nil).UnPack() + callablesLength := rcv.CallablesLength() + t.Callables = make([]*CallableT, callablesLength) + for j := 0; j < callablesLength; j++ { + x := Callable{} + rcv.Callables(&x, j) + t.Callables[j] = x.UnPack() + } + t.Watchdog = rcv.Watchdog(nil).UnPack() +} + +func (rcv *Program) UnPack() *ProgramT { + if rcv == nil { return nil } + t := &ProgramT{} + rcv.UnPackTo(t) + return t +} + type Program struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/Programs.go b/pkg/fbs/common/scheduler/fbs/Programs.go index 3683865..7a44bc4 100644 --- a/pkg/fbs/common/scheduler/fbs/Programs.go +++ b/pkg/fbs/common/scheduler/fbs/Programs.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ProgramsT struct { + Programs []*ProgramT +} + +func (t *ProgramsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + programsOffset := flatbuffers.UOffsetT(0) + if t.Programs != nil { + programsLength := len(t.Programs) + programsOffsets := make([]flatbuffers.UOffsetT, programsLength) + for j := 0; j < programsLength; j++ { + programsOffsets[j] = t.Programs[j].Pack(builder) + } + ProgramsStartProgramsVector(builder, programsLength) + for j := programsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(programsOffsets[j]) + } + programsOffset = builder.EndVector(programsLength) + } + ProgramsStart(builder) + ProgramsAddPrograms(builder, programsOffset) + return ProgramsEnd(builder) +} + +func (rcv *Programs) UnPackTo(t *ProgramsT) { + programsLength := rcv.ProgramsLength() + t.Programs = make([]*ProgramT, programsLength) + for j := 0; j < programsLength; j++ { + x := Program{} + rcv.Programs(&x, j) + t.Programs[j] = x.UnPack() + } +} + +func (rcv *Programs) UnPack() *ProgramsT { + if rcv == nil { return nil } + t := &ProgramsT{} + rcv.UnPackTo(t) + return t +} + type Programs struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/StartupErrorReaction.go b/pkg/fbs/common/scheduler/fbs/StartupErrorReaction.go index 1f4adf4..1a8806e 100644 --- a/pkg/fbs/common/scheduler/fbs/StartupErrorReaction.go +++ b/pkg/fbs/common/scheduler/fbs/StartupErrorReaction.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type StartupErrorReactionT struct { + ErrorReaction CurrentErrorReaction +} + +func (t *StartupErrorReactionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + StartupErrorReactionStart(builder) + StartupErrorReactionAddErrorReaction(builder, t.ErrorReaction) + return StartupErrorReactionEnd(builder) +} + +func (rcv *StartupErrorReaction) UnPackTo(t *StartupErrorReactionT) { + t.ErrorReaction = rcv.ErrorReaction() +} + +func (rcv *StartupErrorReaction) UnPack() *StartupErrorReactionT { + if rcv == nil { return nil } + t := &StartupErrorReactionT{} + rcv.UnPackTo(t) + return t +} + type StartupErrorReaction struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/State.go b/pkg/fbs/common/scheduler/fbs/State.go index 8aa30fd..1ff8487 100644 --- a/pkg/fbs/common/scheduler/fbs/State.go +++ b/pkg/fbs/common/scheduler/fbs/State.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type StateT struct { + State CurrentState +} + +func (t *StateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + StateStart(builder) + StateAddState(builder, t.State) + return StateEnd(builder) +} + +func (rcv *State) UnPackTo(t *StateT) { + t.State = rcv.State() +} + +func (rcv *State) UnPack() *StateT { + if rcv == nil { return nil } + t := &StateT{} + rcv.UnPackTo(t) + return t +} + type State struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/SyncPoints.go b/pkg/fbs/common/scheduler/fbs/SyncPoints.go new file mode 100644 index 0000000..0dd2fc8 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/SyncPoints.go @@ -0,0 +1,152 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// The names of the syncronization points of a callabale have to be unique. +/// To ensure that other callable can run after or before this callable it's recommended to set at least one syncronization point in each list. +type SyncPointsT struct { + After []string + Before []string +} + +func (t *SyncPointsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + afterOffset := flatbuffers.UOffsetT(0) + if t.After != nil { + afterLength := len(t.After) + afterOffsets := make([]flatbuffers.UOffsetT, afterLength) + for j := 0; j < afterLength; j++ { + afterOffsets[j] = builder.CreateString(t.After[j]) + } + SyncPointsStartAfterVector(builder, afterLength) + for j := afterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(afterOffsets[j]) + } + afterOffset = builder.EndVector(afterLength) + } + beforeOffset := flatbuffers.UOffsetT(0) + if t.Before != nil { + beforeLength := len(t.Before) + beforeOffsets := make([]flatbuffers.UOffsetT, beforeLength) + for j := 0; j < beforeLength; j++ { + beforeOffsets[j] = builder.CreateString(t.Before[j]) + } + SyncPointsStartBeforeVector(builder, beforeLength) + for j := beforeLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(beforeOffsets[j]) + } + beforeOffset = builder.EndVector(beforeLength) + } + SyncPointsStart(builder) + SyncPointsAddAfter(builder, afterOffset) + SyncPointsAddBefore(builder, beforeOffset) + return SyncPointsEnd(builder) +} + +func (rcv *SyncPoints) UnPackTo(t *SyncPointsT) { + afterLength := rcv.AfterLength() + t.After = make([]string, afterLength) + for j := 0; j < afterLength; j++ { + t.After[j] = string(rcv.After(j)) + } + beforeLength := rcv.BeforeLength() + t.Before = make([]string, beforeLength) + for j := 0; j < beforeLength; j++ { + t.Before[j] = string(rcv.Before(j)) + } +} + +func (rcv *SyncPoints) UnPack() *SyncPointsT { + if rcv == nil { return nil } + t := &SyncPointsT{} + rcv.UnPackTo(t) + return t +} + +type SyncPoints struct { + _tab flatbuffers.Table +} + +func GetRootAsSyncPoints(buf []byte, offset flatbuffers.UOffsetT) *SyncPoints { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SyncPoints{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsSyncPoints(buf []byte, offset flatbuffers.UOffsetT) *SyncPoints { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SyncPoints{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *SyncPoints) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SyncPoints) Table() flatbuffers.Table { + return rcv._tab +} + +/// user defined syncronization points, execute callable in order after these points +func (rcv *SyncPoints) After(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 *SyncPoints) AfterLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// user defined syncronization points, execute callable in order after these points +/// user defined syncronization points, execute callable in order before these points +func (rcv *SyncPoints) Before(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *SyncPoints) BeforeLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// user defined syncronization points, execute callable in order before these points +func SyncPointsStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func SyncPointsAddAfter(builder *flatbuffers.Builder, after flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(after), 0) +} +func SyncPointsStartAfterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func SyncPointsAddBefore(builder *flatbuffers.Builder, before flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(before), 0) +} +func SyncPointsStartBeforeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func SyncPointsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs/Task.go b/pkg/fbs/common/scheduler/fbs/Task.go index 73d2447..fc3eb32 100644 --- a/pkg/fbs/common/scheduler/fbs/Task.go +++ b/pkg/fbs/common/scheduler/fbs/Task.go @@ -6,6 +6,45 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TaskT struct { + Name string + Priority uint32 + Affinity uint32 + Stacksize uint32 + Event string + Cycletime uint32 +} + +func (t *TaskT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + eventOffset := builder.CreateString(t.Event) + TaskStart(builder) + TaskAddName(builder, nameOffset) + TaskAddPriority(builder, t.Priority) + TaskAddAffinity(builder, t.Affinity) + TaskAddStacksize(builder, t.Stacksize) + TaskAddEvent(builder, eventOffset) + TaskAddCycletime(builder, t.Cycletime) + return TaskEnd(builder) +} + +func (rcv *Task) UnPackTo(t *TaskT) { + t.Name = string(rcv.Name()) + t.Priority = rcv.Priority() + t.Affinity = rcv.Affinity() + t.Stacksize = rcv.Stacksize() + t.Event = string(rcv.Event()) + t.Cycletime = rcv.Cycletime() +} + +func (rcv *Task) UnPack() *TaskT { + if rcv == nil { return nil } + t := &TaskT{} + rcv.UnPackTo(t) + return t +} + type Task struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs/TaskSpecs.go b/pkg/fbs/common/scheduler/fbs/TaskSpecs.go new file mode 100644 index 0000000..86a770b --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/TaskSpecs.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TaskSpecsT struct { + Name string + Priority string + Type string +} + +func (t *TaskSpecsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + priorityOffset := builder.CreateString(t.Priority) + typeOffset := builder.CreateString(t.Type) + TaskSpecsStart(builder) + TaskSpecsAddName(builder, nameOffset) + TaskSpecsAddPriority(builder, priorityOffset) + TaskSpecsAddType(builder, typeOffset) + return TaskSpecsEnd(builder) +} + +func (rcv *TaskSpecs) UnPackTo(t *TaskSpecsT) { + t.Name = string(rcv.Name()) + t.Priority = string(rcv.Priority()) + t.Type = string(rcv.Type()) +} + +func (rcv *TaskSpecs) UnPack() *TaskSpecsT { + if rcv == nil { return nil } + t := &TaskSpecsT{} + rcv.UnPackTo(t) + return t +} + +type TaskSpecs struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskSpecs(buf []byte, offset flatbuffers.UOffsetT) *TaskSpecs { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskSpecs{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskSpecs(buf []byte, offset flatbuffers.UOffsetT) *TaskSpecs { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskSpecs{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskSpecs) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskSpecs) Table() flatbuffers.Table { + return rcv._tab +} + +/// task name to link callables together within a task, e.g. "ctrlXAutomation" or "gppServices" +func (rcv *TaskSpecs) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// task name to link callables together within a task, e.g. "ctrlXAutomation" or "gppServices" +/// task priority as well defined digit or range, e.g. "40" or "mid" to runs with medium priority +func (rcv *TaskSpecs) Priority() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// task priority as well defined digit or range, e.g. "40" or "mid" to runs with medium priority +/// describes required task properties, e.g. "cyclic/ms/10" to runs cyclic every 10 millisecons +func (rcv *TaskSpecs) Type() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// describes required task properties, e.g. "cyclic/ms/10" to runs cyclic every 10 millisecons +func TaskSpecsStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func TaskSpecsAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func TaskSpecsAddPriority(builder *flatbuffers.Builder, priority flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(priority), 0) +} +func TaskSpecsAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(type_), 0) +} +func TaskSpecsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs/Timer.go b/pkg/fbs/common/scheduler/fbs/Timer.go index b50d314..d1b1c81 100644 --- a/pkg/fbs/common/scheduler/fbs/Timer.go +++ b/pkg/fbs/common/scheduler/fbs/Timer.go @@ -13,6 +13,7 @@ const ( TimerOTHER Timer = 3 TimerEQUIDISTANCE Timer = 4 TimerDEVIATION Timer = 5 + TimerREMAINING Timer = 6 ) var EnumNamesTimer = map[Timer]string{ @@ -22,6 +23,7 @@ var EnumNamesTimer = map[Timer]string{ TimerOTHER: "OTHER", TimerEQUIDISTANCE: "EQUIDISTANCE", TimerDEVIATION: "DEVIATION", + TimerREMAINING: "REMAINING", } var EnumValuesTimer = map[string]Timer{ @@ -31,6 +33,7 @@ var EnumValuesTimer = map[string]Timer{ "OTHER": TimerOTHER, "EQUIDISTANCE": TimerEQUIDISTANCE, "DEVIATION": TimerDEVIATION, + "REMAINING": TimerREMAINING, } func (v Timer) String() string { diff --git a/pkg/fbs/common/scheduler/fbs/Trigger.go b/pkg/fbs/common/scheduler/fbs/Trigger.go index 8633174..1b65cbc 100644 --- a/pkg/fbs/common/scheduler/fbs/Trigger.go +++ b/pkg/fbs/common/scheduler/fbs/Trigger.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TriggerT struct { + Trigger CurrentTrigger +} + +func (t *TriggerT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TriggerStart(builder) + TriggerAddTrigger(builder, t.Trigger) + return TriggerEnd(builder) +} + +func (rcv *Trigger) UnPackTo(t *TriggerT) { + t.Trigger = rcv.Trigger() +} + +func (rcv *Trigger) UnPack() *TriggerT { + if rcv == nil { return nil } + t := &TriggerT{} + rcv.UnPackTo(t) + return t +} + type Trigger struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/fbs2/Admin.go b/pkg/fbs/common/scheduler/fbs2/Admin.go new file mode 100644 index 0000000..4d91835 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/Admin.go @@ -0,0 +1,233 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + common__scheduler__controls__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/controls/fbs" + common__scheduler__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/fbs" +) + +type AdminT struct { + StartupState CurrentState + StartupTimeout uint32 + StartupErrorReaction common__scheduler__fbs.CurrentErrorReaction + TriggerSource common__scheduler__fbs.CurrentTrigger + ControlDebug *common__scheduler__controls__fbs.ControlsT + CpuInfo *CpuInfoT + HardwareWatchdogRequired bool + WatchdogDefaultValue common__scheduler__fbs.CallableWdgConfig +} + +func (t *AdminT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + controlDebugOffset := t.ControlDebug.Pack(builder) + + cpuInfoOffset := t.CpuInfo.Pack(builder) + AdminStart(builder) + AdminAddStartupState(builder, t.StartupState) + AdminAddStartupTimeout(builder, t.StartupTimeout) + AdminAddStartupErrorReaction(builder, t.StartupErrorReaction) + AdminAddTriggerSource(builder, t.TriggerSource) + if t.ControlDebug != nil { + AdminAddControlDebugType(builder, t.ControlDebug.Type) + } + AdminAddControlDebug(builder, controlDebugOffset) + AdminAddCpuInfo(builder, cpuInfoOffset) + AdminAddHardwareWatchdogRequired(builder, t.HardwareWatchdogRequired) + AdminAddWatchdogDefaultValue(builder, t.WatchdogDefaultValue) + return AdminEnd(builder) +} + +func (rcv *Admin) UnPackTo(t *AdminT) { + t.StartupState = rcv.StartupState() + t.StartupTimeout = rcv.StartupTimeout() + t.StartupErrorReaction = rcv.StartupErrorReaction() + t.TriggerSource = rcv.TriggerSource() + controlDebugTable := flatbuffers.Table{} + if rcv.ControlDebug(&controlDebugTable) { + t.ControlDebug = rcv.ControlDebugType().UnPack(controlDebugTable) + } + t.CpuInfo = rcv.CpuInfo(nil).UnPack() + t.HardwareWatchdogRequired = rcv.HardwareWatchdogRequired() + t.WatchdogDefaultValue = rcv.WatchdogDefaultValue() +} + +func (rcv *Admin) UnPack() *AdminT { + if rcv == nil { return nil } + t := &AdminT{} + rcv.UnPackTo(t) + return t +} + +type Admin struct { + _tab flatbuffers.Table +} + +func GetRootAsAdmin(buf []byte, offset flatbuffers.UOffsetT) *Admin { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Admin{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAdmin(buf []byte, offset flatbuffers.UOffsetT) *Admin { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Admin{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Admin) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Admin) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Admin) StartupState() CurrentState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CurrentState(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Admin) MutateStartupState(n CurrentState) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func (rcv *Admin) StartupTimeout() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 5 +} + +func (rcv *Admin) MutateStartupTimeout(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *Admin) StartupErrorReaction() common__scheduler__fbs.CurrentErrorReaction { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return common__scheduler__fbs.CurrentErrorReaction(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Admin) MutateStartupErrorReaction(n common__scheduler__fbs.CurrentErrorReaction) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +func (rcv *Admin) TriggerSource() common__scheduler__fbs.CurrentTrigger { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return common__scheduler__fbs.CurrentTrigger(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +func (rcv *Admin) MutateTriggerSource(n common__scheduler__fbs.CurrentTrigger) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + +func (rcv *Admin) ControlDebugType() common__scheduler__controls__fbs.Controls { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return common__scheduler__controls__fbs.Controls(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Admin) MutateControlDebugType(n common__scheduler__controls__fbs.Controls) bool { + return rcv._tab.MutateByteSlot(12, byte(n)) +} + +func (rcv *Admin) ControlDebug(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func (rcv *Admin) CpuInfo(obj *CpuInfo) *CpuInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CpuInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// status of hardware watchdog requirment +func (rcv *Admin) HardwareWatchdogRequired() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// status of hardware watchdog requirment +func (rcv *Admin) MutateHardwareWatchdogRequired(n bool) bool { + return rcv._tab.MutateBoolSlot(18, n) +} + +/// influence default task and hardware watchdog handling +func (rcv *Admin) WatchdogDefaultValue() common__scheduler__fbs.CallableWdgConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return common__scheduler__fbs.CallableWdgConfig(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 3 +} + +/// influence default task and hardware watchdog handling +func (rcv *Admin) MutateWatchdogDefaultValue(n common__scheduler__fbs.CallableWdgConfig) bool { + return rcv._tab.MutateInt8Slot(20, int8(n)) +} + +func AdminStart(builder *flatbuffers.Builder) { + builder.StartObject(9) +} +func AdminAddStartupState(builder *flatbuffers.Builder, startupState CurrentState) { + builder.PrependInt8Slot(0, int8(startupState), 0) +} +func AdminAddStartupTimeout(builder *flatbuffers.Builder, startupTimeout uint32) { + builder.PrependUint32Slot(1, startupTimeout, 5) +} +func AdminAddStartupErrorReaction(builder *flatbuffers.Builder, startupErrorReaction common__scheduler__fbs.CurrentErrorReaction) { + builder.PrependInt8Slot(2, int8(startupErrorReaction), 0) +} +func AdminAddTriggerSource(builder *flatbuffers.Builder, triggerSource common__scheduler__fbs.CurrentTrigger) { + builder.PrependInt8Slot(3, int8(triggerSource), 1) +} +func AdminAddControlDebugType(builder *flatbuffers.Builder, controlDebugType common__scheduler__controls__fbs.Controls) { + builder.PrependByteSlot(4, byte(controlDebugType), 0) +} +func AdminAddControlDebug(builder *flatbuffers.Builder, controlDebug flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(controlDebug), 0) +} +func AdminAddCpuInfo(builder *flatbuffers.Builder, cpuInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(cpuInfo), 0) +} +func AdminAddHardwareWatchdogRequired(builder *flatbuffers.Builder, hardwareWatchdogRequired bool) { + builder.PrependBoolSlot(7, hardwareWatchdogRequired, false) +} +func AdminAddWatchdogDefaultValue(builder *flatbuffers.Builder, watchdogDefaultValue common__scheduler__fbs.CallableWdgConfig) { + builder.PrependInt8Slot(8, int8(watchdogDefaultValue), 3) +} +func AdminEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs2/CpuInfo.go b/pkg/fbs/common/scheduler/fbs2/CpuInfo.go new file mode 100644 index 0000000..2c510cc --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/CpuInfo.go @@ -0,0 +1,447 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CpuInfoT struct { + CpuCoresTotal []uint32 + CpuCoresActive []uint32 + CpuCoresRealtime []uint32 + CpuCoresNonRealtime []uint32 + CpuCoreRealtimeMax int32 + CpuCoreRealtimeMin int32 + CpuCoreRealtimeDefault int32 + CpuCoreNonRealtimeMax int32 + CpuCoreNonRealtimeMin int32 + CpuCoreNonRealtimeDefault int32 + VariationId string + CpuCoreHwWdg uint32 + CpuCorePtpTimer uint32 + CpuCoreScheduler uint32 + CpuCoreAutomation uint32 +} + +func (t *CpuInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cpuCoresTotalOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresTotal != nil { + cpuCoresTotalLength := len(t.CpuCoresTotal) + CpuInfoStartCpuCoresTotalVector(builder, cpuCoresTotalLength) + for j := cpuCoresTotalLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresTotal[j]) + } + cpuCoresTotalOffset = builder.EndVector(cpuCoresTotalLength) + } + cpuCoresActiveOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresActive != nil { + cpuCoresActiveLength := len(t.CpuCoresActive) + CpuInfoStartCpuCoresActiveVector(builder, cpuCoresActiveLength) + for j := cpuCoresActiveLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresActive[j]) + } + cpuCoresActiveOffset = builder.EndVector(cpuCoresActiveLength) + } + cpuCoresRealtimeOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresRealtime != nil { + cpuCoresRealtimeLength := len(t.CpuCoresRealtime) + CpuInfoStartCpuCoresRealtimeVector(builder, cpuCoresRealtimeLength) + for j := cpuCoresRealtimeLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresRealtime[j]) + } + cpuCoresRealtimeOffset = builder.EndVector(cpuCoresRealtimeLength) + } + cpuCoresNonRealtimeOffset := flatbuffers.UOffsetT(0) + if t.CpuCoresNonRealtime != nil { + cpuCoresNonRealtimeLength := len(t.CpuCoresNonRealtime) + CpuInfoStartCpuCoresNonRealtimeVector(builder, cpuCoresNonRealtimeLength) + for j := cpuCoresNonRealtimeLength - 1; j >= 0; j-- { + builder.PrependUint32(t.CpuCoresNonRealtime[j]) + } + cpuCoresNonRealtimeOffset = builder.EndVector(cpuCoresNonRealtimeLength) + } + variationIdOffset := builder.CreateString(t.VariationId) + CpuInfoStart(builder) + CpuInfoAddCpuCoresTotal(builder, cpuCoresTotalOffset) + CpuInfoAddCpuCoresActive(builder, cpuCoresActiveOffset) + CpuInfoAddCpuCoresRealtime(builder, cpuCoresRealtimeOffset) + CpuInfoAddCpuCoresNonRealtime(builder, cpuCoresNonRealtimeOffset) + CpuInfoAddCpuCoreRealtimeMax(builder, t.CpuCoreRealtimeMax) + CpuInfoAddCpuCoreRealtimeMin(builder, t.CpuCoreRealtimeMin) + CpuInfoAddCpuCoreRealtimeDefault(builder, t.CpuCoreRealtimeDefault) + CpuInfoAddCpuCoreNonRealtimeMax(builder, t.CpuCoreNonRealtimeMax) + CpuInfoAddCpuCoreNonRealtimeMin(builder, t.CpuCoreNonRealtimeMin) + CpuInfoAddCpuCoreNonRealtimeDefault(builder, t.CpuCoreNonRealtimeDefault) + CpuInfoAddVariationId(builder, variationIdOffset) + CpuInfoAddCpuCoreHwWdg(builder, t.CpuCoreHwWdg) + CpuInfoAddCpuCorePtpTimer(builder, t.CpuCorePtpTimer) + CpuInfoAddCpuCoreScheduler(builder, t.CpuCoreScheduler) + CpuInfoAddCpuCoreAutomation(builder, t.CpuCoreAutomation) + return CpuInfoEnd(builder) +} + +func (rcv *CpuInfo) UnPackTo(t *CpuInfoT) { + cpuCoresTotalLength := rcv.CpuCoresTotalLength() + t.CpuCoresTotal = make([]uint32, cpuCoresTotalLength) + for j := 0; j < cpuCoresTotalLength; j++ { + t.CpuCoresTotal[j] = rcv.CpuCoresTotal(j) + } + cpuCoresActiveLength := rcv.CpuCoresActiveLength() + t.CpuCoresActive = make([]uint32, cpuCoresActiveLength) + for j := 0; j < cpuCoresActiveLength; j++ { + t.CpuCoresActive[j] = rcv.CpuCoresActive(j) + } + cpuCoresRealtimeLength := rcv.CpuCoresRealtimeLength() + t.CpuCoresRealtime = make([]uint32, cpuCoresRealtimeLength) + for j := 0; j < cpuCoresRealtimeLength; j++ { + t.CpuCoresRealtime[j] = rcv.CpuCoresRealtime(j) + } + cpuCoresNonRealtimeLength := rcv.CpuCoresNonRealtimeLength() + t.CpuCoresNonRealtime = make([]uint32, cpuCoresNonRealtimeLength) + for j := 0; j < cpuCoresNonRealtimeLength; j++ { + t.CpuCoresNonRealtime[j] = rcv.CpuCoresNonRealtime(j) + } + t.CpuCoreRealtimeMax = rcv.CpuCoreRealtimeMax() + t.CpuCoreRealtimeMin = rcv.CpuCoreRealtimeMin() + t.CpuCoreRealtimeDefault = rcv.CpuCoreRealtimeDefault() + t.CpuCoreNonRealtimeMax = rcv.CpuCoreNonRealtimeMax() + t.CpuCoreNonRealtimeMin = rcv.CpuCoreNonRealtimeMin() + t.CpuCoreNonRealtimeDefault = rcv.CpuCoreNonRealtimeDefault() + t.VariationId = string(rcv.VariationId()) + t.CpuCoreHwWdg = rcv.CpuCoreHwWdg() + t.CpuCorePtpTimer = rcv.CpuCorePtpTimer() + t.CpuCoreScheduler = rcv.CpuCoreScheduler() + t.CpuCoreAutomation = rcv.CpuCoreAutomation() +} + +func (rcv *CpuInfo) UnPack() *CpuInfoT { + if rcv == nil { return nil } + t := &CpuInfoT{} + rcv.UnPackTo(t) + return t +} + +type CpuInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsCpuInfo(buf []byte, offset flatbuffers.UOffsetT) *CpuInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CpuInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCpuInfo(buf []byte, offset flatbuffers.UOffsetT) *CpuInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CpuInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CpuInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CpuInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CpuInfo) CpuCoresTotal(j int) uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + } + return 0 +} + +func (rcv *CpuInfo) CpuCoresTotalLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoresTotal(j int, n uint32) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + } + return false +} + +func (rcv *CpuInfo) CpuCoresActive(j int) uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + } + return 0 +} + +func (rcv *CpuInfo) CpuCoresActiveLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoresActive(j int, n uint32) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + } + return false +} + +func (rcv *CpuInfo) CpuCoresRealtime(j int) uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + } + return 0 +} + +func (rcv *CpuInfo) CpuCoresRealtimeLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoresRealtime(j int, n uint32) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + } + return false +} + +func (rcv *CpuInfo) CpuCoresNonRealtime(j int) uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + } + return 0 +} + +func (rcv *CpuInfo) CpuCoresNonRealtimeLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoresNonRealtime(j int, n uint32) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + } + return false +} + +func (rcv *CpuInfo) CpuCoreRealtimeMax() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreRealtimeMax(n int32) bool { + return rcv._tab.MutateInt32Slot(12, n) +} + +func (rcv *CpuInfo) CpuCoreRealtimeMin() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreRealtimeMin(n int32) bool { + return rcv._tab.MutateInt32Slot(14, n) +} + +func (rcv *CpuInfo) CpuCoreRealtimeDefault() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreRealtimeDefault(n int32) bool { + return rcv._tab.MutateInt32Slot(16, n) +} + +func (rcv *CpuInfo) CpuCoreNonRealtimeMax() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreNonRealtimeMax(n int32) bool { + return rcv._tab.MutateInt32Slot(18, n) +} + +func (rcv *CpuInfo) CpuCoreNonRealtimeMin() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreNonRealtimeMin(n int32) bool { + return rcv._tab.MutateInt32Slot(20, n) +} + +func (rcv *CpuInfo) CpuCoreNonRealtimeDefault() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +func (rcv *CpuInfo) MutateCpuCoreNonRealtimeDefault(n int32) bool { + return rcv._tab.MutateInt32Slot(22, n) +} + +func (rcv *CpuInfo) VariationId() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CpuInfo) CpuCoreHwWdg() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoreHwWdg(n uint32) bool { + return rcv._tab.MutateUint32Slot(26, n) +} + +func (rcv *CpuInfo) CpuCorePtpTimer() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCorePtpTimer(n uint32) bool { + return rcv._tab.MutateUint32Slot(28, n) +} + +func (rcv *CpuInfo) CpuCoreScheduler() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoreScheduler(n uint32) bool { + return rcv._tab.MutateUint32Slot(30, n) +} + +func (rcv *CpuInfo) CpuCoreAutomation() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(32)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *CpuInfo) MutateCpuCoreAutomation(n uint32) bool { + return rcv._tab.MutateUint32Slot(32, n) +} + +func CpuInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(15) +} +func CpuInfoAddCpuCoresTotal(builder *flatbuffers.Builder, cpuCoresTotal flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(cpuCoresTotal), 0) +} +func CpuInfoStartCpuCoresTotalVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CpuInfoAddCpuCoresActive(builder *flatbuffers.Builder, cpuCoresActive flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(cpuCoresActive), 0) +} +func CpuInfoStartCpuCoresActiveVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CpuInfoAddCpuCoresRealtime(builder *flatbuffers.Builder, cpuCoresRealtime flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(cpuCoresRealtime), 0) +} +func CpuInfoStartCpuCoresRealtimeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CpuInfoAddCpuCoresNonRealtime(builder *flatbuffers.Builder, cpuCoresNonRealtime flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(cpuCoresNonRealtime), 0) +} +func CpuInfoStartCpuCoresNonRealtimeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CpuInfoAddCpuCoreRealtimeMax(builder *flatbuffers.Builder, cpuCoreRealtimeMax int32) { + builder.PrependInt32Slot(4, cpuCoreRealtimeMax, -1) +} +func CpuInfoAddCpuCoreRealtimeMin(builder *flatbuffers.Builder, cpuCoreRealtimeMin int32) { + builder.PrependInt32Slot(5, cpuCoreRealtimeMin, -1) +} +func CpuInfoAddCpuCoreRealtimeDefault(builder *flatbuffers.Builder, cpuCoreRealtimeDefault int32) { + builder.PrependInt32Slot(6, cpuCoreRealtimeDefault, -1) +} +func CpuInfoAddCpuCoreNonRealtimeMax(builder *flatbuffers.Builder, cpuCoreNonRealtimeMax int32) { + builder.PrependInt32Slot(7, cpuCoreNonRealtimeMax, -1) +} +func CpuInfoAddCpuCoreNonRealtimeMin(builder *flatbuffers.Builder, cpuCoreNonRealtimeMin int32) { + builder.PrependInt32Slot(8, cpuCoreNonRealtimeMin, -1) +} +func CpuInfoAddCpuCoreNonRealtimeDefault(builder *flatbuffers.Builder, cpuCoreNonRealtimeDefault int32) { + builder.PrependInt32Slot(9, cpuCoreNonRealtimeDefault, -1) +} +func CpuInfoAddVariationId(builder *flatbuffers.Builder, variationId flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(variationId), 0) +} +func CpuInfoAddCpuCoreHwWdg(builder *flatbuffers.Builder, cpuCoreHwWdg uint32) { + builder.PrependUint32Slot(11, cpuCoreHwWdg, 0) +} +func CpuInfoAddCpuCorePtpTimer(builder *flatbuffers.Builder, cpuCorePtpTimer uint32) { + builder.PrependUint32Slot(12, cpuCorePtpTimer, 0) +} +func CpuInfoAddCpuCoreScheduler(builder *flatbuffers.Builder, cpuCoreScheduler uint32) { + builder.PrependUint32Slot(13, cpuCoreScheduler, 0) +} +func CpuInfoAddCpuCoreAutomation(builder *flatbuffers.Builder, cpuCoreAutomation uint32) { + builder.PrependUint32Slot(14, cpuCoreAutomation, 0) +} +func CpuInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs2/CurrentState.go b/pkg/fbs/common/scheduler/fbs2/CurrentState.go new file mode 100644 index 0000000..b421de2 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/CurrentState.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import "strconv" + +type CurrentState int8 + +const ( + CurrentStateOPERATING CurrentState = 0 + CurrentStateSETUP CurrentState = 1 + CurrentStateSERVICE CurrentState = 2 + CurrentStateEXIT CurrentState = 3 +) + +var EnumNamesCurrentState = map[CurrentState]string{ + CurrentStateOPERATING: "OPERATING", + CurrentStateSETUP: "SETUP", + CurrentStateSERVICE: "SERVICE", + CurrentStateEXIT: "EXIT", +} + +var EnumValuesCurrentState = map[string]CurrentState{ + "OPERATING": CurrentStateOPERATING, + "SETUP": CurrentStateSETUP, + "SERVICE": CurrentStateSERVICE, + "EXIT": CurrentStateEXIT, +} + +func (v CurrentState) String() string { + if s, ok := EnumNamesCurrentState[v]; ok { + return s + } + return "CurrentState(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/scheduler/fbs2/Program.go b/pkg/fbs/common/scheduler/fbs2/Program.go new file mode 100644 index 0000000..3fc7767 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/Program.go @@ -0,0 +1,194 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + common__scheduler__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/fbs" + common__scheduler__watchdog__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/watchdog/fbs" +) + +type ProgramT struct { + Task *common__scheduler__fbs.TaskT + Callables []*common__scheduler__fbs.CallableT + Watchdog *common__scheduler__watchdog__fbs.WatchdogT + Sequence []string +} + +func (t *ProgramT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskOffset := t.Task.Pack(builder) + callablesOffset := flatbuffers.UOffsetT(0) + if t.Callables != nil { + callablesLength := len(t.Callables) + callablesOffsets := make([]flatbuffers.UOffsetT, callablesLength) + for j := 0; j < callablesLength; j++ { + callablesOffsets[j] = t.Callables[j].Pack(builder) + } + ProgramStartCallablesVector(builder, callablesLength) + for j := callablesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(callablesOffsets[j]) + } + callablesOffset = builder.EndVector(callablesLength) + } + watchdogOffset := t.Watchdog.Pack(builder) + sequenceOffset := flatbuffers.UOffsetT(0) + if t.Sequence != nil { + sequenceLength := len(t.Sequence) + sequenceOffsets := make([]flatbuffers.UOffsetT, sequenceLength) + for j := 0; j < sequenceLength; j++ { + sequenceOffsets[j] = builder.CreateString(t.Sequence[j]) + } + ProgramStartSequenceVector(builder, sequenceLength) + for j := sequenceLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(sequenceOffsets[j]) + } + sequenceOffset = builder.EndVector(sequenceLength) + } + ProgramStart(builder) + ProgramAddTask(builder, taskOffset) + ProgramAddCallables(builder, callablesOffset) + ProgramAddWatchdog(builder, watchdogOffset) + ProgramAddSequence(builder, sequenceOffset) + return ProgramEnd(builder) +} + +func (rcv *Program) UnPackTo(t *ProgramT) { + t.Task = rcv.Task(nil).UnPack() + callablesLength := rcv.CallablesLength() + t.Callables = make([]*common__scheduler__fbs.CallableT, callablesLength) + for j := 0; j < callablesLength; j++ { + x := common__scheduler__fbs.Callable{} + rcv.Callables(&x, j) + t.Callables[j] = x.UnPack() + } + t.Watchdog = rcv.Watchdog(nil).UnPack() + sequenceLength := rcv.SequenceLength() + t.Sequence = make([]string, sequenceLength) + for j := 0; j < sequenceLength; j++ { + t.Sequence[j] = string(rcv.Sequence(j)) + } +} + +func (rcv *Program) UnPack() *ProgramT { + if rcv == nil { return nil } + t := &ProgramT{} + rcv.UnPackTo(t) + return t +} + +type Program struct { + _tab flatbuffers.Table +} + +func GetRootAsProgram(buf []byte, offset flatbuffers.UOffsetT) *Program { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Program{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsProgram(buf []byte, offset flatbuffers.UOffsetT) *Program { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Program{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Program) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Program) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Program) Task(obj *common__scheduler__fbs.Task) *common__scheduler__fbs.Task { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(common__scheduler__fbs.Task) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Program) Callables(obj *common__scheduler__fbs.Callable, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + 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 *Program) CallablesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Program) Watchdog(obj *common__scheduler__watchdog__fbs.Watchdog) *common__scheduler__watchdog__fbs.Watchdog { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(common__scheduler__watchdog__fbs.Watchdog) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Program) Sequence(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *Program) SequenceLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ProgramStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func ProgramAddTask(builder *flatbuffers.Builder, task flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(task), 0) +} +func ProgramAddCallables(builder *flatbuffers.Builder, callables flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(callables), 0) +} +func ProgramStartCallablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ProgramAddWatchdog(builder *flatbuffers.Builder, watchdog flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(watchdog), 0) +} +func ProgramAddSequence(builder *flatbuffers.Builder, sequence flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(sequence), 0) +} +func ProgramStartSequenceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ProgramEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs2/Programs.go b/pkg/fbs/common/scheduler/fbs2/Programs.go new file mode 100644 index 0000000..89acbf7 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/Programs.go @@ -0,0 +1,151 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ProgramsT struct { + Programs []*ProgramT + CallablePool []string +} + +func (t *ProgramsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + programsOffset := flatbuffers.UOffsetT(0) + if t.Programs != nil { + programsLength := len(t.Programs) + programsOffsets := make([]flatbuffers.UOffsetT, programsLength) + for j := 0; j < programsLength; j++ { + programsOffsets[j] = t.Programs[j].Pack(builder) + } + ProgramsStartProgramsVector(builder, programsLength) + for j := programsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(programsOffsets[j]) + } + programsOffset = builder.EndVector(programsLength) + } + callablePoolOffset := flatbuffers.UOffsetT(0) + if t.CallablePool != nil { + callablePoolLength := len(t.CallablePool) + callablePoolOffsets := make([]flatbuffers.UOffsetT, callablePoolLength) + for j := 0; j < callablePoolLength; j++ { + callablePoolOffsets[j] = builder.CreateString(t.CallablePool[j]) + } + ProgramsStartCallablePoolVector(builder, callablePoolLength) + for j := callablePoolLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(callablePoolOffsets[j]) + } + callablePoolOffset = builder.EndVector(callablePoolLength) + } + ProgramsStart(builder) + ProgramsAddPrograms(builder, programsOffset) + ProgramsAddCallablePool(builder, callablePoolOffset) + return ProgramsEnd(builder) +} + +func (rcv *Programs) UnPackTo(t *ProgramsT) { + programsLength := rcv.ProgramsLength() + t.Programs = make([]*ProgramT, programsLength) + for j := 0; j < programsLength; j++ { + x := Program{} + rcv.Programs(&x, j) + t.Programs[j] = x.UnPack() + } + callablePoolLength := rcv.CallablePoolLength() + t.CallablePool = make([]string, callablePoolLength) + for j := 0; j < callablePoolLength; j++ { + t.CallablePool[j] = string(rcv.CallablePool(j)) + } +} + +func (rcv *Programs) UnPack() *ProgramsT { + if rcv == nil { return nil } + t := &ProgramsT{} + rcv.UnPackTo(t) + return t +} + +type Programs struct { + _tab flatbuffers.Table +} + +func GetRootAsPrograms(buf []byte, offset flatbuffers.UOffsetT) *Programs { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Programs{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPrograms(buf []byte, offset flatbuffers.UOffsetT) *Programs { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Programs{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Programs) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Programs) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Programs) Programs(obj *Program, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *Programs) ProgramsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Programs) CallablePool(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *Programs) CallablePoolLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ProgramsStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func ProgramsAddPrograms(builder *flatbuffers.Builder, programs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(programs), 0) +} +func ProgramsStartProgramsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ProgramsAddCallablePool(builder *flatbuffers.Builder, callablePool flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(callablePool), 0) +} +func ProgramsStartCallablePoolVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ProgramsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/fbs2/State.go b/pkg/fbs/common/scheduler/fbs2/State.go new file mode 100644 index 0000000..3be9e88 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/State.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type StateT struct { + State CurrentState +} + +func (t *StateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + StateStart(builder) + StateAddState(builder, t.State) + return StateEnd(builder) +} + +func (rcv *State) UnPackTo(t *StateT) { + t.State = rcv.State() +} + +func (rcv *State) UnPack() *StateT { + if rcv == nil { return nil } + t := &StateT{} + rcv.UnPackTo(t) + return t +} + +type State struct { + _tab flatbuffers.Table +} + +func GetRootAsState(buf []byte, offset flatbuffers.UOffsetT) *State { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState(buf []byte, offset flatbuffers.UOffsetT) *State { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State) State() CurrentState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CurrentState(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +func (rcv *State) MutateState(n CurrentState) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func StateStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func StateAddState(builder *flatbuffers.Builder, state CurrentState) { + builder.PrependInt8Slot(0, int8(state), 1) +} +func StateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Class.go b/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Class.go index 709c5a2..828959c 100644 --- a/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Class.go +++ b/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Class.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ClassT struct { + Type CurrentClass +} + +func (t *ClassT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ClassStart(builder) + ClassAddType(builder, t.Type) + return ClassEnd(builder) +} + +func (rcv *Class) UnPackTo(t *ClassT) { + t.Type = rcv.Type() +} + +func (rcv *Class) UnPack() *ClassT { + if rcv == nil { return nil } + t := &ClassT{} + rcv.UnPackTo(t) + return t +} + type Class struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Configuration.go b/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Configuration.go index 67b5dec..ec1afe3 100644 --- a/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Configuration.go +++ b/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs/Configuration.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ConfigurationT struct { + Type CurrentConfiguration +} + +func (t *ConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ConfigurationStart(builder) + ConfigurationAddType(builder, t.Type) + return ConfigurationEnd(builder) +} + +func (rcv *Configuration) UnPackTo(t *ConfigurationT) { + t.Type = rcv.Type() +} + +func (rcv *Configuration) UnPack() *ConfigurationT { + if rcv == nil { return nil } + t := &ConfigurationT{} + rcv.UnPackTo(t) + return t +} + type Configuration struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/CurrentType.go b/pkg/fbs/common/scheduler/watchdog/fbs/CurrentType.go index 48ab368..07256dd 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/CurrentType.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/CurrentType.go @@ -8,14 +8,17 @@ type CurrentType int8 const ( CurrentTypeCYCLE CurrentType = 0 + CurrentTypeNONE CurrentType = 1 ) var EnumNamesCurrentType = map[CurrentType]string{ CurrentTypeCYCLE: "CYCLE", + CurrentTypeNONE: "NONE", } var EnumValuesCurrentType = map[string]CurrentType{ "CYCLE": CurrentTypeCYCLE, + "NONE": CurrentTypeNONE, } func (v CurrentType) String() string { diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/Cyclic.go b/pkg/fbs/common/scheduler/watchdog/fbs/Cyclic.go index 039dfd2..f5f79fc 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/Cyclic.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/Cyclic.go @@ -6,6 +6,35 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CyclicT struct { + ErrorCount uint32 + Reset bool + ErrorReaction *ErrorReactionT +} + +func (t *CyclicT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + errorReactionOffset := t.ErrorReaction.Pack(builder) + CyclicStart(builder) + CyclicAddErrorCount(builder, t.ErrorCount) + CyclicAddReset(builder, t.Reset) + CyclicAddErrorReaction(builder, errorReactionOffset) + return CyclicEnd(builder) +} + +func (rcv *Cyclic) UnPackTo(t *CyclicT) { + t.ErrorCount = rcv.ErrorCount() + t.Reset = rcv.Reset() + t.ErrorReaction = rcv.ErrorReaction(nil).UnPack() +} + +func (rcv *Cyclic) UnPack() *CyclicT { + if rcv == nil { return nil } + t := &CyclicT{} + rcv.UnPackTo(t) + return t +} + type Cyclic struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/Duration.go b/pkg/fbs/common/scheduler/watchdog/fbs/Duration.go index 10526bc..65c0ff0 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/Duration.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/Duration.go @@ -6,6 +6,38 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DurationT struct { + Time uint32 + ErrorCount uint32 + Reset bool + ErrorReaction *ErrorReactionT +} + +func (t *DurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + errorReactionOffset := t.ErrorReaction.Pack(builder) + DurationStart(builder) + DurationAddTime(builder, t.Time) + DurationAddErrorCount(builder, t.ErrorCount) + DurationAddReset(builder, t.Reset) + DurationAddErrorReaction(builder, errorReactionOffset) + return DurationEnd(builder) +} + +func (rcv *Duration) UnPackTo(t *DurationT) { + t.Time = rcv.Time() + t.ErrorCount = rcv.ErrorCount() + t.Reset = rcv.Reset() + t.ErrorReaction = rcv.ErrorReaction(nil).UnPack() +} + +func (rcv *Duration) UnPack() *DurationT { + if rcv == nil { return nil } + t := &DurationT{} + rcv.UnPackTo(t) + return t +} + type Duration struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/ErrorReaction.go b/pkg/fbs/common/scheduler/watchdog/fbs/ErrorReaction.go index d3bf61d..fdf259a 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/ErrorReaction.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/ErrorReaction.go @@ -5,9 +5,39 @@ package fbs import ( flatbuffers "github.com/google/flatbuffers/go" - common__scheduler__watchdog__errorreaction__fbs "common/scheduler/watchdog/errorreaction/fbs" + common__scheduler__watchdog__errorreaction__fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/common/scheduler/watchdog/errorreaction/fbs" ) +type ErrorReactionT struct { + Class *common__scheduler__watchdog__errorreaction__fbs.ClassT + Configuration *common__scheduler__watchdog__errorreaction__fbs.ConfigurationT + MaxConsecutiveErrors uint32 +} + +func (t *ErrorReactionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + classOffset := t.Class.Pack(builder) + configurationOffset := t.Configuration.Pack(builder) + ErrorReactionStart(builder) + ErrorReactionAddClass(builder, classOffset) + ErrorReactionAddConfiguration(builder, configurationOffset) + ErrorReactionAddMaxConsecutiveErrors(builder, t.MaxConsecutiveErrors) + return ErrorReactionEnd(builder) +} + +func (rcv *ErrorReaction) UnPackTo(t *ErrorReactionT) { + t.Class = rcv.Class(nil).UnPack() + t.Configuration = rcv.Configuration(nil).UnPack() + t.MaxConsecutiveErrors = rcv.MaxConsecutiveErrors() +} + +func (rcv *ErrorReaction) UnPack() *ErrorReactionT { + if rcv == nil { return nil } + t := &ErrorReactionT{} + rcv.UnPackTo(t) + return t +} + type ErrorReaction struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/Type.go b/pkg/fbs/common/scheduler/watchdog/fbs/Type.go index bf79a08..995ec16 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/Type.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/Type.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type TypeT struct { + Type CurrentType +} + +func (t *TypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + TypeStart(builder) + TypeAddType(builder, t.Type) + return TypeEnd(builder) +} + +func (rcv *Type) UnPackTo(t *TypeT) { + t.Type = rcv.Type() +} + +func (rcv *Type) UnPack() *TypeT { + if rcv == nil { return nil } + t := &TypeT{} + rcv.UnPackTo(t) + return t +} + type Type struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/Watchdog.go b/pkg/fbs/common/scheduler/watchdog/fbs/Watchdog.go index 92efe99..6eeb027 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/Watchdog.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/Watchdog.go @@ -6,6 +6,44 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type WatchdogT struct { + Name string + Type *TypeT + Variant *WatchdogVariantT +} + +func (t *WatchdogT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + typeOffset := t.Type.Pack(builder) + variantOffset := t.Variant.Pack(builder) + + WatchdogStart(builder) + WatchdogAddName(builder, nameOffset) + WatchdogAddType(builder, typeOffset) + if t.Variant != nil { + WatchdogAddVariantType(builder, t.Variant.Type) + } + WatchdogAddVariant(builder, variantOffset) + return WatchdogEnd(builder) +} + +func (rcv *Watchdog) UnPackTo(t *WatchdogT) { + t.Name = string(rcv.Name()) + t.Type = rcv.Type(nil).UnPack() + variantTable := flatbuffers.Table{} + if rcv.Variant(&variantTable) { + t.Variant = rcv.VariantType().UnPack(variantTable) + } +} + +func (rcv *Watchdog) UnPack() *WatchdogT { + if rcv == nil { return nil } + t := &WatchdogT{} + rcv.UnPackTo(t) + return t +} + type Watchdog struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/scheduler/watchdog/fbs/WatchdogVariant.go b/pkg/fbs/common/scheduler/watchdog/fbs/WatchdogVariant.go index c4b15b3..5887435 100644 --- a/pkg/fbs/common/scheduler/watchdog/fbs/WatchdogVariant.go +++ b/pkg/fbs/common/scheduler/watchdog/fbs/WatchdogVariant.go @@ -2,7 +2,11 @@ package fbs -import "strconv" +import ( + "strconv" + + flatbuffers "github.com/google/flatbuffers/go" +) type WatchdogVariant byte @@ -30,3 +34,33 @@ func (v WatchdogVariant) String() string { } return "WatchdogVariant(" + strconv.FormatInt(int64(v), 10) + ")" } + +type WatchdogVariantT struct { + Type WatchdogVariant + Value interface{} +} + +func (t *WatchdogVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case WatchdogVariantCyclic: + return t.Value.(*CyclicT).Pack(builder) + case WatchdogVariantDuration: + return t.Value.(*DurationT).Pack(builder) + } + return 0 +} + +func (rcv WatchdogVariant) UnPack(table flatbuffers.Table) *WatchdogVariantT { + switch rcv { + case WatchdogVariantCyclic: + x := Cyclic{_tab: table} + return &WatchdogVariantT{ Type: WatchdogVariantCyclic, Value: x.UnPack() } + case WatchdogVariantDuration: + x := Duration{_tab: table} + return &WatchdogVariantT{ Type: WatchdogVariantDuration, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/common/systemcore/licenseproxy/LicenseCapabilities.go b/pkg/fbs/common/systemcore/licenseproxy/LicenseCapabilities.go index 444ad68..a52785b 100644 --- a/pkg/fbs/common/systemcore/licenseproxy/LicenseCapabilities.go +++ b/pkg/fbs/common/systemcore/licenseproxy/LicenseCapabilities.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LicenseCapabilitiesT struct { + Capabilities []*LicenseCapabilityT +} + +func (t *LicenseCapabilitiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + capabilitiesOffset := flatbuffers.UOffsetT(0) + if t.Capabilities != nil { + capabilitiesLength := len(t.Capabilities) + capabilitiesOffsets := make([]flatbuffers.UOffsetT, capabilitiesLength) + for j := 0; j < capabilitiesLength; j++ { + capabilitiesOffsets[j] = t.Capabilities[j].Pack(builder) + } + LicenseCapabilitiesStartCapabilitiesVector(builder, capabilitiesLength) + for j := capabilitiesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(capabilitiesOffsets[j]) + } + capabilitiesOffset = builder.EndVector(capabilitiesLength) + } + LicenseCapabilitiesStart(builder) + LicenseCapabilitiesAddCapabilities(builder, capabilitiesOffset) + return LicenseCapabilitiesEnd(builder) +} + +func (rcv *LicenseCapabilities) UnPackTo(t *LicenseCapabilitiesT) { + capabilitiesLength := rcv.CapabilitiesLength() + t.Capabilities = make([]*LicenseCapabilityT, capabilitiesLength) + for j := 0; j < capabilitiesLength; j++ { + x := LicenseCapability{} + rcv.Capabilities(&x, j) + t.Capabilities[j] = x.UnPack() + } +} + +func (rcv *LicenseCapabilities) UnPack() *LicenseCapabilitiesT { + if rcv == nil { return nil } + t := &LicenseCapabilitiesT{} + rcv.UnPackTo(t) + return t +} + type LicenseCapabilities struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/systemcore/licenseproxy/LicenseCapability.go b/pkg/fbs/common/systemcore/licenseproxy/LicenseCapability.go index 34559a8..a753bb4 100644 --- a/pkg/fbs/common/systemcore/licenseproxy/LicenseCapability.go +++ b/pkg/fbs/common/systemcore/licenseproxy/LicenseCapability.go @@ -6,6 +6,47 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LicenseCapabilityT struct { + Name string + Version string + Count int32 + IsPermanent bool + StartDate string + FinalExpirationDate string +} + +func (t *LicenseCapabilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + startDateOffset := builder.CreateString(t.StartDate) + finalExpirationDateOffset := builder.CreateString(t.FinalExpirationDate) + LicenseCapabilityStart(builder) + LicenseCapabilityAddName(builder, nameOffset) + LicenseCapabilityAddVersion(builder, versionOffset) + LicenseCapabilityAddCount(builder, t.Count) + LicenseCapabilityAddIsPermanent(builder, t.IsPermanent) + LicenseCapabilityAddStartDate(builder, startDateOffset) + LicenseCapabilityAddFinalExpirationDate(builder, finalExpirationDateOffset) + return LicenseCapabilityEnd(builder) +} + +func (rcv *LicenseCapability) UnPackTo(t *LicenseCapabilityT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) + t.Count = rcv.Count() + t.IsPermanent = rcv.IsPermanent() + t.StartDate = string(rcv.StartDate()) + t.FinalExpirationDate = string(rcv.FinalExpirationDate()) +} + +func (rcv *LicenseCapability) UnPack() *LicenseCapabilityT { + if rcv == nil { return nil } + t := &LicenseCapabilityT{} + rcv.UnPackTo(t) + return t +} + type LicenseCapability struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/systemcore/licenseproxy/LicenseRequest.go b/pkg/fbs/common/systemcore/licenseproxy/LicenseRequest.go index 87afbc3..d80835d 100644 --- a/pkg/fbs/common/systemcore/licenseproxy/LicenseRequest.go +++ b/pkg/fbs/common/systemcore/licenseproxy/LicenseRequest.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LicenseRequestT struct { + Name string + Version string +} + +func (t *LicenseRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + LicenseRequestStart(builder) + LicenseRequestAddName(builder, nameOffset) + LicenseRequestAddVersion(builder, versionOffset) + return LicenseRequestEnd(builder) +} + +func (rcv *LicenseRequest) UnPackTo(t *LicenseRequestT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) +} + +func (rcv *LicenseRequest) UnPack() *LicenseRequestT { + if rcv == nil { return nil } + t := &LicenseRequestT{} + rcv.UnPackTo(t) + return t +} + type LicenseRequest struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/systemcore/licenseproxy/LicenseResponse.go b/pkg/fbs/common/systemcore/licenseproxy/LicenseResponse.go index 25377aa..09c3ca7 100644 --- a/pkg/fbs/common/systemcore/licenseproxy/LicenseResponse.go +++ b/pkg/fbs/common/systemcore/licenseproxy/LicenseResponse.go @@ -6,6 +6,51 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type LicenseResponseT struct { + Name string + Version string + Id string + IsPermanent bool + StartDate string + EndDate string + Tampered bool +} + +func (t *LicenseResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + idOffset := builder.CreateString(t.Id) + startDateOffset := builder.CreateString(t.StartDate) + endDateOffset := builder.CreateString(t.EndDate) + LicenseResponseStart(builder) + LicenseResponseAddName(builder, nameOffset) + LicenseResponseAddVersion(builder, versionOffset) + LicenseResponseAddId(builder, idOffset) + LicenseResponseAddIsPermanent(builder, t.IsPermanent) + LicenseResponseAddStartDate(builder, startDateOffset) + LicenseResponseAddEndDate(builder, endDateOffset) + LicenseResponseAddTampered(builder, t.Tampered) + return LicenseResponseEnd(builder) +} + +func (rcv *LicenseResponse) UnPackTo(t *LicenseResponseT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) + t.Id = string(rcv.Id()) + t.IsPermanent = rcv.IsPermanent() + t.StartDate = string(rcv.StartDate()) + t.EndDate = string(rcv.EndDate()) + t.Tampered = rcv.Tampered() +} + +func (rcv *LicenseResponse) UnPack() *LicenseResponseT { + if rcv == nil { return nil } + t := &LicenseResponseT{} + rcv.UnPackTo(t) + return t +} + type LicenseResponse struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/systemhandler/fbs/CurrentState.go b/pkg/fbs/common/systemhandler/fbs/CurrentState.go index 781f3cd..d96fd20 100644 --- a/pkg/fbs/common/systemhandler/fbs/CurrentState.go +++ b/pkg/fbs/common/systemhandler/fbs/CurrentState.go @@ -7,33 +7,45 @@ import "strconv" type CurrentState int8 const ( - CurrentStateINIT CurrentState = 0 - CurrentStateSTOP CurrentState = 1 - CurrentStateRUN CurrentState = 2 - CurrentStateERROR CurrentState = 3 - CurrentStateSYSERROR CurrentState = 4 - CurrentStateSHUTDOWN CurrentState = 5 - CurrentStateWARNING CurrentState = 6 + CurrentStateINIT CurrentState = 0 + CurrentStateSTOP CurrentState = 1 + CurrentStateRUN CurrentState = 2 + CurrentStateERROR CurrentState = 3 + CurrentStateSYSERROR CurrentState = 4 + CurrentStateSHUTDOWN CurrentState = 5 + CurrentStateWARNING CurrentState = 6 + CurrentStateSERVICE CurrentState = 7 + CurrentStateSETUP CurrentState = 8 + CurrentStatePARTIAL_OPERATING CurrentState = 9 + CurrentStateOPERATING CurrentState = 10 ) var EnumNamesCurrentState = map[CurrentState]string{ - CurrentStateINIT: "INIT", - CurrentStateSTOP: "STOP", - CurrentStateRUN: "RUN", - CurrentStateERROR: "ERROR", - CurrentStateSYSERROR: "SYSERROR", - CurrentStateSHUTDOWN: "SHUTDOWN", - CurrentStateWARNING: "WARNING", + CurrentStateINIT: "INIT", + CurrentStateSTOP: "STOP", + CurrentStateRUN: "RUN", + CurrentStateERROR: "ERROR", + CurrentStateSYSERROR: "SYSERROR", + CurrentStateSHUTDOWN: "SHUTDOWN", + CurrentStateWARNING: "WARNING", + CurrentStateSERVICE: "SERVICE", + CurrentStateSETUP: "SETUP", + CurrentStatePARTIAL_OPERATING: "PARTIAL_OPERATING", + CurrentStateOPERATING: "OPERATING", } var EnumValuesCurrentState = map[string]CurrentState{ - "INIT": CurrentStateINIT, - "STOP": CurrentStateSTOP, - "RUN": CurrentStateRUN, - "ERROR": CurrentStateERROR, - "SYSERROR": CurrentStateSYSERROR, - "SHUTDOWN": CurrentStateSHUTDOWN, - "WARNING": CurrentStateWARNING, + "INIT": CurrentStateINIT, + "STOP": CurrentStateSTOP, + "RUN": CurrentStateRUN, + "ERROR": CurrentStateERROR, + "SYSERROR": CurrentStateSYSERROR, + "SHUTDOWN": CurrentStateSHUTDOWN, + "WARNING": CurrentStateWARNING, + "SERVICE": CurrentStateSERVICE, + "SETUP": CurrentStateSETUP, + "PARTIAL_OPERATING": CurrentStatePARTIAL_OPERATING, + "OPERATING": CurrentStateOPERATING, } func (v CurrentState) String() string { diff --git a/pkg/fbs/common/systemhandler/fbs/State.go b/pkg/fbs/common/systemhandler/fbs/State.go index aef8fa2..67403f1 100644 --- a/pkg/fbs/common/systemhandler/fbs/State.go +++ b/pkg/fbs/common/systemhandler/fbs/State.go @@ -6,6 +6,28 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type StateT struct { + State CurrentState +} + +func (t *StateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + StateStart(builder) + StateAddState(builder, t.State) + return StateEnd(builder) +} + +func (rcv *State) UnPackTo(t *StateT) { + t.State = rcv.State() +} + +func (rcv *State) UnPack() *StateT { + if rcv == nil { return nil } + t := &StateT{} + rcv.UnPackTo(t) + return t +} + type State struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/common/testbuddy/Data.go b/pkg/fbs/common/testbuddy/Data.go new file mode 100644 index 0000000..49ab9ac --- /dev/null +++ b/pkg/fbs/common/testbuddy/Data.go @@ -0,0 +1,93 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package testbuddy + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DataT struct { + Name string + Value float64 +} + +func (t *DataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + DataStart(builder) + DataAddName(builder, nameOffset) + DataAddValue(builder, t.Value) + return DataEnd(builder) +} + +func (rcv *Data) UnPackTo(t *DataT) { + t.Name = string(rcv.Name()) + t.Value = rcv.Value() +} + +func (rcv *Data) UnPack() *DataT { + if rcv == nil { return nil } + t := &DataT{} + rcv.UnPackTo(t) + return t +} + +type Data struct { + _tab flatbuffers.Table +} + +func GetRootAsData(buf []byte, offset flatbuffers.UOffsetT) *Data { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Data{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsData(buf []byte, offset flatbuffers.UOffsetT) *Data { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Data{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Data) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Data) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Data) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Data) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Data) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func DataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func DataAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func DataAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(1, value, 0.0) +} +func DataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/testbuddy/Log.go b/pkg/fbs/common/testbuddy/Log.go new file mode 100644 index 0000000..32a07e7 --- /dev/null +++ b/pkg/fbs/common/testbuddy/Log.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package testbuddy + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LogT struct { + Index uint32 + Type LogType + Log string +} + +func (t *LogT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + logOffset := builder.CreateString(t.Log) + LogStart(builder) + LogAddIndex(builder, t.Index) + LogAddType(builder, t.Type) + LogAddLog(builder, logOffset) + return LogEnd(builder) +} + +func (rcv *Log) UnPackTo(t *LogT) { + t.Index = rcv.Index() + t.Type = rcv.Type() + t.Log = string(rcv.Log()) +} + +func (rcv *Log) UnPack() *LogT { + if rcv == nil { return nil } + t := &LogT{} + rcv.UnPackTo(t) + return t +} + +type Log struct { + _tab flatbuffers.Table +} + +func GetRootAsLog(buf []byte, offset flatbuffers.UOffsetT) *Log { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Log{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLog(buf []byte, offset flatbuffers.UOffsetT) *Log { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Log{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Log) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Log) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Log) Index() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Log) MutateIndex(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *Log) Type() LogType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return LogType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Log) MutateType(n LogType) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func (rcv *Log) Log() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func LogStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func LogAddIndex(builder *flatbuffers.Builder, index uint32) { + builder.PrependUint32Slot(0, index, 0) +} +func LogAddType(builder *flatbuffers.Builder, type_ LogType) { + builder.PrependInt8Slot(1, int8(type_), 0) +} +func LogAddLog(builder *flatbuffers.Builder, log flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(log), 0) +} +func LogEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/common/testbuddy/LogType.go b/pkg/fbs/common/testbuddy/LogType.go new file mode 100644 index 0000000..68f3c64 --- /dev/null +++ b/pkg/fbs/common/testbuddy/LogType.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package testbuddy + +import "strconv" + +type LogType int8 + +const ( + LogTypeLog LogType = 0 + LogTypeWarning LogType = 1 + LogTypeError LogType = 2 +) + +var EnumNamesLogType = map[LogType]string{ + LogTypeLog: "Log", + LogTypeWarning: "Warning", + LogTypeError: "Error", +} + +var EnumValuesLogType = map[string]LogType{ + "Log": LogTypeLog, + "Warning": LogTypeWarning, + "Error": LogTypeError, +} + +func (v LogType) String() string { + if s, ok := EnumNamesLogType[v]; ok { + return s + } + return "LogType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/testbuddy/TestResult.go b/pkg/fbs/common/testbuddy/TestResult.go new file mode 100644 index 0000000..d7acc01 --- /dev/null +++ b/pkg/fbs/common/testbuddy/TestResult.go @@ -0,0 +1,192 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package testbuddy + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TestResultT struct { + NumWarnings int32 + NumErrors int32 + Log []*LogT + Data []*DataT +} + +func (t *TestResultT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + logOffset := flatbuffers.UOffsetT(0) + if t.Log != nil { + logLength := len(t.Log) + logOffsets := make([]flatbuffers.UOffsetT, logLength) + for j := 0; j < logLength; j++ { + logOffsets[j] = t.Log[j].Pack(builder) + } + TestResultStartLogVector(builder, logLength) + for j := logLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(logOffsets[j]) + } + logOffset = builder.EndVector(logLength) + } + dataOffset := flatbuffers.UOffsetT(0) + if t.Data != nil { + dataLength := len(t.Data) + dataOffsets := make([]flatbuffers.UOffsetT, dataLength) + for j := 0; j < dataLength; j++ { + dataOffsets[j] = t.Data[j].Pack(builder) + } + TestResultStartDataVector(builder, dataLength) + for j := dataLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(dataOffsets[j]) + } + dataOffset = builder.EndVector(dataLength) + } + TestResultStart(builder) + TestResultAddNumWarnings(builder, t.NumWarnings) + TestResultAddNumErrors(builder, t.NumErrors) + TestResultAddLog(builder, logOffset) + TestResultAddData(builder, dataOffset) + return TestResultEnd(builder) +} + +func (rcv *TestResult) UnPackTo(t *TestResultT) { + t.NumWarnings = rcv.NumWarnings() + t.NumErrors = rcv.NumErrors() + logLength := rcv.LogLength() + t.Log = make([]*LogT, logLength) + for j := 0; j < logLength; j++ { + x := Log{} + rcv.Log(&x, j) + t.Log[j] = x.UnPack() + } + dataLength := rcv.DataLength() + t.Data = make([]*DataT, dataLength) + for j := 0; j < dataLength; j++ { + x := Data{} + rcv.Data(&x, j) + t.Data[j] = x.UnPack() + } +} + +func (rcv *TestResult) UnPack() *TestResultT { + if rcv == nil { return nil } + t := &TestResultT{} + rcv.UnPackTo(t) + return t +} + +type TestResult struct { + _tab flatbuffers.Table +} + +func GetRootAsTestResult(buf []byte, offset flatbuffers.UOffsetT) *TestResult { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TestResult{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTestResult(buf []byte, offset flatbuffers.UOffsetT) *TestResult { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TestResult{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TestResult) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TestResult) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TestResult) NumWarnings() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TestResult) MutateNumWarnings(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +func (rcv *TestResult) NumErrors() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TestResult) MutateNumErrors(n int32) bool { + return rcv._tab.MutateInt32Slot(6, n) +} + +func (rcv *TestResult) Log(obj *Log, 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 *TestResult) LogLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *TestResult) Data(obj *Data, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + 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 *TestResult) DataLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func TestResultStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func TestResultAddNumWarnings(builder *flatbuffers.Builder, numWarnings int32) { + builder.PrependInt32Slot(0, numWarnings, 0) +} +func TestResultAddNumErrors(builder *flatbuffers.Builder, numErrors int32) { + builder.PrependInt32Slot(1, numErrors, 0) +} +func TestResultAddLog(builder *flatbuffers.Builder, log flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(log), 0) +} +func TestResultStartLogVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TestResultAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(data), 0) +} +func TestResultStartDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TestResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionAvoidance.go b/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionAvoidance.go new file mode 100644 index 0000000..7858063 --- /dev/null +++ b/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionAvoidance.go @@ -0,0 +1,114 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the collision avoidance function +type CollisionAvoidanceT struct { + AxsName string + Enable bool + Params *GetCollisionGuardStateParamsT +} + +func (t *CollisionAvoidanceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsNameOffset := builder.CreateString(t.AxsName) + paramsOffset := t.Params.Pack(builder) + CollisionAvoidanceStart(builder) + CollisionAvoidanceAddAxsName(builder, axsNameOffset) + CollisionAvoidanceAddEnable(builder, t.Enable) + CollisionAvoidanceAddParams(builder, paramsOffset) + return CollisionAvoidanceEnd(builder) +} + +func (rcv *CollisionAvoidance) UnPackTo(t *CollisionAvoidanceT) { + t.AxsName = string(rcv.AxsName()) + t.Enable = rcv.Enable() + t.Params = rcv.Params(nil).UnPack() +} + +func (rcv *CollisionAvoidance) UnPack() *CollisionAvoidanceT { + if rcv == nil { return nil } + t := &CollisionAvoidanceT{} + rcv.UnPackTo(t) + return t +} + +type CollisionAvoidance struct { + _tab flatbuffers.Table +} + +func GetRootAsCollisionAvoidance(buf []byte, offset flatbuffers.UOffsetT) *CollisionAvoidance { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CollisionAvoidance{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCollisionAvoidance(buf []byte, offset flatbuffers.UOffsetT) *CollisionAvoidance { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CollisionAvoidance{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CollisionAvoidance) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CollisionAvoidance) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CollisionAvoidance) AxsName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CollisionAvoidance) Enable() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *CollisionAvoidance) MutateEnable(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *CollisionAvoidance) Params(obj *GetCollisionGuardStateParams) *GetCollisionGuardStateParams { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(GetCollisionGuardStateParams) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func CollisionAvoidanceStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CollisionAvoidanceAddAxsName(builder *flatbuffers.Builder, axsName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axsName), 0) +} +func CollisionAvoidanceAddEnable(builder *flatbuffers.Builder, enable bool) { + builder.PrependBoolSlot(1, enable, false) +} +func CollisionAvoidanceAddParams(builder *flatbuffers.Builder, params flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(params), 0) +} +func CollisionAvoidanceEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionGuardState.go b/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionGuardState.go new file mode 100644 index 0000000..9ad3f63 --- /dev/null +++ b/pkg/fbs/motion/collision_avoidance/fbtypes/CollisionGuardState.go @@ -0,0 +1,45 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Possible collision guard states +type CollisionGuardState int8 + +const ( + CollisionGuardStateMONITORING CollisionGuardState = 0 + CollisionGuardStateTARGETS_CROSSING CollisionGuardState = 1 + CollisionGuardStateSYNC_ADVICE CollisionGuardState = 2 + CollisionGuardStateSLOWDOWN_ADVICE CollisionGuardState = 3 + CollisionGuardStateSTOP CollisionGuardState = 4 + CollisionGuardStateEMERGENCY_STOP CollisionGuardState = 5 + CollisionGuardStateUNKNOWN CollisionGuardState = 6 +) + +var EnumNamesCollisionGuardState = map[CollisionGuardState]string{ + CollisionGuardStateMONITORING: "MONITORING", + CollisionGuardStateTARGETS_CROSSING: "TARGETS_CROSSING", + CollisionGuardStateSYNC_ADVICE: "SYNC_ADVICE", + CollisionGuardStateSLOWDOWN_ADVICE: "SLOWDOWN_ADVICE", + CollisionGuardStateSTOP: "STOP", + CollisionGuardStateEMERGENCY_STOP: "EMERGENCY_STOP", + CollisionGuardStateUNKNOWN: "UNKNOWN", +} + +var EnumValuesCollisionGuardState = map[string]CollisionGuardState{ + "MONITORING": CollisionGuardStateMONITORING, + "TARGETS_CROSSING": CollisionGuardStateTARGETS_CROSSING, + "SYNC_ADVICE": CollisionGuardStateSYNC_ADVICE, + "SLOWDOWN_ADVICE": CollisionGuardStateSLOWDOWN_ADVICE, + "STOP": CollisionGuardStateSTOP, + "EMERGENCY_STOP": CollisionGuardStateEMERGENCY_STOP, + "UNKNOWN": CollisionGuardStateUNKNOWN, +} + +func (v CollisionGuardState) String() string { + if s, ok := EnumNamesCollisionGuardState[v]; ok { + return s + } + return "CollisionGuardState(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/collision_avoidance/fbtypes/GetCollisionGuardStateParams.go b/pkg/fbs/motion/collision_avoidance/fbtypes/GetCollisionGuardStateParams.go new file mode 100644 index 0000000..bda0e34 --- /dev/null +++ b/pkg/fbs/motion/collision_avoidance/fbtypes/GetCollisionGuardStateParams.go @@ -0,0 +1,277 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the get collision guard state function +type GetCollisionGuardStateParamsT struct { + EmergencyDist float64 + MinDist float64 + SlowDownDist float64 + SyncDist float64 + ActPos float64 + TargetPos float64 + ActBrakingDist float64 + NeighborPos float64 + NeighborTargetPos float64 + NeighborBrakingDist float64 + HysteresisDist float64 + PrevState CollisionGuardState +} + +func (t *GetCollisionGuardStateParamsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + GetCollisionGuardStateParamsStart(builder) + GetCollisionGuardStateParamsAddEmergencyDist(builder, t.EmergencyDist) + GetCollisionGuardStateParamsAddMinDist(builder, t.MinDist) + GetCollisionGuardStateParamsAddSlowDownDist(builder, t.SlowDownDist) + GetCollisionGuardStateParamsAddSyncDist(builder, t.SyncDist) + GetCollisionGuardStateParamsAddActPos(builder, t.ActPos) + GetCollisionGuardStateParamsAddTargetPos(builder, t.TargetPos) + GetCollisionGuardStateParamsAddActBrakingDist(builder, t.ActBrakingDist) + GetCollisionGuardStateParamsAddNeighborPos(builder, t.NeighborPos) + GetCollisionGuardStateParamsAddNeighborTargetPos(builder, t.NeighborTargetPos) + GetCollisionGuardStateParamsAddNeighborBrakingDist(builder, t.NeighborBrakingDist) + GetCollisionGuardStateParamsAddHysteresisDist(builder, t.HysteresisDist) + GetCollisionGuardStateParamsAddPrevState(builder, t.PrevState) + return GetCollisionGuardStateParamsEnd(builder) +} + +func (rcv *GetCollisionGuardStateParams) UnPackTo(t *GetCollisionGuardStateParamsT) { + t.EmergencyDist = rcv.EmergencyDist() + t.MinDist = rcv.MinDist() + t.SlowDownDist = rcv.SlowDownDist() + t.SyncDist = rcv.SyncDist() + t.ActPos = rcv.ActPos() + t.TargetPos = rcv.TargetPos() + t.ActBrakingDist = rcv.ActBrakingDist() + t.NeighborPos = rcv.NeighborPos() + t.NeighborTargetPos = rcv.NeighborTargetPos() + t.NeighborBrakingDist = rcv.NeighborBrakingDist() + t.HysteresisDist = rcv.HysteresisDist() + t.PrevState = rcv.PrevState() +} + +func (rcv *GetCollisionGuardStateParams) UnPack() *GetCollisionGuardStateParamsT { + if rcv == nil { return nil } + t := &GetCollisionGuardStateParamsT{} + rcv.UnPackTo(t) + return t +} + +type GetCollisionGuardStateParams struct { + _tab flatbuffers.Table +} + +func GetRootAsGetCollisionGuardStateParams(buf []byte, offset flatbuffers.UOffsetT) *GetCollisionGuardStateParams { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &GetCollisionGuardStateParams{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsGetCollisionGuardStateParams(buf []byte, offset flatbuffers.UOffsetT) *GetCollisionGuardStateParams { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &GetCollisionGuardStateParams{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *GetCollisionGuardStateParams) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *GetCollisionGuardStateParams) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *GetCollisionGuardStateParams) EmergencyDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateEmergencyDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *GetCollisionGuardStateParams) MinDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateMinDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *GetCollisionGuardStateParams) SlowDownDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateSlowDownDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *GetCollisionGuardStateParams) SyncDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateSyncDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func (rcv *GetCollisionGuardStateParams) ActPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateActPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(12, n) +} + +func (rcv *GetCollisionGuardStateParams) TargetPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateTargetPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(14, n) +} + +func (rcv *GetCollisionGuardStateParams) ActBrakingDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateActBrakingDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(16, n) +} + +func (rcv *GetCollisionGuardStateParams) NeighborPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateNeighborPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(18, n) +} + +func (rcv *GetCollisionGuardStateParams) NeighborTargetPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateNeighborTargetPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(20, n) +} + +func (rcv *GetCollisionGuardStateParams) NeighborBrakingDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateNeighborBrakingDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(22, n) +} + +func (rcv *GetCollisionGuardStateParams) HysteresisDist() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *GetCollisionGuardStateParams) MutateHysteresisDist(n float64) bool { + return rcv._tab.MutateFloat64Slot(24, n) +} + +func (rcv *GetCollisionGuardStateParams) PrevState() CollisionGuardState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return CollisionGuardState(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *GetCollisionGuardStateParams) MutatePrevState(n CollisionGuardState) bool { + return rcv._tab.MutateInt8Slot(26, int8(n)) +} + +func GetCollisionGuardStateParamsStart(builder *flatbuffers.Builder) { + builder.StartObject(12) +} +func GetCollisionGuardStateParamsAddEmergencyDist(builder *flatbuffers.Builder, emergencyDist float64) { + builder.PrependFloat64Slot(0, emergencyDist, 0.0) +} +func GetCollisionGuardStateParamsAddMinDist(builder *flatbuffers.Builder, minDist float64) { + builder.PrependFloat64Slot(1, minDist, 0.0) +} +func GetCollisionGuardStateParamsAddSlowDownDist(builder *flatbuffers.Builder, slowDownDist float64) { + builder.PrependFloat64Slot(2, slowDownDist, 0.0) +} +func GetCollisionGuardStateParamsAddSyncDist(builder *flatbuffers.Builder, syncDist float64) { + builder.PrependFloat64Slot(3, syncDist, 0.0) +} +func GetCollisionGuardStateParamsAddActPos(builder *flatbuffers.Builder, actPos float64) { + builder.PrependFloat64Slot(4, actPos, 0.0) +} +func GetCollisionGuardStateParamsAddTargetPos(builder *flatbuffers.Builder, targetPos float64) { + builder.PrependFloat64Slot(5, targetPos, 0.0) +} +func GetCollisionGuardStateParamsAddActBrakingDist(builder *flatbuffers.Builder, actBrakingDist float64) { + builder.PrependFloat64Slot(6, actBrakingDist, 0.0) +} +func GetCollisionGuardStateParamsAddNeighborPos(builder *flatbuffers.Builder, neighborPos float64) { + builder.PrependFloat64Slot(7, neighborPos, 0.0) +} +func GetCollisionGuardStateParamsAddNeighborTargetPos(builder *flatbuffers.Builder, neighborTargetPos float64) { + builder.PrependFloat64Slot(8, neighborTargetPos, 0.0) +} +func GetCollisionGuardStateParamsAddNeighborBrakingDist(builder *flatbuffers.Builder, neighborBrakingDist float64) { + builder.PrependFloat64Slot(9, neighborBrakingDist, 0.0) +} +func GetCollisionGuardStateParamsAddHysteresisDist(builder *flatbuffers.Builder, hysteresisDist float64) { + builder.PrependFloat64Slot(10, hysteresisDist, 0.0) +} +func GetCollisionGuardStateParamsAddPrevState(builder *flatbuffers.Builder, prevState CollisionGuardState) { + builder.PrependInt8Slot(11, int8(prevState), 0) +} +func GetCollisionGuardStateParamsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AcquiredLicenses.go b/pkg/fbs/motion/core/fbtypes/AcquiredLicenses.go index 3209c89..aca60e2 100644 --- a/pkg/fbs/motion/core/fbtypes/AcquiredLicenses.go +++ b/pkg/fbs/motion/core/fbtypes/AcquiredLicenses.go @@ -7,6 +7,47 @@ import ( ) /// all currently acquired licenses (motion must be in state RUNNING) +type AcquiredLicensesT struct { + Licenses []*SingleLicenseT +} + +func (t *AcquiredLicensesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + licensesOffset := flatbuffers.UOffsetT(0) + if t.Licenses != nil { + licensesLength := len(t.Licenses) + licensesOffsets := make([]flatbuffers.UOffsetT, licensesLength) + for j := 0; j < licensesLength; j++ { + licensesOffsets[j] = t.Licenses[j].Pack(builder) + } + AcquiredLicensesStartLicensesVector(builder, licensesLength) + for j := licensesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(licensesOffsets[j]) + } + licensesOffset = builder.EndVector(licensesLength) + } + AcquiredLicensesStart(builder) + AcquiredLicensesAddLicenses(builder, licensesOffset) + return AcquiredLicensesEnd(builder) +} + +func (rcv *AcquiredLicenses) UnPackTo(t *AcquiredLicensesT) { + licensesLength := rcv.LicensesLength() + t.Licenses = make([]*SingleLicenseT, licensesLength) + for j := 0; j < licensesLength; j++ { + x := SingleLicense{} + rcv.Licenses(&x, j) + t.Licenses[j] = x.UnPack() + } +} + +func (rcv *AcquiredLicenses) UnPack() *AcquiredLicensesT { + if rcv == nil { return nil } + t := &AcquiredLicensesT{} + rcv.UnPackTo(t) + return t +} + type AcquiredLicenses struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsActualValues.go b/pkg/fbs/motion/core/fbtypes/AxsActualValues.go index 6ccc151..cd4b7f8 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsActualValues.go +++ b/pkg/fbs/motion/core/fbtypes/AxsActualValues.go @@ -7,6 +7,60 @@ import ( ) /// actual values from the drives +type AxsActualValuesT struct { + ActualPos float64 + ActualVel float64 + ActualAcc float64 + ActualTorque float64 + DistLeft float64 + ActualPosUnit string + ActualVelUnit string + ActualAccUnit string + ActualTorqueUnit string + DistLeftUnit string +} + +func (t *AxsActualValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + actualPosUnitOffset := builder.CreateString(t.ActualPosUnit) + actualVelUnitOffset := builder.CreateString(t.ActualVelUnit) + actualAccUnitOffset := builder.CreateString(t.ActualAccUnit) + actualTorqueUnitOffset := builder.CreateString(t.ActualTorqueUnit) + distLeftUnitOffset := builder.CreateString(t.DistLeftUnit) + AxsActualValuesStart(builder) + AxsActualValuesAddActualPos(builder, t.ActualPos) + AxsActualValuesAddActualVel(builder, t.ActualVel) + AxsActualValuesAddActualAcc(builder, t.ActualAcc) + AxsActualValuesAddActualTorque(builder, t.ActualTorque) + AxsActualValuesAddDistLeft(builder, t.DistLeft) + AxsActualValuesAddActualPosUnit(builder, actualPosUnitOffset) + AxsActualValuesAddActualVelUnit(builder, actualVelUnitOffset) + AxsActualValuesAddActualAccUnit(builder, actualAccUnitOffset) + AxsActualValuesAddActualTorqueUnit(builder, actualTorqueUnitOffset) + AxsActualValuesAddDistLeftUnit(builder, distLeftUnitOffset) + return AxsActualValuesEnd(builder) +} + +func (rcv *AxsActualValues) UnPackTo(t *AxsActualValuesT) { + t.ActualPos = rcv.ActualPos() + t.ActualVel = rcv.ActualVel() + t.ActualAcc = rcv.ActualAcc() + t.ActualTorque = rcv.ActualTorque() + t.DistLeft = rcv.DistLeft() + t.ActualPosUnit = string(rcv.ActualPosUnit()) + t.ActualVelUnit = string(rcv.ActualVelUnit()) + t.ActualAccUnit = string(rcv.ActualAccUnit()) + t.ActualTorqueUnit = string(rcv.ActualTorqueUnit()) + t.DistLeftUnit = string(rcv.DistLeftUnit()) +} + +func (rcv *AxsActualValues) UnPack() *AxsActualValuesT { + if rcv == nil { return nil } + t := &AxsActualValuesT{} + rcv.UnPackTo(t) + return t +} + type AxsActualValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsBrakingDistanceEx.go b/pkg/fbs/motion/core/fbtypes/AxsBrakingDistanceEx.go new file mode 100644 index 0000000..e8df19a --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsBrakingDistanceEx.go @@ -0,0 +1,172 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// axis braking distance +type AxsBrakingDistanceExT struct { + SelectedTypes []BrakingDistanceType + DistanceUnit string + Distance float64 + DistanceType BrakingDistanceType +} + +func (t *AxsBrakingDistanceExT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + selectedTypesOffset := flatbuffers.UOffsetT(0) + if t.SelectedTypes != nil { + selectedTypesLength := len(t.SelectedTypes) + AxsBrakingDistanceExStartSelectedTypesVector(builder, selectedTypesLength) + for j := selectedTypesLength - 1; j >= 0; j-- { + builder.PrependInt8(int8(t.SelectedTypes[j])) + } + selectedTypesOffset = builder.EndVector(selectedTypesLength) + } + distanceUnitOffset := builder.CreateString(t.DistanceUnit) + AxsBrakingDistanceExStart(builder) + AxsBrakingDistanceExAddSelectedTypes(builder, selectedTypesOffset) + AxsBrakingDistanceExAddDistanceUnit(builder, distanceUnitOffset) + AxsBrakingDistanceExAddDistance(builder, t.Distance) + AxsBrakingDistanceExAddDistanceType(builder, t.DistanceType) + return AxsBrakingDistanceExEnd(builder) +} + +func (rcv *AxsBrakingDistanceEx) UnPackTo(t *AxsBrakingDistanceExT) { + selectedTypesLength := rcv.SelectedTypesLength() + t.SelectedTypes = make([]BrakingDistanceType, selectedTypesLength) + for j := 0; j < selectedTypesLength; j++ { + t.SelectedTypes[j] = rcv.SelectedTypes(j) + } + t.DistanceUnit = string(rcv.DistanceUnit()) + t.Distance = rcv.Distance() + t.DistanceType = rcv.DistanceType() +} + +func (rcv *AxsBrakingDistanceEx) UnPack() *AxsBrakingDistanceExT { + if rcv == nil { return nil } + t := &AxsBrakingDistanceExT{} + rcv.UnPackTo(t) + return t +} + +type AxsBrakingDistanceEx struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsBrakingDistanceEx(buf []byte, offset flatbuffers.UOffsetT) *AxsBrakingDistanceEx { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsBrakingDistanceEx{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsBrakingDistanceEx(buf []byte, offset flatbuffers.UOffsetT) *AxsBrakingDistanceEx { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsBrakingDistanceEx{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsBrakingDistanceEx) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsBrakingDistanceEx) Table() flatbuffers.Table { + return rcv._tab +} + +/// selected braking distance types in the calculation +/// default value is [SOFT_STOP, ESTOP] +func (rcv *AxsBrakingDistanceEx) SelectedTypes(j int) BrakingDistanceType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return BrakingDistanceType(rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))) + } + return 0 +} + +func (rcv *AxsBrakingDistanceEx) SelectedTypesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// selected braking distance types in the calculation +/// default value is [SOFT_STOP, ESTOP] +func (rcv *AxsBrakingDistanceEx) MutateSelectedTypes(j int, n BrakingDistanceType) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), int8(n)) + } + return false +} + +/// unit in which braking distance value should be calculated +/// default value is the configured unit for the axis +func (rcv *AxsBrakingDistanceEx) DistanceUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit in which braking distance value should be calculated +/// default value is the configured unit for the axis +/// calculated braking distance +func (rcv *AxsBrakingDistanceEx) Distance() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// calculated braking distance +func (rcv *AxsBrakingDistanceEx) MutateDistance(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +/// the distance type of the calculated braking distance +func (rcv *AxsBrakingDistanceEx) DistanceType() BrakingDistanceType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return BrakingDistanceType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// the distance type of the calculated braking distance +func (rcv *AxsBrakingDistanceEx) MutateDistanceType(n BrakingDistanceType) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + +func AxsBrakingDistanceExStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsBrakingDistanceExAddSelectedTypes(builder *flatbuffers.Builder, selectedTypes flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(selectedTypes), 0) +} +func AxsBrakingDistanceExStartSelectedTypesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func AxsBrakingDistanceExAddDistanceUnit(builder *flatbuffers.Builder, distanceUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(distanceUnit), 0) +} +func AxsBrakingDistanceExAddDistance(builder *flatbuffers.Builder, distance float64) { + builder.PrependFloat64Slot(2, distance, 0.0) +} +func AxsBrakingDistanceExAddDistanceType(builder *flatbuffers.Builder, distanceType BrakingDistanceType) { + builder.PrependInt8Slot(3, int8(distanceType), 0) +} +func AxsBrakingDistanceExEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfg.go b/pkg/fbs/motion/core/fbtypes/AxsCfg.go index 7b4b547..520ca40 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfg.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfg.go @@ -7,6 +7,61 @@ import ( ) /// complete configuration of a single axis +type AxsCfgT struct { + ObjectType string + AxisProfileName string + Limits *AxsCfgLimitsT + Functions *AxsCfgFunctionsT + Properties *AxsCfgPropertiesT + Units *UnitCfgObjT + KinProperties *AxsCfgKinPropertiesT + DevErrReaction *AxsCfgDeviceErrorReactionT + RtInputs *RTInputsCfgT +} + +func (t *AxsCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objectTypeOffset := builder.CreateString(t.ObjectType) + axisProfileNameOffset := builder.CreateString(t.AxisProfileName) + limitsOffset := t.Limits.Pack(builder) + functionsOffset := t.Functions.Pack(builder) + propertiesOffset := t.Properties.Pack(builder) + unitsOffset := t.Units.Pack(builder) + kinPropertiesOffset := t.KinProperties.Pack(builder) + devErrReactionOffset := t.DevErrReaction.Pack(builder) + rtInputsOffset := t.RtInputs.Pack(builder) + AxsCfgStart(builder) + AxsCfgAddObjectType(builder, objectTypeOffset) + AxsCfgAddAxisProfileName(builder, axisProfileNameOffset) + AxsCfgAddLimits(builder, limitsOffset) + AxsCfgAddFunctions(builder, functionsOffset) + AxsCfgAddProperties(builder, propertiesOffset) + AxsCfgAddUnits(builder, unitsOffset) + AxsCfgAddKinProperties(builder, kinPropertiesOffset) + AxsCfgAddDevErrReaction(builder, devErrReactionOffset) + AxsCfgAddRtInputs(builder, rtInputsOffset) + return AxsCfgEnd(builder) +} + +func (rcv *AxsCfg) UnPackTo(t *AxsCfgT) { + t.ObjectType = string(rcv.ObjectType()) + t.AxisProfileName = string(rcv.AxisProfileName()) + t.Limits = rcv.Limits(nil).UnPack() + t.Functions = rcv.Functions(nil).UnPack() + t.Properties = rcv.Properties(nil).UnPack() + t.Units = rcv.Units(nil).UnPack() + t.KinProperties = rcv.KinProperties(nil).UnPack() + t.DevErrReaction = rcv.DevErrReaction(nil).UnPack() + t.RtInputs = rcv.RtInputs(nil).UnPack() +} + +func (rcv *AxsCfg) UnPack() *AxsCfgT { + if rcv == nil { return nil } + t := &AxsCfgT{} + rcv.UnPackTo(t) + return t +} + type AxsCfg struct { _tab flatbuffers.Table } @@ -144,8 +199,23 @@ func (rcv *AxsCfg) DevErrReaction(obj *AxsCfgDeviceErrorReaction) *AxsCfgDeviceE } /// device error reation settings +/// configuration of the real-time inputs of the axis +func (rcv *AxsCfg) RtInputs(obj *RTInputsCfg) *RTInputsCfg { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(RTInputsCfg) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of the real-time inputs of the axis func AxsCfgStart(builder *flatbuffers.Builder) { - builder.StartObject(8) + builder.StartObject(9) } func AxsCfgAddObjectType(builder *flatbuffers.Builder, objectType flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objectType), 0) @@ -171,6 +241,9 @@ func AxsCfgAddKinProperties(builder *flatbuffers.Builder, kinProperties flatbuff func AxsCfgAddDevErrReaction(builder *flatbuffers.Builder, devErrReaction flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(devErrReaction), 0) } +func AxsCfgAddRtInputs(builder *flatbuffers.Builder, rtInputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(rtInputs), 0) +} func AxsCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgCoupling.go b/pkg/fbs/motion/core/fbtypes/AxsCfgCoupling.go index 4e4f0ec..5d2e96b 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgCoupling.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgCoupling.go @@ -7,6 +7,29 @@ import ( ) /// configuration for coupling functions for a single axis +type AxsCfgCouplingT struct { + Gantry *AxsCfgGantryT +} + +func (t *AxsCfgCouplingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + gantryOffset := t.Gantry.Pack(builder) + AxsCfgCouplingStart(builder) + AxsCfgCouplingAddGantry(builder, gantryOffset) + return AxsCfgCouplingEnd(builder) +} + +func (rcv *AxsCfgCoupling) UnPackTo(t *AxsCfgCouplingT) { + t.Gantry = rcv.Gantry(nil).UnPack() +} + +func (rcv *AxsCfgCoupling) UnPack() *AxsCfgCouplingT { + if rcv == nil { return nil } + t := &AxsCfgCouplingT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgCoupling struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go b/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go index 4f0c561..0c8c381 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go @@ -7,6 +7,33 @@ import ( ) /// configuration for reaction to device error +type AxsCfgDeviceErrorReactionT struct { + UserEstopLim *AxsCfgEstopDynamicLimitsT + EstopSettings *AxsCfgEstopSettingsT +} + +func (t *AxsCfgDeviceErrorReactionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + userEstopLimOffset := t.UserEstopLim.Pack(builder) + estopSettingsOffset := t.EstopSettings.Pack(builder) + AxsCfgDeviceErrorReactionStart(builder) + AxsCfgDeviceErrorReactionAddUserEstopLim(builder, userEstopLimOffset) + AxsCfgDeviceErrorReactionAddEstopSettings(builder, estopSettingsOffset) + return AxsCfgDeviceErrorReactionEnd(builder) +} + +func (rcv *AxsCfgDeviceErrorReaction) UnPackTo(t *AxsCfgDeviceErrorReactionT) { + t.UserEstopLim = rcv.UserEstopLim(nil).UnPack() + t.EstopSettings = rcv.EstopSettings(nil).UnPack() +} + +func (rcv *AxsCfgDeviceErrorReaction) UnPack() *AxsCfgDeviceErrorReactionT { + if rcv == nil { return nil } + t := &AxsCfgDeviceErrorReactionT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgDeviceErrorReaction struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgEstopDynamicLimits.go b/pkg/fbs/motion/core/fbtypes/AxsCfgEstopDynamicLimits.go index a8f0a2e..1caa7b4 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgEstopDynamicLimits.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgEstopDynamicLimits.go @@ -7,6 +7,39 @@ import ( ) /// configuration for E-Stop dynamic limitation +type AxsCfgEstopDynamicLimitsT struct { + Dec float64 + JrkDec float64 + DecUnit string + JrkDecUnit string +} + +func (t *AxsCfgEstopDynamicLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + decUnitOffset := builder.CreateString(t.DecUnit) + jrkDecUnitOffset := builder.CreateString(t.JrkDecUnit) + AxsCfgEstopDynamicLimitsStart(builder) + AxsCfgEstopDynamicLimitsAddDec(builder, t.Dec) + AxsCfgEstopDynamicLimitsAddJrkDec(builder, t.JrkDec) + AxsCfgEstopDynamicLimitsAddDecUnit(builder, decUnitOffset) + AxsCfgEstopDynamicLimitsAddJrkDecUnit(builder, jrkDecUnitOffset) + return AxsCfgEstopDynamicLimitsEnd(builder) +} + +func (rcv *AxsCfgEstopDynamicLimits) UnPackTo(t *AxsCfgEstopDynamicLimitsT) { + t.Dec = rcv.Dec() + t.JrkDec = rcv.JrkDec() + t.DecUnit = string(rcv.DecUnit()) + t.JrkDecUnit = string(rcv.JrkDecUnit()) +} + +func (rcv *AxsCfgEstopDynamicLimits) UnPack() *AxsCfgEstopDynamicLimitsT { + if rcv == nil { return nil } + t := &AxsCfgEstopDynamicLimitsT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgEstopDynamicLimits struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgEstopSettings.go b/pkg/fbs/motion/core/fbtypes/AxsCfgEstopSettings.go index 00e4d21..dbf97b7 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgEstopSettings.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgEstopSettings.go @@ -7,6 +7,43 @@ import ( ) /// configuration for axis estop to device error +type AxsCfgEstopSettingsT struct { + EstopToNoDevErr EstopType + EstopToNoDeviceInfo EstopType + EstopToDevLightErr EstopType + EstopToFieldbusErr EstopType + EstopToDevCriticalErr EstopType + EstopToDevFatalErr EstopType +} + +func (t *AxsCfgEstopSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCfgEstopSettingsStart(builder) + AxsCfgEstopSettingsAddEstopToNoDevErr(builder, t.EstopToNoDevErr) + AxsCfgEstopSettingsAddEstopToNoDeviceInfo(builder, t.EstopToNoDeviceInfo) + AxsCfgEstopSettingsAddEstopToDevLightErr(builder, t.EstopToDevLightErr) + AxsCfgEstopSettingsAddEstopToFieldbusErr(builder, t.EstopToFieldbusErr) + AxsCfgEstopSettingsAddEstopToDevCriticalErr(builder, t.EstopToDevCriticalErr) + AxsCfgEstopSettingsAddEstopToDevFatalErr(builder, t.EstopToDevFatalErr) + return AxsCfgEstopSettingsEnd(builder) +} + +func (rcv *AxsCfgEstopSettings) UnPackTo(t *AxsCfgEstopSettingsT) { + t.EstopToNoDevErr = rcv.EstopToNoDevErr() + t.EstopToNoDeviceInfo = rcv.EstopToNoDeviceInfo() + t.EstopToDevLightErr = rcv.EstopToDevLightErr() + t.EstopToFieldbusErr = rcv.EstopToFieldbusErr() + t.EstopToDevCriticalErr = rcv.EstopToDevCriticalErr() + t.EstopToDevFatalErr = rcv.EstopToDevFatalErr() +} + +func (rcv *AxsCfgEstopSettings) UnPack() *AxsCfgEstopSettingsT { + if rcv == nil { return nil } + t := &AxsCfgEstopSettingsT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgEstopSettings struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go b/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go index afb825b..0e8d20e 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go @@ -4,9 +4,56 @@ package fbtypes import ( flatbuffers "github.com/google/flatbuffers/go" + + motion__sync__fbtypes "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/motion/sync/fbtypes" ) /// configuration for specific functions of this axis +type AxsCfgFunctionsT struct { + Coupling *AxsCfgCouplingT + CalculationPipelines []*motion__sync__fbtypes.CalcPipelineCfgT +} + +func (t *AxsCfgFunctionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + couplingOffset := t.Coupling.Pack(builder) + calculationPipelinesOffset := flatbuffers.UOffsetT(0) + if t.CalculationPipelines != nil { + calculationPipelinesLength := len(t.CalculationPipelines) + calculationPipelinesOffsets := make([]flatbuffers.UOffsetT, calculationPipelinesLength) + for j := 0; j < calculationPipelinesLength; j++ { + calculationPipelinesOffsets[j] = t.CalculationPipelines[j].Pack(builder) + } + AxsCfgFunctionsStartCalculationPipelinesVector(builder, calculationPipelinesLength) + for j := calculationPipelinesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(calculationPipelinesOffsets[j]) + } + calculationPipelinesOffset = builder.EndVector(calculationPipelinesLength) + } + AxsCfgFunctionsStart(builder) + AxsCfgFunctionsAddCoupling(builder, couplingOffset) + AxsCfgFunctionsAddCalculationPipelines(builder, calculationPipelinesOffset) + return AxsCfgFunctionsEnd(builder) +} + +func (rcv *AxsCfgFunctions) UnPackTo(t *AxsCfgFunctionsT) { + t.Coupling = rcv.Coupling(nil).UnPack() + calculationPipelinesLength := rcv.CalculationPipelinesLength() + t.CalculationPipelines = make([]*motion__sync__fbtypes.CalcPipelineCfgT, calculationPipelinesLength) + for j := 0; j < calculationPipelinesLength; j++ { + x := motion__sync__fbtypes.CalcPipelineCfg{} + rcv.CalculationPipelines(&x, j) + t.CalculationPipelines[j] = x.UnPack() + } +} + +func (rcv *AxsCfgFunctions) UnPack() *AxsCfgFunctionsT { + if rcv == nil { return nil } + t := &AxsCfgFunctionsT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgFunctions struct { _tab flatbuffers.Table } @@ -49,12 +96,40 @@ func (rcv *AxsCfgFunctions) Coupling(obj *AxsCfgCoupling) *AxsCfgCoupling { } /// configuration for coupling functions for a single axis +/// configuration for calculation pipelines for a single axis +func (rcv *AxsCfgFunctions) CalculationPipelines(obj *motion__sync__fbtypes.CalcPipelineCfg, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + 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 *AxsCfgFunctions) CalculationPipelinesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// configuration for calculation pipelines for a single axis func AxsCfgFunctionsStart(builder *flatbuffers.Builder) { - builder.StartObject(1) + builder.StartObject(2) } func AxsCfgFunctionsAddCoupling(builder *flatbuffers.Builder, coupling flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(coupling), 0) } +func AxsCfgFunctionsAddCalculationPipelines(builder *flatbuffers.Builder, calculationPipelines flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(calculationPipelines), 0) +} +func AxsCfgFunctionsStartCalculationPipelinesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} func AxsCfgFunctionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgGantry.go b/pkg/fbs/motion/core/fbtypes/AxsCfgGantry.go index 2d6f61a..681637f 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgGantry.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgGantry.go @@ -7,6 +7,34 @@ import ( ) /// configuration for gantry coupling function of a single axis +type AxsCfgGantryT struct { + IsMember bool + MoveAllowed bool + MultiBrakeDyn bool +} + +func (t *AxsCfgGantryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCfgGantryStart(builder) + AxsCfgGantryAddIsMember(builder, t.IsMember) + AxsCfgGantryAddMoveAllowed(builder, t.MoveAllowed) + AxsCfgGantryAddMultiBrakeDyn(builder, t.MultiBrakeDyn) + return AxsCfgGantryEnd(builder) +} + +func (rcv *AxsCfgGantry) UnPackTo(t *AxsCfgGantryT) { + t.IsMember = rcv.IsMember() + t.MoveAllowed = rcv.MoveAllowed() + t.MultiBrakeDyn = rcv.MultiBrakeDyn() +} + +func (rcv *AxsCfgGantry) UnPack() *AxsCfgGantryT { + if rcv == nil { return nil } + t := &AxsCfgGantryT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgGantry struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgKinProperties.go b/pkg/fbs/motion/core/fbtypes/AxsCfgKinProperties.go index 59f35d1..f7035e8 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgKinProperties.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgKinProperties.go @@ -7,6 +7,31 @@ import ( ) /// kinematic properties for axes +type AxsCfgKinPropertiesT struct { + AccReserve float64 + JrkReserve float64 +} + +func (t *AxsCfgKinPropertiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCfgKinPropertiesStart(builder) + AxsCfgKinPropertiesAddAccReserve(builder, t.AccReserve) + AxsCfgKinPropertiesAddJrkReserve(builder, t.JrkReserve) + return AxsCfgKinPropertiesEnd(builder) +} + +func (rcv *AxsCfgKinProperties) UnPackTo(t *AxsCfgKinPropertiesT) { + t.AccReserve = rcv.AccReserve() + t.JrkReserve = rcv.JrkReserve() +} + +func (rcv *AxsCfgKinProperties) UnPack() *AxsCfgKinPropertiesT { + if rcv == nil { return nil } + t := &AxsCfgKinPropertiesT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgKinProperties struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgLimits.go b/pkg/fbs/motion/core/fbtypes/AxsCfgLimits.go index b2097ca..d04469e 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgLimits.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgLimits.go @@ -7,6 +7,81 @@ import ( ) /// configured limits of a single axis +type AxsCfgLimitsT struct { + PosMin float64 + PosMax float64 + VelPos float64 + VelNeg float64 + Acc float64 + Dec float64 + JrkAcc float64 + JrkDec float64 + PosMinUnit string + PosMaxUnit string + VelPosUnit string + VelNegUnit string + AccUnit string + DecUnit string + JrkAccUnit string + JrkDecUnit string +} + +func (t *AxsCfgLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + posMinUnitOffset := builder.CreateString(t.PosMinUnit) + posMaxUnitOffset := builder.CreateString(t.PosMaxUnit) + velPosUnitOffset := builder.CreateString(t.VelPosUnit) + velNegUnitOffset := builder.CreateString(t.VelNegUnit) + accUnitOffset := builder.CreateString(t.AccUnit) + decUnitOffset := builder.CreateString(t.DecUnit) + jrkAccUnitOffset := builder.CreateString(t.JrkAccUnit) + jrkDecUnitOffset := builder.CreateString(t.JrkDecUnit) + AxsCfgLimitsStart(builder) + AxsCfgLimitsAddPosMin(builder, t.PosMin) + AxsCfgLimitsAddPosMax(builder, t.PosMax) + AxsCfgLimitsAddVelPos(builder, t.VelPos) + AxsCfgLimitsAddVelNeg(builder, t.VelNeg) + AxsCfgLimitsAddAcc(builder, t.Acc) + AxsCfgLimitsAddDec(builder, t.Dec) + AxsCfgLimitsAddJrkAcc(builder, t.JrkAcc) + AxsCfgLimitsAddJrkDec(builder, t.JrkDec) + AxsCfgLimitsAddPosMinUnit(builder, posMinUnitOffset) + AxsCfgLimitsAddPosMaxUnit(builder, posMaxUnitOffset) + AxsCfgLimitsAddVelPosUnit(builder, velPosUnitOffset) + AxsCfgLimitsAddVelNegUnit(builder, velNegUnitOffset) + AxsCfgLimitsAddAccUnit(builder, accUnitOffset) + AxsCfgLimitsAddDecUnit(builder, decUnitOffset) + AxsCfgLimitsAddJrkAccUnit(builder, jrkAccUnitOffset) + AxsCfgLimitsAddJrkDecUnit(builder, jrkDecUnitOffset) + return AxsCfgLimitsEnd(builder) +} + +func (rcv *AxsCfgLimits) UnPackTo(t *AxsCfgLimitsT) { + t.PosMin = rcv.PosMin() + t.PosMax = rcv.PosMax() + t.VelPos = rcv.VelPos() + t.VelNeg = rcv.VelNeg() + t.Acc = rcv.Acc() + t.Dec = rcv.Dec() + t.JrkAcc = rcv.JrkAcc() + t.JrkDec = rcv.JrkDec() + t.PosMinUnit = string(rcv.PosMinUnit()) + t.PosMaxUnit = string(rcv.PosMaxUnit()) + t.VelPosUnit = string(rcv.VelPosUnit()) + t.VelNegUnit = string(rcv.VelNegUnit()) + t.AccUnit = string(rcv.AccUnit()) + t.DecUnit = string(rcv.DecUnit()) + t.JrkAccUnit = string(rcv.JrkAccUnit()) + t.JrkDecUnit = string(rcv.JrkDecUnit()) +} + +func (rcv *AxsCfgLimits) UnPack() *AxsCfgLimitsT { + if rcv == nil { return nil } + t := &AxsCfgLimitsT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgLimits struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgProperties.go b/pkg/fbs/motion/core/fbtypes/AxsCfgProperties.go index aa1304c..906080f 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgProperties.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgProperties.go @@ -7,6 +7,39 @@ import ( ) /// common axis properties for a single axis +type AxsCfgPropertiesT struct { + AxsType string + Modulo bool + ModuloValue float64 + ModuloValueUnit string +} + +func (t *AxsCfgPropertiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsTypeOffset := builder.CreateString(t.AxsType) + moduloValueUnitOffset := builder.CreateString(t.ModuloValueUnit) + AxsCfgPropertiesStart(builder) + AxsCfgPropertiesAddAxsType(builder, axsTypeOffset) + AxsCfgPropertiesAddModulo(builder, t.Modulo) + AxsCfgPropertiesAddModuloValue(builder, t.ModuloValue) + AxsCfgPropertiesAddModuloValueUnit(builder, moduloValueUnitOffset) + return AxsCfgPropertiesEnd(builder) +} + +func (rcv *AxsCfgProperties) UnPackTo(t *AxsCfgPropertiesT) { + t.AxsType = string(rcv.AxsType()) + t.Modulo = rcv.Modulo() + t.ModuloValue = rcv.ModuloValue() + t.ModuloValueUnit = string(rcv.ModuloValueUnit()) +} + +func (rcv *AxsCfgProperties) UnPack() *AxsCfgPropertiesT { + if rcv == nil { return nil } + t := &AxsCfgPropertiesT{} + rcv.UnPackTo(t) + return t +} + type AxsCfgProperties struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdAbortData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdAbortData.go index 70a4faa..3fd4ff5 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdAbortData.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdAbortData.go @@ -7,6 +7,31 @@ import ( ) /// parameters of the axis abort command +type AxsCmdAbortDataT struct { + Dec float64 + JrkDec float64 +} + +func (t *AxsCmdAbortDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCmdAbortDataStart(builder) + AxsCmdAbortDataAddDec(builder, t.Dec) + AxsCmdAbortDataAddJrkDec(builder, t.JrkDec) + return AxsCmdAbortDataEnd(builder) +} + +func (rcv *AxsCmdAbortData) UnPackTo(t *AxsCmdAbortDataT) { + t.Dec = rcv.Dec() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *AxsCmdAbortData) UnPack() *AxsCmdAbortDataT { + if rcv == nil { return nil } + t := &AxsCmdAbortDataT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdAbortData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdAddToGantryData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdAddToGantryData.go index d194510..1a01153 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdAddToGantryData.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdAddToGantryData.go @@ -7,6 +7,32 @@ import ( ) /// parameters of the axis command add-to-gantry +type AxsCmdAddToGantryDataT struct { + MasterName string + Buffered bool +} + +func (t *AxsCmdAddToGantryDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterNameOffset := builder.CreateString(t.MasterName) + AxsCmdAddToGantryDataStart(builder) + AxsCmdAddToGantryDataAddMasterName(builder, masterNameOffset) + AxsCmdAddToGantryDataAddBuffered(builder, t.Buffered) + return AxsCmdAddToGantryDataEnd(builder) +} + +func (rcv *AxsCmdAddToGantryData) UnPackTo(t *AxsCmdAddToGantryDataT) { + t.MasterName = string(rcv.MasterName()) + t.Buffered = rcv.Buffered() +} + +func (rcv *AxsCmdAddToGantryData) UnPack() *AxsCmdAddToGantryDataT { + if rcv == nil { return nil } + t := &AxsCmdAddToGantryDataT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdAddToGantryData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdAddToKinData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdAddToKinData.go index 7f0d261..8511171 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdAddToKinData.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdAddToKinData.go @@ -7,6 +7,32 @@ import ( ) /// parameters of the axis command add-to-kin +type AxsCmdAddToKinDataT struct { + KinName string + Buffered bool +} + +func (t *AxsCmdAddToKinDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + kinNameOffset := builder.CreateString(t.KinName) + AxsCmdAddToKinDataStart(builder) + AxsCmdAddToKinDataAddKinName(builder, kinNameOffset) + AxsCmdAddToKinDataAddBuffered(builder, t.Buffered) + return AxsCmdAddToKinDataEnd(builder) +} + +func (rcv *AxsCmdAddToKinData) UnPackTo(t *AxsCmdAddToKinDataT) { + t.KinName = string(rcv.KinName()) + t.Buffered = rcv.Buffered() +} + +func (rcv *AxsCmdAddToKinData) UnPack() *AxsCmdAddToKinDataT { + if rcv == nil { return nil } + t := &AxsCmdAddToKinDataT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdAddToKinData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdJogData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdJogData.go index 26f19c7..bb0055f 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdJogData.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdJogData.go @@ -7,6 +7,36 @@ import ( ) /// parameters of the axis jog commands +type AxsCmdJogDataT struct { + JogDir string + JogIncrement float64 + Lim *DynamicLimitsT +} + +func (t *AxsCmdJogDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + jogDirOffset := builder.CreateString(t.JogDir) + limOffset := t.Lim.Pack(builder) + AxsCmdJogDataStart(builder) + AxsCmdJogDataAddJogDir(builder, jogDirOffset) + AxsCmdJogDataAddJogIncrement(builder, t.JogIncrement) + AxsCmdJogDataAddLim(builder, limOffset) + return AxsCmdJogDataEnd(builder) +} + +func (rcv *AxsCmdJogData) UnPackTo(t *AxsCmdJogDataT) { + t.JogDir = string(rcv.JogDir()) + t.JogIncrement = rcv.JogIncrement() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *AxsCmdJogData) UnPack() *AxsCmdJogDataT { + if rcv == nil { return nil } + t := &AxsCmdJogDataT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdJogData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdPosData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdPosData.go index 355b888..1933af4 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdPosData.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdPosData.go @@ -7,6 +7,35 @@ import ( ) /// parameters of the axis position commands +type AxsCmdPosDataT struct { + AxsPos float64 + Buffered bool + Lim *DynamicLimitsT +} + +func (t *AxsCmdPosDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + limOffset := t.Lim.Pack(builder) + AxsCmdPosDataStart(builder) + AxsCmdPosDataAddAxsPos(builder, t.AxsPos) + AxsCmdPosDataAddBuffered(builder, t.Buffered) + AxsCmdPosDataAddLim(builder, limOffset) + return AxsCmdPosDataEnd(builder) +} + +func (rcv *AxsCmdPosData) UnPackTo(t *AxsCmdPosDataT) { + t.AxsPos = rcv.AxsPos() + t.Buffered = rcv.Buffered() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *AxsCmdPosData) UnPack() *AxsCmdPosDataT { + if rcv == nil { return nil } + t := &AxsCmdPosDataT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdPosData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdValues.go b/pkg/fbs/motion/core/fbtypes/AxsCmdValues.go index f359ced..0f6e9d1 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCmdValues.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdValues.go @@ -7,6 +7,57 @@ import ( ) /// parameters and data of the active command +type AxsCmdValuesT struct { + TargetPos float64 + TargetVel float64 + TargetTrq float64 + Lim *DynamicLimitsStateT + CmdId uint64 + Src *CmdSourceT + TargetPosUnit string + TargetVelUnit string + TargetTrqUnit string +} + +func (t *AxsCmdValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + limOffset := t.Lim.Pack(builder) + srcOffset := t.Src.Pack(builder) + targetPosUnitOffset := builder.CreateString(t.TargetPosUnit) + targetVelUnitOffset := builder.CreateString(t.TargetVelUnit) + targetTrqUnitOffset := builder.CreateString(t.TargetTrqUnit) + AxsCmdValuesStart(builder) + AxsCmdValuesAddTargetPos(builder, t.TargetPos) + AxsCmdValuesAddTargetVel(builder, t.TargetVel) + AxsCmdValuesAddTargetTrq(builder, t.TargetTrq) + AxsCmdValuesAddLim(builder, limOffset) + AxsCmdValuesAddCmdId(builder, t.CmdId) + AxsCmdValuesAddSrc(builder, srcOffset) + AxsCmdValuesAddTargetPosUnit(builder, targetPosUnitOffset) + AxsCmdValuesAddTargetVelUnit(builder, targetVelUnitOffset) + AxsCmdValuesAddTargetTrqUnit(builder, targetTrqUnitOffset) + return AxsCmdValuesEnd(builder) +} + +func (rcv *AxsCmdValues) UnPackTo(t *AxsCmdValuesT) { + t.TargetPos = rcv.TargetPos() + t.TargetVel = rcv.TargetVel() + t.TargetTrq = rcv.TargetTrq() + t.Lim = rcv.Lim(nil).UnPack() + t.CmdId = rcv.CmdId() + t.Src = rcv.Src(nil).UnPack() + t.TargetPosUnit = string(rcv.TargetPosUnit()) + t.TargetVelUnit = string(rcv.TargetVelUnit()) + t.TargetTrqUnit = string(rcv.TargetTrqUnit()) +} + +func (rcv *AxsCmdValues) UnPack() *AxsCmdValuesT { + if rcv == nil { return nil } + t := &AxsCmdValuesT{} + rcv.UnPackTo(t) + return t +} + type AxsCmdValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdVelData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdVelData.go new file mode 100644 index 0000000..2b00e8c --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdVelData.go @@ -0,0 +1,143 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis velocity command +type AxsCmdVelDataT struct { + AxsVel float64 + DriveVelMode bool + Buffered bool + Lim *DynamicLimitsT +} + +func (t *AxsCmdVelDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + limOffset := t.Lim.Pack(builder) + AxsCmdVelDataStart(builder) + AxsCmdVelDataAddAxsVel(builder, t.AxsVel) + AxsCmdVelDataAddDriveVelMode(builder, t.DriveVelMode) + AxsCmdVelDataAddBuffered(builder, t.Buffered) + AxsCmdVelDataAddLim(builder, limOffset) + return AxsCmdVelDataEnd(builder) +} + +func (rcv *AxsCmdVelData) UnPackTo(t *AxsCmdVelDataT) { + t.AxsVel = rcv.AxsVel() + t.DriveVelMode = rcv.DriveVelMode() + t.Buffered = rcv.Buffered() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *AxsCmdVelData) UnPack() *AxsCmdVelDataT { + if rcv == nil { return nil } + t := &AxsCmdVelDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdVelData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdVelData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdVelData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdVelData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdVelData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdVelData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdVelData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdVelData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdVelData) Table() flatbuffers.Table { + return rcv._tab +} + +/// commanded target velocity (can be negative) +func (rcv *AxsCmdVelData) AxsVel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target velocity (can be negative) +func (rcv *AxsCmdVelData) MutateAxsVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// should this command switch/stay the drive to velocity mode (or switch/stay to position mode)? +func (rcv *AxsCmdVelData) DriveVelMode() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// should this command switch/stay the drive to velocity mode (or switch/stay to position mode)? +func (rcv *AxsCmdVelData) MutateDriveVelMode(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +/// should this be a buffered command? +func (rcv *AxsCmdVelData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// should this be a buffered command? +func (rcv *AxsCmdVelData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +/// dynamic limits for the motion of this command +func (rcv *AxsCmdVelData) Lim(obj *DynamicLimits) *DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DynamicLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// dynamic limits for the motion of this command +func AxsCmdVelDataStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsCmdVelDataAddAxsVel(builder *flatbuffers.Builder, axsVel float64) { + builder.PrependFloat64Slot(0, axsVel, 0.0) +} +func AxsCmdVelDataAddDriveVelMode(builder *flatbuffers.Builder, driveVelMode bool) { + builder.PrependBoolSlot(1, driveVelMode, false) +} +func AxsCmdVelDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(2, buffered, false) +} +func AxsCmdVelDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func AxsCmdVelDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsIpoValues.go b/pkg/fbs/motion/core/fbtypes/AxsIpoValues.go index b415294..f0926dc 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsIpoValues.go +++ b/pkg/fbs/motion/core/fbtypes/AxsIpoValues.go @@ -7,6 +7,53 @@ import ( ) /// currently interpolated values +type AxsIpoValuesT struct { + IpoPos float64 + IpoVel float64 + IpoAcc float64 + IpoJrk float64 + IpoPosUnit string + IpoVelUnit string + IpoAccUnit string + IpoJrkUnit string +} + +func (t *AxsIpoValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ipoPosUnitOffset := builder.CreateString(t.IpoPosUnit) + ipoVelUnitOffset := builder.CreateString(t.IpoVelUnit) + ipoAccUnitOffset := builder.CreateString(t.IpoAccUnit) + ipoJrkUnitOffset := builder.CreateString(t.IpoJrkUnit) + AxsIpoValuesStart(builder) + AxsIpoValuesAddIpoPos(builder, t.IpoPos) + AxsIpoValuesAddIpoVel(builder, t.IpoVel) + AxsIpoValuesAddIpoAcc(builder, t.IpoAcc) + AxsIpoValuesAddIpoJrk(builder, t.IpoJrk) + AxsIpoValuesAddIpoPosUnit(builder, ipoPosUnitOffset) + AxsIpoValuesAddIpoVelUnit(builder, ipoVelUnitOffset) + AxsIpoValuesAddIpoAccUnit(builder, ipoAccUnitOffset) + AxsIpoValuesAddIpoJrkUnit(builder, ipoJrkUnitOffset) + return AxsIpoValuesEnd(builder) +} + +func (rcv *AxsIpoValues) UnPackTo(t *AxsIpoValuesT) { + t.IpoPos = rcv.IpoPos() + t.IpoVel = rcv.IpoVel() + t.IpoAcc = rcv.IpoAcc() + t.IpoJrk = rcv.IpoJrk() + t.IpoPosUnit = string(rcv.IpoPosUnit()) + t.IpoVelUnit = string(rcv.IpoVelUnit()) + t.IpoAccUnit = string(rcv.IpoAccUnit()) + t.IpoJrkUnit = string(rcv.IpoJrkUnit()) +} + +func (rcv *AxsIpoValues) UnPack() *AxsIpoValuesT { + if rcv == nil { return nil } + t := &AxsIpoValuesT{} + rcv.UnPackTo(t) + return t +} + type AxsIpoValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/BootState.go b/pkg/fbs/motion/core/fbtypes/BootState.go index ca7a4a9..27f3c26 100644 --- a/pkg/fbs/motion/core/fbtypes/BootState.go +++ b/pkg/fbs/motion/core/fbtypes/BootState.go @@ -7,6 +7,35 @@ import ( ) /// return type of requests of the current boot state +type BootStateT struct { + Text string + ActStep uint32 + MaxSteps uint32 +} + +func (t *BootStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + textOffset := builder.CreateString(t.Text) + BootStateStart(builder) + BootStateAddText(builder, textOffset) + BootStateAddActStep(builder, t.ActStep) + BootStateAddMaxSteps(builder, t.MaxSteps) + return BootStateEnd(builder) +} + +func (rcv *BootState) UnPackTo(t *BootStateT) { + t.Text = string(rcv.Text()) + t.ActStep = rcv.ActStep() + t.MaxSteps = rcv.MaxSteps() +} + +func (rcv *BootState) UnPack() *BootStateT { + if rcv == nil { return nil } + t := &BootStateT{} + rcv.UnPackTo(t) + return t +} + type BootState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/BrakeLimit.go b/pkg/fbs/motion/core/fbtypes/BrakeLimit.go new file mode 100644 index 0000000..3d68970 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/BrakeLimit.go @@ -0,0 +1,36 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// type of the brake limit +type BrakeLimit int8 + +const ( + /// brake with commanded dynamics limits (soft stop) + BrakeLimitLAST_COMMANDED_LIMITS BrakeLimit = 0 + /// brake with reduced axis limits (on commanded path) + BrakeLimitREDUCED_AXIS_LIMITS BrakeLimit = 1 + /// brake with configured axis limits (on commanded path) + BrakeLimitCONFIGURED_AXIS_LIMITS BrakeLimit = 2 +) + +var EnumNamesBrakeLimit = map[BrakeLimit]string{ + BrakeLimitLAST_COMMANDED_LIMITS: "LAST_COMMANDED_LIMITS", + BrakeLimitREDUCED_AXIS_LIMITS: "REDUCED_AXIS_LIMITS", + BrakeLimitCONFIGURED_AXIS_LIMITS: "CONFIGURED_AXIS_LIMITS", +} + +var EnumValuesBrakeLimit = map[string]BrakeLimit{ + "LAST_COMMANDED_LIMITS": BrakeLimitLAST_COMMANDED_LIMITS, + "REDUCED_AXIS_LIMITS": BrakeLimitREDUCED_AXIS_LIMITS, + "CONFIGURED_AXIS_LIMITS": BrakeLimitCONFIGURED_AXIS_LIMITS, +} + +func (v BrakeLimit) String() string { + if s, ok := EnumNamesBrakeLimit[v]; ok { + return s + } + return "BrakeLimit(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/core/fbtypes/BrakingDistanceType.go b/pkg/fbs/motion/core/fbtypes/BrakingDistanceType.go new file mode 100644 index 0000000..6d22d96 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/BrakingDistanceType.go @@ -0,0 +1,36 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// braking distance type +type BrakingDistanceType int8 + +const ( + /// invalid braking distance type + BrakingDistanceTypeUNDEFINED BrakingDistanceType = 0 + /// emergency stop distance + BrakingDistanceTypeESTOP BrakingDistanceType = 1 + /// soft stop distance (corresponding to setting override to 0) + BrakingDistanceTypeSOFT_STOP BrakingDistanceType = 2 +) + +var EnumNamesBrakingDistanceType = map[BrakingDistanceType]string{ + BrakingDistanceTypeUNDEFINED: "UNDEFINED", + BrakingDistanceTypeESTOP: "ESTOP", + BrakingDistanceTypeSOFT_STOP: "SOFT_STOP", +} + +var EnumValuesBrakingDistanceType = map[string]BrakingDistanceType{ + "UNDEFINED": BrakingDistanceTypeUNDEFINED, + "ESTOP": BrakingDistanceTypeESTOP, + "SOFT_STOP": BrakingDistanceTypeSOFT_STOP, +} + +func (v BrakingDistanceType) String() string { + if s, ok := EnumNamesBrakingDistanceType[v]; ok { + return s + } + return "BrakingDistanceType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/core/fbtypes/Capability.go b/pkg/fbs/motion/core/fbtypes/Capability.go new file mode 100644 index 0000000..275fc0b --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/Capability.go @@ -0,0 +1,138 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Response for a single capability +type CapabilityT struct { + Count uint32 + MainDiag uint32 + DetailDiag uint32 + AddInfo string +} + +func (t *CapabilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + addInfoOffset := builder.CreateString(t.AddInfo) + CapabilityStart(builder) + CapabilityAddCount(builder, t.Count) + CapabilityAddMainDiag(builder, t.MainDiag) + CapabilityAddDetailDiag(builder, t.DetailDiag) + CapabilityAddAddInfo(builder, addInfoOffset) + return CapabilityEnd(builder) +} + +func (rcv *Capability) UnPackTo(t *CapabilityT) { + t.Count = rcv.Count() + t.MainDiag = rcv.MainDiag() + t.DetailDiag = rcv.DetailDiag() + t.AddInfo = string(rcv.AddInfo()) +} + +func (rcv *Capability) UnPack() *CapabilityT { + if rcv == nil { return nil } + t := &CapabilityT{} + rcv.UnPackTo(t) + return t +} + +type Capability struct { + _tab flatbuffers.Table +} + +func GetRootAsCapability(buf []byte, offset flatbuffers.UOffsetT) *Capability { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Capability{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCapability(buf []byte, offset flatbuffers.UOffsetT) *Capability { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Capability{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Capability) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Capability) Table() flatbuffers.Table { + return rcv._tab +} + +/// how many items are allowed by the system or the ressource? (when true/false then 1 represents true and 0 represents false) +func (rcv *Capability) Count() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// how many items are allowed by the system or the ressource? (when true/false then 1 represents true and 0 represents false) +func (rcv *Capability) MutateCount(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +/// in case of count==0: get here the main diagnosis code, why the capability is missing +func (rcv *Capability) MainDiag() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// in case of count==0: get here the main diagnosis code, why the capability is missing +func (rcv *Capability) MutateMainDiag(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +/// in case of count==0: get here the detail diagnosis code, why the capability is missing +func (rcv *Capability) DetailDiag() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// in case of count==0: get here the detail diagnosis code, why the capability is missing +func (rcv *Capability) MutateDetailDiag(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +/// in case of count==0: get here additional information text, why the capability is missing +func (rcv *Capability) AddInfo() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// in case of count==0: get here additional information text, why the capability is missing +func CapabilityStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func CapabilityAddCount(builder *flatbuffers.Builder, count uint32) { + builder.PrependUint32Slot(0, count, 0) +} +func CapabilityAddMainDiag(builder *flatbuffers.Builder, mainDiag uint32) { + builder.PrependUint32Slot(1, mainDiag, 0) +} +func CapabilityAddDetailDiag(builder *flatbuffers.Builder, detailDiag uint32) { + builder.PrependUint32Slot(2, detailDiag, 0) +} +func CapabilityAddAddInfo(builder *flatbuffers.Builder, addInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(addInfo), 0) +} +func CapabilityEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go b/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go index 59418a9..506b98a 100644 --- a/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go +++ b/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go @@ -7,6 +7,29 @@ import ( ) /// parameters for all command options, that have no parameters (except the perm. type) +type CmdOptNoParamT struct { + PermType string +} + +func (t *CmdOptNoParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + CmdOptNoParamStart(builder) + CmdOptNoParamAddPermType(builder, permTypeOffset) + return CmdOptNoParamEnd(builder) +} + +func (rcv *CmdOptNoParam) UnPackTo(t *CmdOptNoParamT) { + t.PermType = string(rcv.PermType()) +} + +func (rcv *CmdOptNoParam) UnPack() *CmdOptNoParamT { + if rcv == nil { return nil } + t := &CmdOptNoParamT{} + rcv.UnPackTo(t) + return t +} + type CmdOptNoParam struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/CmdSource.go b/pkg/fbs/motion/core/fbtypes/CmdSource.go index 3441057..d7d5f41 100644 --- a/pkg/fbs/motion/core/fbtypes/CmdSource.go +++ b/pkg/fbs/motion/core/fbtypes/CmdSource.go @@ -7,6 +7,36 @@ import ( ) /// command source (by which interface was this command inserted into the system (e.g. "PLC")) +type CmdSourceT struct { + Type string + Name string + Line uint64 +} + +func (t *CmdSourceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + typeOffset := builder.CreateString(t.Type) + nameOffset := builder.CreateString(t.Name) + CmdSourceStart(builder) + CmdSourceAddType(builder, typeOffset) + CmdSourceAddName(builder, nameOffset) + CmdSourceAddLine(builder, t.Line) + return CmdSourceEnd(builder) +} + +func (rcv *CmdSource) UnPackTo(t *CmdSourceT) { + t.Type = string(rcv.Type()) + t.Name = string(rcv.Name()) + t.Line = rcv.Line() +} + +func (rcv *CmdSource) UnPack() *CmdSourceT { + if rcv == nil { return nil } + t := &CmdSourceT{} + rcv.UnPackTo(t) + return t +} + type CmdSource struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/DiagInfo.go b/pkg/fbs/motion/core/fbtypes/DiagInfo.go index 8698e0c..0a452d1 100644 --- a/pkg/fbs/motion/core/fbtypes/DiagInfo.go +++ b/pkg/fbs/motion/core/fbtypes/DiagInfo.go @@ -7,6 +7,61 @@ import ( ) /// informations on the last diagnosis message of this motion object or of the system +type DiagInfoT struct { + MainDiagCode uint32 + DetailedDiagCode uint32 + ObjName string + ObjURI string + Source string + AddInfo string + FirstMainDiagCode uint32 + FirstDetailedDiagCode uint32 + FirstSource string + FirstAddInfo string +} + +func (t *DiagInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objNameOffset := builder.CreateString(t.ObjName) + objURIOffset := builder.CreateString(t.ObjURI) + sourceOffset := builder.CreateString(t.Source) + addInfoOffset := builder.CreateString(t.AddInfo) + firstSourceOffset := builder.CreateString(t.FirstSource) + firstAddInfoOffset := builder.CreateString(t.FirstAddInfo) + DiagInfoStart(builder) + DiagInfoAddMainDiagCode(builder, t.MainDiagCode) + DiagInfoAddDetailedDiagCode(builder, t.DetailedDiagCode) + DiagInfoAddObjName(builder, objNameOffset) + DiagInfoAddObjURI(builder, objURIOffset) + DiagInfoAddSource(builder, sourceOffset) + DiagInfoAddAddInfo(builder, addInfoOffset) + DiagInfoAddFirstMainDiagCode(builder, t.FirstMainDiagCode) + DiagInfoAddFirstDetailedDiagCode(builder, t.FirstDetailedDiagCode) + DiagInfoAddFirstSource(builder, firstSourceOffset) + DiagInfoAddFirstAddInfo(builder, firstAddInfoOffset) + return DiagInfoEnd(builder) +} + +func (rcv *DiagInfo) UnPackTo(t *DiagInfoT) { + t.MainDiagCode = rcv.MainDiagCode() + t.DetailedDiagCode = rcv.DetailedDiagCode() + t.ObjName = string(rcv.ObjName()) + t.ObjURI = string(rcv.ObjURI()) + t.Source = string(rcv.Source()) + t.AddInfo = string(rcv.AddInfo()) + t.FirstMainDiagCode = rcv.FirstMainDiagCode() + t.FirstDetailedDiagCode = rcv.FirstDetailedDiagCode() + t.FirstSource = string(rcv.FirstSource()) + t.FirstAddInfo = string(rcv.FirstAddInfo()) +} + +func (rcv *DiagInfo) UnPack() *DiagInfoT { + if rcv == nil { return nil } + t := &DiagInfoT{} + rcv.UnPackTo(t) + return t +} + type DiagInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/DynamicLimits.go b/pkg/fbs/motion/core/fbtypes/DynamicLimits.go index 2cb0778..4077b40 100644 --- a/pkg/fbs/motion/core/fbtypes/DynamicLimits.go +++ b/pkg/fbs/motion/core/fbtypes/DynamicLimits.go @@ -7,6 +7,40 @@ import ( ) /// set of dynamic limits (for commands) +type DynamicLimitsT struct { + Vel float64 + Acc float64 + Dec float64 + JrkAcc float64 + JrkDec float64 +} + +func (t *DynamicLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DynamicLimitsStart(builder) + DynamicLimitsAddVel(builder, t.Vel) + DynamicLimitsAddAcc(builder, t.Acc) + DynamicLimitsAddDec(builder, t.Dec) + DynamicLimitsAddJrkAcc(builder, t.JrkAcc) + DynamicLimitsAddJrkDec(builder, t.JrkDec) + return DynamicLimitsEnd(builder) +} + +func (rcv *DynamicLimits) UnPackTo(t *DynamicLimitsT) { + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Dec = rcv.Dec() + t.JrkAcc = rcv.JrkAcc() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *DynamicLimits) UnPack() *DynamicLimitsT { + if rcv == nil { return nil } + t := &DynamicLimitsT{} + rcv.UnPackTo(t) + return t +} + type DynamicLimits struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/DynamicLimitsState.go b/pkg/fbs/motion/core/fbtypes/DynamicLimitsState.go index 5bade2a..00eda06 100644 --- a/pkg/fbs/motion/core/fbtypes/DynamicLimitsState.go +++ b/pkg/fbs/motion/core/fbtypes/DynamicLimitsState.go @@ -7,6 +7,60 @@ import ( ) /// set of dynamic limits (for reading them in states) +type DynamicLimitsStateT struct { + Vel float64 + Acc float64 + Dec float64 + JrkAcc float64 + JrkDec float64 + VelUnit string + AccUnit string + DecUnit string + JrkAccUnit string + JrkDecUnit string +} + +func (t *DynamicLimitsStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + velUnitOffset := builder.CreateString(t.VelUnit) + accUnitOffset := builder.CreateString(t.AccUnit) + decUnitOffset := builder.CreateString(t.DecUnit) + jrkAccUnitOffset := builder.CreateString(t.JrkAccUnit) + jrkDecUnitOffset := builder.CreateString(t.JrkDecUnit) + DynamicLimitsStateStart(builder) + DynamicLimitsStateAddVel(builder, t.Vel) + DynamicLimitsStateAddAcc(builder, t.Acc) + DynamicLimitsStateAddDec(builder, t.Dec) + DynamicLimitsStateAddJrkAcc(builder, t.JrkAcc) + DynamicLimitsStateAddJrkDec(builder, t.JrkDec) + DynamicLimitsStateAddVelUnit(builder, velUnitOffset) + DynamicLimitsStateAddAccUnit(builder, accUnitOffset) + DynamicLimitsStateAddDecUnit(builder, decUnitOffset) + DynamicLimitsStateAddJrkAccUnit(builder, jrkAccUnitOffset) + DynamicLimitsStateAddJrkDecUnit(builder, jrkDecUnitOffset) + return DynamicLimitsStateEnd(builder) +} + +func (rcv *DynamicLimitsState) UnPackTo(t *DynamicLimitsStateT) { + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Dec = rcv.Dec() + t.JrkAcc = rcv.JrkAcc() + t.JrkDec = rcv.JrkDec() + t.VelUnit = string(rcv.VelUnit()) + t.AccUnit = string(rcv.AccUnit()) + t.DecUnit = string(rcv.DecUnit()) + t.JrkAccUnit = string(rcv.JrkAccUnit()) + t.JrkDecUnit = string(rcv.JrkDecUnit()) +} + +func (rcv *DynamicLimitsState) UnPack() *DynamicLimitsStateT { + if rcv == nil { return nil } + t := &DynamicLimitsStateT{} + rcv.UnPackTo(t) + return t +} + type DynamicLimitsState struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/IpoAddData.go b/pkg/fbs/motion/core/fbtypes/IpoAddData.go index b94617e..c13abfc 100644 --- a/pkg/fbs/motion/core/fbtypes/IpoAddData.go +++ b/pkg/fbs/motion/core/fbtypes/IpoAddData.go @@ -7,6 +7,53 @@ import ( ) /// currently interpolated values +type IpoAddDataT struct { + DistFromStart float64 + DistToTarget float64 + TimeFromStart float64 + TimeToTarget float64 + DistFromStartUnit string + DistToTargetUnit string + TimeFromStartUnit string + TimeToTargetUnit string +} + +func (t *IpoAddDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + distFromStartUnitOffset := builder.CreateString(t.DistFromStartUnit) + distToTargetUnitOffset := builder.CreateString(t.DistToTargetUnit) + timeFromStartUnitOffset := builder.CreateString(t.TimeFromStartUnit) + timeToTargetUnitOffset := builder.CreateString(t.TimeToTargetUnit) + IpoAddDataStart(builder) + IpoAddDataAddDistFromStart(builder, t.DistFromStart) + IpoAddDataAddDistToTarget(builder, t.DistToTarget) + IpoAddDataAddTimeFromStart(builder, t.TimeFromStart) + IpoAddDataAddTimeToTarget(builder, t.TimeToTarget) + IpoAddDataAddDistFromStartUnit(builder, distFromStartUnitOffset) + IpoAddDataAddDistToTargetUnit(builder, distToTargetUnitOffset) + IpoAddDataAddTimeFromStartUnit(builder, timeFromStartUnitOffset) + IpoAddDataAddTimeToTargetUnit(builder, timeToTargetUnitOffset) + return IpoAddDataEnd(builder) +} + +func (rcv *IpoAddData) UnPackTo(t *IpoAddDataT) { + t.DistFromStart = rcv.DistFromStart() + t.DistToTarget = rcv.DistToTarget() + t.TimeFromStart = rcv.TimeFromStart() + t.TimeToTarget = rcv.TimeToTarget() + t.DistFromStartUnit = string(rcv.DistFromStartUnit()) + t.DistToTargetUnit = string(rcv.DistToTargetUnit()) + t.TimeFromStartUnit = string(rcv.TimeFromStartUnit()) + t.TimeToTargetUnit = string(rcv.TimeToTargetUnit()) +} + +func (rcv *IpoAddData) UnPack() *IpoAddDataT { + if rcv == nil { return nil } + t := &IpoAddDataT{} + rcv.UnPackTo(t) + return t +} + type IpoAddData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinActualValues.go b/pkg/fbs/motion/core/fbtypes/KinActualValues.go index 397e8ac..3771ac0 100644 --- a/pkg/fbs/motion/core/fbtypes/KinActualValues.go +++ b/pkg/fbs/motion/core/fbtypes/KinActualValues.go @@ -7,6 +7,82 @@ import ( ) /// actual values of the kinematics +type KinActualValuesT struct { + ActualPos []float64 + ActualVel float64 + ActualAcc float64 + ActualJerk float64 + ActualPosUnit []string + ActualVelUnit string + ActualAccUnit string + ActualJerkUnit string +} + +func (t *KinActualValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + actualPosOffset := flatbuffers.UOffsetT(0) + if t.ActualPos != nil { + actualPosLength := len(t.ActualPos) + KinActualValuesStartActualPosVector(builder, actualPosLength) + for j := actualPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.ActualPos[j]) + } + actualPosOffset = builder.EndVector(actualPosLength) + } + actualPosUnitOffset := flatbuffers.UOffsetT(0) + if t.ActualPosUnit != nil { + actualPosUnitLength := len(t.ActualPosUnit) + actualPosUnitOffsets := make([]flatbuffers.UOffsetT, actualPosUnitLength) + for j := 0; j < actualPosUnitLength; j++ { + actualPosUnitOffsets[j] = builder.CreateString(t.ActualPosUnit[j]) + } + KinActualValuesStartActualPosUnitVector(builder, actualPosUnitLength) + for j := actualPosUnitLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(actualPosUnitOffsets[j]) + } + actualPosUnitOffset = builder.EndVector(actualPosUnitLength) + } + actualVelUnitOffset := builder.CreateString(t.ActualVelUnit) + actualAccUnitOffset := builder.CreateString(t.ActualAccUnit) + actualJerkUnitOffset := builder.CreateString(t.ActualJerkUnit) + KinActualValuesStart(builder) + KinActualValuesAddActualPos(builder, actualPosOffset) + KinActualValuesAddActualVel(builder, t.ActualVel) + KinActualValuesAddActualAcc(builder, t.ActualAcc) + KinActualValuesAddActualJerk(builder, t.ActualJerk) + KinActualValuesAddActualPosUnit(builder, actualPosUnitOffset) + KinActualValuesAddActualVelUnit(builder, actualVelUnitOffset) + KinActualValuesAddActualAccUnit(builder, actualAccUnitOffset) + KinActualValuesAddActualJerkUnit(builder, actualJerkUnitOffset) + return KinActualValuesEnd(builder) +} + +func (rcv *KinActualValues) UnPackTo(t *KinActualValuesT) { + actualPosLength := rcv.ActualPosLength() + t.ActualPos = make([]float64, actualPosLength) + for j := 0; j < actualPosLength; j++ { + t.ActualPos[j] = rcv.ActualPos(j) + } + t.ActualVel = rcv.ActualVel() + t.ActualAcc = rcv.ActualAcc() + t.ActualJerk = rcv.ActualJerk() + actualPosUnitLength := rcv.ActualPosUnitLength() + t.ActualPosUnit = make([]string, actualPosUnitLength) + for j := 0; j < actualPosUnitLength; j++ { + t.ActualPosUnit[j] = string(rcv.ActualPosUnit(j)) + } + t.ActualVelUnit = string(rcv.ActualVelUnit()) + t.ActualAccUnit = string(rcv.ActualAccUnit()) + t.ActualJerkUnit = string(rcv.ActualJerkUnit()) +} + +func (rcv *KinActualValues) UnPack() *KinActualValuesT { + if rcv == nil { return nil } + t := &KinActualValuesT{} + rcv.UnPackTo(t) + return t +} + type KinActualValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinAxsAll.go b/pkg/fbs/motion/core/fbtypes/KinAxsAll.go index 6885b41..164706f 100644 --- a/pkg/fbs/motion/core/fbtypes/KinAxsAll.go +++ b/pkg/fbs/motion/core/fbtypes/KinAxsAll.go @@ -7,6 +7,47 @@ import ( ) /// Data of all axes that are currently added to the kinematics +type KinAxsAllT struct { + Info []*KinAxsSingleT +} + +func (t *KinAxsAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + infoOffset := flatbuffers.UOffsetT(0) + if t.Info != nil { + infoLength := len(t.Info) + infoOffsets := make([]flatbuffers.UOffsetT, infoLength) + for j := 0; j < infoLength; j++ { + infoOffsets[j] = t.Info[j].Pack(builder) + } + KinAxsAllStartInfoVector(builder, infoLength) + for j := infoLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(infoOffsets[j]) + } + infoOffset = builder.EndVector(infoLength) + } + KinAxsAllStart(builder) + KinAxsAllAddInfo(builder, infoOffset) + return KinAxsAllEnd(builder) +} + +func (rcv *KinAxsAll) UnPackTo(t *KinAxsAllT) { + infoLength := rcv.InfoLength() + t.Info = make([]*KinAxsSingleT, infoLength) + for j := 0; j < infoLength; j++ { + x := KinAxsSingle{} + rcv.Info(&x, j) + t.Info[j] = x.UnPack() + } +} + +func (rcv *KinAxsAll) UnPack() *KinAxsAllT { + if rcv == nil { return nil } + t := &KinAxsAllT{} + rcv.UnPackTo(t) + return t +} + type KinAxsAll struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinAxsSingle.go b/pkg/fbs/motion/core/fbtypes/KinAxsSingle.go index 9bce2f8..d1ccf5a 100644 --- a/pkg/fbs/motion/core/fbtypes/KinAxsSingle.go +++ b/pkg/fbs/motion/core/fbtypes/KinAxsSingle.go @@ -7,6 +7,37 @@ import ( ) /// informations of an axis that is part of a kinematics +type KinAxsSingleT struct { + Meaning string + Name string + Dir string +} + +func (t *KinAxsSingleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + meaningOffset := builder.CreateString(t.Meaning) + nameOffset := builder.CreateString(t.Name) + dirOffset := builder.CreateString(t.Dir) + KinAxsSingleStart(builder) + KinAxsSingleAddMeaning(builder, meaningOffset) + KinAxsSingleAddName(builder, nameOffset) + KinAxsSingleAddDir(builder, dirOffset) + return KinAxsSingleEnd(builder) +} + +func (rcv *KinAxsSingle) UnPackTo(t *KinAxsSingleT) { + t.Meaning = string(rcv.Meaning()) + t.Name = string(rcv.Name()) + t.Dir = string(rcv.Dir()) +} + +func (rcv *KinAxsSingle) UnPack() *KinAxsSingleT { + if rcv == nil { return nil } + t := &KinAxsSingleT{} + rcv.UnPackTo(t) + return t +} + type KinAxsSingle struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfg.go b/pkg/fbs/motion/core/fbtypes/KinCfg.go index 98fc555..4033cba 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfg.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfg.go @@ -7,6 +7,71 @@ import ( ) /// complete configuration of a single kinematics +type KinCfgT struct { + ObjectType string + Limits *KinCfgLimitsT + AxsCfg []*KinCfgAxsT + Mcs *KinCfgAxsTrafoAllSetsT + Units *UnitCfgKinT + PrepLimits *KinCfgPrepLimitsT + RtInputs *RTInputsCfgT +} + +func (t *KinCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objectTypeOffset := builder.CreateString(t.ObjectType) + limitsOffset := t.Limits.Pack(builder) + axsCfgOffset := flatbuffers.UOffsetT(0) + if t.AxsCfg != nil { + axsCfgLength := len(t.AxsCfg) + axsCfgOffsets := make([]flatbuffers.UOffsetT, axsCfgLength) + for j := 0; j < axsCfgLength; j++ { + axsCfgOffsets[j] = t.AxsCfg[j].Pack(builder) + } + KinCfgStartAxsCfgVector(builder, axsCfgLength) + for j := axsCfgLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(axsCfgOffsets[j]) + } + axsCfgOffset = builder.EndVector(axsCfgLength) + } + mcsOffset := t.Mcs.Pack(builder) + unitsOffset := t.Units.Pack(builder) + prepLimitsOffset := t.PrepLimits.Pack(builder) + rtInputsOffset := t.RtInputs.Pack(builder) + KinCfgStart(builder) + KinCfgAddObjectType(builder, objectTypeOffset) + KinCfgAddLimits(builder, limitsOffset) + KinCfgAddAxsCfg(builder, axsCfgOffset) + KinCfgAddMcs(builder, mcsOffset) + KinCfgAddUnits(builder, unitsOffset) + KinCfgAddPrepLimits(builder, prepLimitsOffset) + KinCfgAddRtInputs(builder, rtInputsOffset) + return KinCfgEnd(builder) +} + +func (rcv *KinCfg) UnPackTo(t *KinCfgT) { + t.ObjectType = string(rcv.ObjectType()) + t.Limits = rcv.Limits(nil).UnPack() + axsCfgLength := rcv.AxsCfgLength() + t.AxsCfg = make([]*KinCfgAxsT, axsCfgLength) + for j := 0; j < axsCfgLength; j++ { + x := KinCfgAxs{} + rcv.AxsCfg(&x, j) + t.AxsCfg[j] = x.UnPack() + } + t.Mcs = rcv.Mcs(nil).UnPack() + t.Units = rcv.Units(nil).UnPack() + t.PrepLimits = rcv.PrepLimits(nil).UnPack() + t.RtInputs = rcv.RtInputs(nil).UnPack() +} + +func (rcv *KinCfg) UnPack() *KinCfgT { + if rcv == nil { return nil } + t := &KinCfgT{} + rcv.UnPackTo(t) + return t +} + type KinCfg struct { _tab flatbuffers.Table } @@ -126,8 +191,23 @@ func (rcv *KinCfg) PrepLimits(obj *KinCfgPrepLimits) *KinCfgPrepLimits { } /// preparation limits of a kinematics +/// configuration of the real-time inputs of the kinematics +func (rcv *KinCfg) RtInputs(obj *RTInputsCfg) *RTInputsCfg { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(RTInputsCfg) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of the real-time inputs of the kinematics func KinCfgStart(builder *flatbuffers.Builder) { - builder.StartObject(6) + builder.StartObject(7) } func KinCfgAddObjectType(builder *flatbuffers.Builder, objectType flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objectType), 0) @@ -150,6 +230,9 @@ func KinCfgAddUnits(builder *flatbuffers.Builder, units flatbuffers.UOffsetT) { func KinCfgAddPrepLimits(builder *flatbuffers.Builder, prepLimits flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(prepLimits), 0) } +func KinCfgAddRtInputs(builder *flatbuffers.Builder, rtInputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(rtInputs), 0) +} func KinCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxs.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxs.go index c097c3b..3b90193 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxs.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxs.go @@ -7,6 +7,37 @@ import ( ) /// configuration of an axis that can be added to a kinematics +type KinCfgAxsT struct { + AxsName string + AxsMeaning string + AxsDir string +} + +func (t *KinCfgAxsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsNameOffset := builder.CreateString(t.AxsName) + axsMeaningOffset := builder.CreateString(t.AxsMeaning) + axsDirOffset := builder.CreateString(t.AxsDir) + KinCfgAxsStart(builder) + KinCfgAxsAddAxsName(builder, axsNameOffset) + KinCfgAxsAddAxsMeaning(builder, axsMeaningOffset) + KinCfgAxsAddAxsDir(builder, axsDirOffset) + return KinCfgAxsEnd(builder) +} + +func (rcv *KinCfgAxs) UnPackTo(t *KinCfgAxsT) { + t.AxsName = string(rcv.AxsName()) + t.AxsMeaning = string(rcv.AxsMeaning()) + t.AxsDir = string(rcv.AxsDir()) +} + +func (rcv *KinCfgAxs) UnPack() *KinCfgAxsT { + if rcv == nil { return nil } + t := &KinCfgAxsT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxs struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllParam.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllParam.go index 2650cc2..1f52fcf 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllParam.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllParam.go @@ -6,7 +6,56 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) -/// data of a single configuration parameter of an axis transformation +/// configuration parameter of a single axis transformation +type KinCfgAxsTrafoAllParamT struct { + AxisAssignment *KinCfgAxsTrafoAxisAssignmentT + Groups []*KinCfgAxsTrafoParamGroupT + General *KinCfgAxsTrafoParamGroupT +} + +func (t *KinCfgAxsTrafoAllParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axisAssignmentOffset := t.AxisAssignment.Pack(builder) + groupsOffset := flatbuffers.UOffsetT(0) + if t.Groups != nil { + groupsLength := len(t.Groups) + groupsOffsets := make([]flatbuffers.UOffsetT, groupsLength) + for j := 0; j < groupsLength; j++ { + groupsOffsets[j] = t.Groups[j].Pack(builder) + } + KinCfgAxsTrafoAllParamStartGroupsVector(builder, groupsLength) + for j := groupsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(groupsOffsets[j]) + } + groupsOffset = builder.EndVector(groupsLength) + } + generalOffset := t.General.Pack(builder) + KinCfgAxsTrafoAllParamStart(builder) + KinCfgAxsTrafoAllParamAddAxisAssignment(builder, axisAssignmentOffset) + KinCfgAxsTrafoAllParamAddGroups(builder, groupsOffset) + KinCfgAxsTrafoAllParamAddGeneral(builder, generalOffset) + return KinCfgAxsTrafoAllParamEnd(builder) +} + +func (rcv *KinCfgAxsTrafoAllParam) UnPackTo(t *KinCfgAxsTrafoAllParamT) { + t.AxisAssignment = rcv.AxisAssignment(nil).UnPack() + groupsLength := rcv.GroupsLength() + t.Groups = make([]*KinCfgAxsTrafoParamGroupT, groupsLength) + for j := 0; j < groupsLength; j++ { + x := KinCfgAxsTrafoParamGroup{} + rcv.Groups(&x, j) + t.Groups[j] = x.UnPack() + } + t.General = rcv.General(nil).UnPack() +} + +func (rcv *KinCfgAxsTrafoAllParam) UnPack() *KinCfgAxsTrafoAllParamT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoAllParamT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoAllParam struct { _tab flatbuffers.Table } @@ -34,27 +83,23 @@ func (rcv *KinCfgAxsTrafoAllParam) Table() flatbuffers.Table { return rcv._tab } -/// Names of all axes, that are required for this axis transformation and that require an axis assignment -func (rcv *KinCfgAxsTrafoAllParam) AxsAssignment(j int) []byte { +/// axis assignment +func (rcv *KinCfgAxsTrafoAllParam) AxisAssignment(obj *KinCfgAxsTrafoAxisAssignment) *KinCfgAxsTrafoAxisAssignment { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(KinCfgAxsTrafoAxisAssignment) + } + obj.Init(rcv._tab.Bytes, x) + return obj } return nil } -func (rcv *KinCfgAxsTrafoAllParam) AxsAssignmentLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.VectorLen(o) - } - return 0 -} - -/// Names of all axes, that are required for this axis transformation and that require an axis assignment -/// Vector of all configuration parameters of the axis transformation -func (rcv *KinCfgAxsTrafoAllParam) Parameter(obj *KinCfgAxsTrafoParam, j int) bool { +/// axis assignment +/// all configuration parameter groups of this axis transformation +func (rcv *KinCfgAxsTrafoAllParam) Groups(obj *KinCfgAxsTrafoParamGroup, j int) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { x := rcv._tab.Vector(o) @@ -66,7 +111,7 @@ func (rcv *KinCfgAxsTrafoAllParam) Parameter(obj *KinCfgAxsTrafoParam, j int) bo return false } -func (rcv *KinCfgAxsTrafoAllParam) ParameterLength() int { +func (rcv *KinCfgAxsTrafoAllParam) GroupsLength() int { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { return rcv._tab.VectorLen(o) @@ -74,22 +119,37 @@ func (rcv *KinCfgAxsTrafoAllParam) ParameterLength() int { return 0 } -/// Vector of all configuration parameters of the axis transformation -func KinCfgAxsTrafoAllParamStart(builder *flatbuffers.Builder) { - builder.StartObject(2) +/// all configuration parameter groups of this axis transformation +/// all general parameter of this axis transformation +func (rcv *KinCfgAxsTrafoAllParam) General(obj *KinCfgAxsTrafoParamGroup) *KinCfgAxsTrafoParamGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(KinCfgAxsTrafoParamGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil } -func KinCfgAxsTrafoAllParamAddAxsAssignment(builder *flatbuffers.Builder, axsAssignment flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axsAssignment), 0) + +/// all general parameter of this axis transformation +func KinCfgAxsTrafoAllParamStart(builder *flatbuffers.Builder) { + builder.StartObject(3) } -func KinCfgAxsTrafoAllParamStartAxsAssignmentVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) +func KinCfgAxsTrafoAllParamAddAxisAssignment(builder *flatbuffers.Builder, axisAssignment flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axisAssignment), 0) } -func KinCfgAxsTrafoAllParamAddParameter(builder *flatbuffers.Builder, parameter flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(parameter), 0) +func KinCfgAxsTrafoAllParamAddGroups(builder *flatbuffers.Builder, groups flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(groups), 0) } -func KinCfgAxsTrafoAllParamStartParameterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { +func KinCfgAxsTrafoAllParamStartGroupsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } +func KinCfgAxsTrafoAllParamAddGeneral(builder *flatbuffers.Builder, general flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(general), 0) +} func KinCfgAxsTrafoAllParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllSets.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllSets.go index ffd09de..273fd16 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllSets.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAllSets.go @@ -7,6 +7,47 @@ import ( ) /// configuration values of all axis transformation sets +type KinCfgAxsTrafoAllSetsT struct { + AxsTrafoSets []*KinCfgAxsTrafoSetT +} + +func (t *KinCfgAxsTrafoAllSetsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsTrafoSetsOffset := flatbuffers.UOffsetT(0) + if t.AxsTrafoSets != nil { + axsTrafoSetsLength := len(t.AxsTrafoSets) + axsTrafoSetsOffsets := make([]flatbuffers.UOffsetT, axsTrafoSetsLength) + for j := 0; j < axsTrafoSetsLength; j++ { + axsTrafoSetsOffsets[j] = t.AxsTrafoSets[j].Pack(builder) + } + KinCfgAxsTrafoAllSetsStartAxsTrafoSetsVector(builder, axsTrafoSetsLength) + for j := axsTrafoSetsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(axsTrafoSetsOffsets[j]) + } + axsTrafoSetsOffset = builder.EndVector(axsTrafoSetsLength) + } + KinCfgAxsTrafoAllSetsStart(builder) + KinCfgAxsTrafoAllSetsAddAxsTrafoSets(builder, axsTrafoSetsOffset) + return KinCfgAxsTrafoAllSetsEnd(builder) +} + +func (rcv *KinCfgAxsTrafoAllSets) UnPackTo(t *KinCfgAxsTrafoAllSetsT) { + axsTrafoSetsLength := rcv.AxsTrafoSetsLength() + t.AxsTrafoSets = make([]*KinCfgAxsTrafoSetT, axsTrafoSetsLength) + for j := 0; j < axsTrafoSetsLength; j++ { + x := KinCfgAxsTrafoSet{} + rcv.AxsTrafoSets(&x, j) + t.AxsTrafoSets[j] = x.UnPack() + } +} + +func (rcv *KinCfgAxsTrafoAllSets) UnPack() *KinCfgAxsTrafoAllSetsT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoAllSetsT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoAllSets struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAxisAssignment.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAxisAssignment.go index ecb3eb3..24c12cf 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAxisAssignment.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoAxisAssignment.go @@ -7,6 +7,47 @@ import ( ) /// data of a all axis assignments for an axis transformation +type KinCfgAxsTrafoAxisAssignmentT struct { + Assignment []*KinCfgAxsTrafoSingleAxisAssignmentT +} + +func (t *KinCfgAxsTrafoAxisAssignmentT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + assignmentOffset := flatbuffers.UOffsetT(0) + if t.Assignment != nil { + assignmentLength := len(t.Assignment) + assignmentOffsets := make([]flatbuffers.UOffsetT, assignmentLength) + for j := 0; j < assignmentLength; j++ { + assignmentOffsets[j] = t.Assignment[j].Pack(builder) + } + KinCfgAxsTrafoAxisAssignmentStartAssignmentVector(builder, assignmentLength) + for j := assignmentLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(assignmentOffsets[j]) + } + assignmentOffset = builder.EndVector(assignmentLength) + } + KinCfgAxsTrafoAxisAssignmentStart(builder) + KinCfgAxsTrafoAxisAssignmentAddAssignment(builder, assignmentOffset) + return KinCfgAxsTrafoAxisAssignmentEnd(builder) +} + +func (rcv *KinCfgAxsTrafoAxisAssignment) UnPackTo(t *KinCfgAxsTrafoAxisAssignmentT) { + assignmentLength := rcv.AssignmentLength() + t.Assignment = make([]*KinCfgAxsTrafoSingleAxisAssignmentT, assignmentLength) + for j := 0; j < assignmentLength; j++ { + x := KinCfgAxsTrafoSingleAxisAssignment{} + rcv.Assignment(&x, j) + t.Assignment[j] = x.UnPack() + } +} + +func (rcv *KinCfgAxsTrafoAxisAssignment) UnPack() *KinCfgAxsTrafoAxisAssignmentT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoAxisAssignmentT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoAxisAssignment struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoData.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoData.go index 2901f15..7a37bc5 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoData.go @@ -6,7 +6,48 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) -/// data of all registered axis transformations +/// data of all registered axis transformations when reading all data of implemented axis transformations +type KinCfgAxsTrafoDataT struct { + AxsTrafoData []*KinCfgAxsTrafoDataSingleT +} + +func (t *KinCfgAxsTrafoDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsTrafoDataOffset := flatbuffers.UOffsetT(0) + if t.AxsTrafoData != nil { + axsTrafoDataLength := len(t.AxsTrafoData) + axsTrafoDataOffsets := make([]flatbuffers.UOffsetT, axsTrafoDataLength) + for j := 0; j < axsTrafoDataLength; j++ { + axsTrafoDataOffsets[j] = t.AxsTrafoData[j].Pack(builder) + } + KinCfgAxsTrafoDataStartAxsTrafoDataVector(builder, axsTrafoDataLength) + for j := axsTrafoDataLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(axsTrafoDataOffsets[j]) + } + axsTrafoDataOffset = builder.EndVector(axsTrafoDataLength) + } + KinCfgAxsTrafoDataStart(builder) + KinCfgAxsTrafoDataAddAxsTrafoData(builder, axsTrafoDataOffset) + return KinCfgAxsTrafoDataEnd(builder) +} + +func (rcv *KinCfgAxsTrafoData) UnPackTo(t *KinCfgAxsTrafoDataT) { + axsTrafoDataLength := rcv.AxsTrafoDataLength() + t.AxsTrafoData = make([]*KinCfgAxsTrafoDataSingleT, axsTrafoDataLength) + for j := 0; j < axsTrafoDataLength; j++ { + x := KinCfgAxsTrafoDataSingle{} + rcv.AxsTrafoData(&x, j) + t.AxsTrafoData[j] = x.UnPack() + } +} + +func (rcv *KinCfgAxsTrafoData) UnPack() *KinCfgAxsTrafoDataT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoDataT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataAllParam.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataAllParam.go new file mode 100644 index 0000000..e163ed6 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataAllParam.go @@ -0,0 +1,156 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// data of a single configuration parameter of an axis transformation when reading all data of an implemented axis transformation +type KinCfgAxsTrafoDataAllParamT struct { + AxsAssignment []string + Parameter []*KinCfgAxsTrafoDataParamT +} + +func (t *KinCfgAxsTrafoDataAllParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsAssignmentOffset := flatbuffers.UOffsetT(0) + if t.AxsAssignment != nil { + axsAssignmentLength := len(t.AxsAssignment) + axsAssignmentOffsets := make([]flatbuffers.UOffsetT, axsAssignmentLength) + for j := 0; j < axsAssignmentLength; j++ { + axsAssignmentOffsets[j] = builder.CreateString(t.AxsAssignment[j]) + } + KinCfgAxsTrafoDataAllParamStartAxsAssignmentVector(builder, axsAssignmentLength) + for j := axsAssignmentLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(axsAssignmentOffsets[j]) + } + axsAssignmentOffset = builder.EndVector(axsAssignmentLength) + } + parameterOffset := flatbuffers.UOffsetT(0) + if t.Parameter != nil { + parameterLength := len(t.Parameter) + parameterOffsets := make([]flatbuffers.UOffsetT, parameterLength) + for j := 0; j < parameterLength; j++ { + parameterOffsets[j] = t.Parameter[j].Pack(builder) + } + KinCfgAxsTrafoDataAllParamStartParameterVector(builder, parameterLength) + for j := parameterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(parameterOffsets[j]) + } + parameterOffset = builder.EndVector(parameterLength) + } + KinCfgAxsTrafoDataAllParamStart(builder) + KinCfgAxsTrafoDataAllParamAddAxsAssignment(builder, axsAssignmentOffset) + KinCfgAxsTrafoDataAllParamAddParameter(builder, parameterOffset) + return KinCfgAxsTrafoDataAllParamEnd(builder) +} + +func (rcv *KinCfgAxsTrafoDataAllParam) UnPackTo(t *KinCfgAxsTrafoDataAllParamT) { + axsAssignmentLength := rcv.AxsAssignmentLength() + t.AxsAssignment = make([]string, axsAssignmentLength) + for j := 0; j < axsAssignmentLength; j++ { + t.AxsAssignment[j] = string(rcv.AxsAssignment(j)) + } + parameterLength := rcv.ParameterLength() + t.Parameter = make([]*KinCfgAxsTrafoDataParamT, parameterLength) + for j := 0; j < parameterLength; j++ { + x := KinCfgAxsTrafoDataParam{} + rcv.Parameter(&x, j) + t.Parameter[j] = x.UnPack() + } +} + +func (rcv *KinCfgAxsTrafoDataAllParam) UnPack() *KinCfgAxsTrafoDataAllParamT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoDataAllParamT{} + rcv.UnPackTo(t) + return t +} + +type KinCfgAxsTrafoDataAllParam struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCfgAxsTrafoDataAllParam(buf []byte, offset flatbuffers.UOffsetT) *KinCfgAxsTrafoDataAllParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCfgAxsTrafoDataAllParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCfgAxsTrafoDataAllParam(buf []byte, offset flatbuffers.UOffsetT) *KinCfgAxsTrafoDataAllParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCfgAxsTrafoDataAllParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCfgAxsTrafoDataAllParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCfgAxsTrafoDataAllParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// Names of all axes, that are required for this axis transformation and that require an axis assignment +func (rcv *KinCfgAxsTrafoDataAllParam) AxsAssignment(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 *KinCfgAxsTrafoDataAllParam) AxsAssignmentLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// Names of all axes, that are required for this axis transformation and that require an axis assignment +/// Vector of all configuration parameters of the axis transformation +func (rcv *KinCfgAxsTrafoDataAllParam) Parameter(obj *KinCfgAxsTrafoDataParam, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + 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 *KinCfgAxsTrafoDataAllParam) ParameterLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// Vector of all configuration parameters of the axis transformation +func KinCfgAxsTrafoDataAllParamStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func KinCfgAxsTrafoDataAllParamAddAxsAssignment(builder *flatbuffers.Builder, axsAssignment flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axsAssignment), 0) +} +func KinCfgAxsTrafoDataAllParamStartAxsAssignmentVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func KinCfgAxsTrafoDataAllParamAddParameter(builder *flatbuffers.Builder, parameter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(parameter), 0) +} +func KinCfgAxsTrafoDataAllParamStartParameterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func KinCfgAxsTrafoDataAllParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataParam.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataParam.go new file mode 100644 index 0000000..da1266a --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataParam.go @@ -0,0 +1,228 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// data of a single configuration parameter of an axis transformation when reading all data of an implemented axis transformation +type KinCfgAxsTrafoDataParamT struct { + Name string + Description string + Image string + DocRef string + Group string + Unit string + Values []string + Type VarType +} + +func (t *KinCfgAxsTrafoDataParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + descriptionOffset := builder.CreateString(t.Description) + imageOffset := builder.CreateString(t.Image) + docRefOffset := builder.CreateString(t.DocRef) + groupOffset := builder.CreateString(t.Group) + unitOffset := builder.CreateString(t.Unit) + valuesOffset := flatbuffers.UOffsetT(0) + if t.Values != nil { + valuesLength := len(t.Values) + valuesOffsets := make([]flatbuffers.UOffsetT, valuesLength) + for j := 0; j < valuesLength; j++ { + valuesOffsets[j] = builder.CreateString(t.Values[j]) + } + KinCfgAxsTrafoDataParamStartValuesVector(builder, valuesLength) + for j := valuesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(valuesOffsets[j]) + } + valuesOffset = builder.EndVector(valuesLength) + } + KinCfgAxsTrafoDataParamStart(builder) + KinCfgAxsTrafoDataParamAddName(builder, nameOffset) + KinCfgAxsTrafoDataParamAddDescription(builder, descriptionOffset) + KinCfgAxsTrafoDataParamAddImage(builder, imageOffset) + KinCfgAxsTrafoDataParamAddDocRef(builder, docRefOffset) + KinCfgAxsTrafoDataParamAddGroup(builder, groupOffset) + KinCfgAxsTrafoDataParamAddUnit(builder, unitOffset) + KinCfgAxsTrafoDataParamAddValues(builder, valuesOffset) + KinCfgAxsTrafoDataParamAddType(builder, t.Type) + return KinCfgAxsTrafoDataParamEnd(builder) +} + +func (rcv *KinCfgAxsTrafoDataParam) UnPackTo(t *KinCfgAxsTrafoDataParamT) { + t.Name = string(rcv.Name()) + t.Description = string(rcv.Description()) + t.Image = string(rcv.Image()) + t.DocRef = string(rcv.DocRef()) + t.Group = string(rcv.Group()) + t.Unit = string(rcv.Unit()) + valuesLength := rcv.ValuesLength() + t.Values = make([]string, valuesLength) + for j := 0; j < valuesLength; j++ { + t.Values[j] = string(rcv.Values(j)) + } + t.Type = rcv.Type() +} + +func (rcv *KinCfgAxsTrafoDataParam) UnPack() *KinCfgAxsTrafoDataParamT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoDataParamT{} + rcv.UnPackTo(t) + return t +} + +type KinCfgAxsTrafoDataParam struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCfgAxsTrafoDataParam(buf []byte, offset flatbuffers.UOffsetT) *KinCfgAxsTrafoDataParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCfgAxsTrafoDataParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCfgAxsTrafoDataParam(buf []byte, offset flatbuffers.UOffsetT) *KinCfgAxsTrafoDataParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCfgAxsTrafoDataParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCfgAxsTrafoDataParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCfgAxsTrafoDataParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// Name of the parameter +func (rcv *KinCfgAxsTrafoDataParam) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Name of the parameter +/// Description of the parameter +func (rcv *KinCfgAxsTrafoDataParam) Description() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Description of the parameter +/// Image (link) of the parameter +func (rcv *KinCfgAxsTrafoDataParam) Image() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Image (link) of the parameter +/// Reference to the documentation of the parameter +func (rcv *KinCfgAxsTrafoDataParam) DocRef() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Reference to the documentation of the parameter +/// Group of the parameter (might be empty, when this parameter is not part of a group) +func (rcv *KinCfgAxsTrafoDataParam) Group() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Group of the parameter (might be empty, when this parameter is not part of a group) +/// Expected unit of the parameter (might be empty for unitless parameters +func (rcv *KinCfgAxsTrafoDataParam) Unit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Expected unit of the parameter (might be empty for unitless parameters +/// Valid values for the parameter (when it's a string parameter and a kind of enumeration, else empty) +func (rcv *KinCfgAxsTrafoDataParam) Values(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *KinCfgAxsTrafoDataParam) ValuesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// Valid values for the parameter (when it's a string parameter and a kind of enumeration, else empty) +/// Type of the variable +func (rcv *KinCfgAxsTrafoDataParam) Type() VarType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return VarType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +/// Type of the variable +func (rcv *KinCfgAxsTrafoDataParam) MutateType(n VarType) bool { + return rcv._tab.MutateInt8Slot(18, int8(n)) +} + +func KinCfgAxsTrafoDataParamStart(builder *flatbuffers.Builder) { + builder.StartObject(8) +} +func KinCfgAxsTrafoDataParamAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func KinCfgAxsTrafoDataParamAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(description), 0) +} +func KinCfgAxsTrafoDataParamAddImage(builder *flatbuffers.Builder, image flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(image), 0) +} +func KinCfgAxsTrafoDataParamAddDocRef(builder *flatbuffers.Builder, docRef flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(docRef), 0) +} +func KinCfgAxsTrafoDataParamAddGroup(builder *flatbuffers.Builder, group flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(group), 0) +} +func KinCfgAxsTrafoDataParamAddUnit(builder *flatbuffers.Builder, unit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(unit), 0) +} +func KinCfgAxsTrafoDataParamAddValues(builder *flatbuffers.Builder, values flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(values), 0) +} +func KinCfgAxsTrafoDataParamStartValuesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func KinCfgAxsTrafoDataParamAddType(builder *flatbuffers.Builder, type_ VarType) { + builder.PrependInt8Slot(7, int8(type_), 1) +} +func KinCfgAxsTrafoDataParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataSingle.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataSingle.go index c9ad82e..6d4bc1b 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataSingle.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoDataSingle.go @@ -6,7 +6,53 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) -/// data of a single registered axis transformation +/// data of a single registered axis transformation when reading all data of an implemented axis transformation +type KinCfgAxsTrafoDataSingleT struct { + Name string + Description string + Image string + DocRef string + Version string + Pow POWType + Parameters *KinCfgAxsTrafoDataAllParamT +} + +func (t *KinCfgAxsTrafoDataSingleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + descriptionOffset := builder.CreateString(t.Description) + imageOffset := builder.CreateString(t.Image) + docRefOffset := builder.CreateString(t.DocRef) + versionOffset := builder.CreateString(t.Version) + parametersOffset := t.Parameters.Pack(builder) + KinCfgAxsTrafoDataSingleStart(builder) + KinCfgAxsTrafoDataSingleAddName(builder, nameOffset) + KinCfgAxsTrafoDataSingleAddDescription(builder, descriptionOffset) + KinCfgAxsTrafoDataSingleAddImage(builder, imageOffset) + KinCfgAxsTrafoDataSingleAddDocRef(builder, docRefOffset) + KinCfgAxsTrafoDataSingleAddVersion(builder, versionOffset) + KinCfgAxsTrafoDataSingleAddPow(builder, t.Pow) + KinCfgAxsTrafoDataSingleAddParameters(builder, parametersOffset) + return KinCfgAxsTrafoDataSingleEnd(builder) +} + +func (rcv *KinCfgAxsTrafoDataSingle) UnPackTo(t *KinCfgAxsTrafoDataSingleT) { + t.Name = string(rcv.Name()) + t.Description = string(rcv.Description()) + t.Image = string(rcv.Image()) + t.DocRef = string(rcv.DocRef()) + t.Version = string(rcv.Version()) + t.Pow = rcv.Pow() + t.Parameters = rcv.Parameters(nil).UnPack() +} + +func (rcv *KinCfgAxsTrafoDataSingle) UnPack() *KinCfgAxsTrafoDataSingleT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoDataSingleT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoDataSingle struct { _tab flatbuffers.Table } @@ -99,12 +145,12 @@ func (rcv *KinCfgAxsTrafoDataSingle) MutatePow(n POWType) bool { } /// All configuration parameters of the axis transformation -func (rcv *KinCfgAxsTrafoDataSingle) Parameters(obj *KinCfgAxsTrafoAllParam) *KinCfgAxsTrafoAllParam { +func (rcv *KinCfgAxsTrafoDataSingle) Parameters(obj *KinCfgAxsTrafoDataAllParam) *KinCfgAxsTrafoDataAllParam { o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) if o != 0 { x := rcv._tab.Indirect(o + rcv._tab.Pos) if obj == nil { - obj = new(KinCfgAxsTrafoAllParam) + obj = new(KinCfgAxsTrafoDataAllParam) } obj.Init(rcv._tab.Bytes, x) return obj diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoParamGroup.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoParamGroup.go index f4c085f..ac8c0bf 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoParamGroup.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoParamGroup.go @@ -7,6 +7,51 @@ import ( ) /// configuration of a single parameter group of an axis transformation +type KinCfgAxsTrafoParamGroupT struct { + Name string + Param []*KinCfgAxsTrafoSingleParamT +} + +func (t *KinCfgAxsTrafoParamGroupT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + paramOffset := flatbuffers.UOffsetT(0) + if t.Param != nil { + paramLength := len(t.Param) + paramOffsets := make([]flatbuffers.UOffsetT, paramLength) + for j := 0; j < paramLength; j++ { + paramOffsets[j] = t.Param[j].Pack(builder) + } + KinCfgAxsTrafoParamGroupStartParamVector(builder, paramLength) + for j := paramLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(paramOffsets[j]) + } + paramOffset = builder.EndVector(paramLength) + } + KinCfgAxsTrafoParamGroupStart(builder) + KinCfgAxsTrafoParamGroupAddName(builder, nameOffset) + KinCfgAxsTrafoParamGroupAddParam(builder, paramOffset) + return KinCfgAxsTrafoParamGroupEnd(builder) +} + +func (rcv *KinCfgAxsTrafoParamGroup) UnPackTo(t *KinCfgAxsTrafoParamGroupT) { + t.Name = string(rcv.Name()) + paramLength := rcv.ParamLength() + t.Param = make([]*KinCfgAxsTrafoSingleParamT, paramLength) + for j := 0; j < paramLength; j++ { + x := KinCfgAxsTrafoSingleParam{} + rcv.Param(&x, j) + t.Param[j] = x.UnPack() + } +} + +func (rcv *KinCfgAxsTrafoParamGroup) UnPack() *KinCfgAxsTrafoParamGroupT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoParamGroupT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoParamGroup struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSet.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSet.go index 3e9680b..12fd3de 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSet.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSet.go @@ -7,6 +7,37 @@ import ( ) /// data of a single axis transformation set +type KinCfgAxsTrafoSetT struct { + Name string + AxsTrafo string + Param *KinCfgAxsTrafoAllParamT +} + +func (t *KinCfgAxsTrafoSetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + axsTrafoOffset := builder.CreateString(t.AxsTrafo) + paramOffset := t.Param.Pack(builder) + KinCfgAxsTrafoSetStart(builder) + KinCfgAxsTrafoSetAddName(builder, nameOffset) + KinCfgAxsTrafoSetAddAxsTrafo(builder, axsTrafoOffset) + KinCfgAxsTrafoSetAddParam(builder, paramOffset) + return KinCfgAxsTrafoSetEnd(builder) +} + +func (rcv *KinCfgAxsTrafoSet) UnPackTo(t *KinCfgAxsTrafoSetT) { + t.Name = string(rcv.Name()) + t.AxsTrafo = string(rcv.AxsTrafo()) + t.Param = rcv.Param(nil).UnPack() +} + +func (rcv *KinCfgAxsTrafoSet) UnPack() *KinCfgAxsTrafoSetT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoSetT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoSet struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleAxisAssignment.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleAxisAssignment.go index 5250c07..a767b9e 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleAxisAssignment.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleAxisAssignment.go @@ -7,6 +7,32 @@ import ( ) /// data of a single axis assignment for an axis transformation +type KinCfgAxsTrafoSingleAxisAssignmentT struct { + AxisName string + IndexACS byte +} + +func (t *KinCfgAxsTrafoSingleAxisAssignmentT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axisNameOffset := builder.CreateString(t.AxisName) + KinCfgAxsTrafoSingleAxisAssignmentStart(builder) + KinCfgAxsTrafoSingleAxisAssignmentAddAxisName(builder, axisNameOffset) + KinCfgAxsTrafoSingleAxisAssignmentAddIndexACS(builder, t.IndexACS) + return KinCfgAxsTrafoSingleAxisAssignmentEnd(builder) +} + +func (rcv *KinCfgAxsTrafoSingleAxisAssignment) UnPackTo(t *KinCfgAxsTrafoSingleAxisAssignmentT) { + t.AxisName = string(rcv.AxisName()) + t.IndexACS = rcv.IndexACS() +} + +func (rcv *KinCfgAxsTrafoSingleAxisAssignment) UnPack() *KinCfgAxsTrafoSingleAxisAssignmentT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoSingleAxisAssignmentT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoSingleAxisAssignment struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleParam.go b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleParam.go index 63ea5ec..3a1ee89 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleParam.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgAxsTrafoSingleParam.go @@ -7,6 +7,39 @@ import ( ) /// configuration of a single parameter of an axis transformation +type KinCfgAxsTrafoSingleParamT struct { + Name string + ValueDouble float64 + ValueInt int64 + ValueString string +} + +func (t *KinCfgAxsTrafoSingleParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + valueStringOffset := builder.CreateString(t.ValueString) + KinCfgAxsTrafoSingleParamStart(builder) + KinCfgAxsTrafoSingleParamAddName(builder, nameOffset) + KinCfgAxsTrafoSingleParamAddValueDouble(builder, t.ValueDouble) + KinCfgAxsTrafoSingleParamAddValueInt(builder, t.ValueInt) + KinCfgAxsTrafoSingleParamAddValueString(builder, valueStringOffset) + return KinCfgAxsTrafoSingleParamEnd(builder) +} + +func (rcv *KinCfgAxsTrafoSingleParam) UnPackTo(t *KinCfgAxsTrafoSingleParamT) { + t.Name = string(rcv.Name()) + t.ValueDouble = rcv.ValueDouble() + t.ValueInt = rcv.ValueInt() + t.ValueString = string(rcv.ValueString()) +} + +func (rcv *KinCfgAxsTrafoSingleParam) UnPack() *KinCfgAxsTrafoSingleParamT { + if rcv == nil { return nil } + t := &KinCfgAxsTrafoSingleParamT{} + rcv.UnPackTo(t) + return t +} + type KinCfgAxsTrafoSingleParam struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgLimits.go b/pkg/fbs/motion/core/fbtypes/KinCfgLimits.go index d01ff2b..7d1a83c 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgLimits.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgLimits.go @@ -7,6 +7,60 @@ import ( ) /// all configured limits of this kinematics +type KinCfgLimitsT struct { + Vel float64 + Acc float64 + Dec float64 + JrkAcc float64 + JrkDec float64 + VelUnit string + AccUnit string + DecUnit string + JrkAccUnit string + JrkDecUnit string +} + +func (t *KinCfgLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + velUnitOffset := builder.CreateString(t.VelUnit) + accUnitOffset := builder.CreateString(t.AccUnit) + decUnitOffset := builder.CreateString(t.DecUnit) + jrkAccUnitOffset := builder.CreateString(t.JrkAccUnit) + jrkDecUnitOffset := builder.CreateString(t.JrkDecUnit) + KinCfgLimitsStart(builder) + KinCfgLimitsAddVel(builder, t.Vel) + KinCfgLimitsAddAcc(builder, t.Acc) + KinCfgLimitsAddDec(builder, t.Dec) + KinCfgLimitsAddJrkAcc(builder, t.JrkAcc) + KinCfgLimitsAddJrkDec(builder, t.JrkDec) + KinCfgLimitsAddVelUnit(builder, velUnitOffset) + KinCfgLimitsAddAccUnit(builder, accUnitOffset) + KinCfgLimitsAddDecUnit(builder, decUnitOffset) + KinCfgLimitsAddJrkAccUnit(builder, jrkAccUnitOffset) + KinCfgLimitsAddJrkDecUnit(builder, jrkDecUnitOffset) + return KinCfgLimitsEnd(builder) +} + +func (rcv *KinCfgLimits) UnPackTo(t *KinCfgLimitsT) { + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Dec = rcv.Dec() + t.JrkAcc = rcv.JrkAcc() + t.JrkDec = rcv.JrkDec() + t.VelUnit = string(rcv.VelUnit()) + t.AccUnit = string(rcv.AccUnit()) + t.DecUnit = string(rcv.DecUnit()) + t.JrkAccUnit = string(rcv.JrkAccUnit()) + t.JrkDecUnit = string(rcv.JrkDecUnit()) +} + +func (rcv *KinCfgLimits) UnPack() *KinCfgLimitsT { + if rcv == nil { return nil } + t := &KinCfgLimitsT{} + rcv.UnPackTo(t) + return t +} + type KinCfgLimits struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgPrepLimits.go b/pkg/fbs/motion/core/fbtypes/KinCfgPrepLimits.go index da2aa90..e0bf3a2 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgPrepLimits.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgPrepLimits.go @@ -7,6 +7,28 @@ import ( ) /// preparation limits for kinematics +type KinCfgPrepLimitsT struct { + MaxCmdsInBuffer uint64 +} + +func (t *KinCfgPrepLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + KinCfgPrepLimitsStart(builder) + KinCfgPrepLimitsAddMaxCmdsInBuffer(builder, t.MaxCmdsInBuffer) + return KinCfgPrepLimitsEnd(builder) +} + +func (rcv *KinCfgPrepLimits) UnPackTo(t *KinCfgPrepLimitsT) { + t.MaxCmdsInBuffer = rcv.MaxCmdsInBuffer() +} + +func (rcv *KinCfgPrepLimits) UnPack() *KinCfgPrepLimitsT { + if rcv == nil { return nil } + t := &KinCfgPrepLimitsT{} + rcv.UnPackTo(t) + return t +} + type KinCfgPrepLimits struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdAbortData.go b/pkg/fbs/motion/core/fbtypes/KinCmdAbortData.go new file mode 100644 index 0000000..aa729ab --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCmdAbortData.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Command data for kinAbort command and kinInterrupt command +type KinCmdAbortDataT struct { + Type BrakeLimit +} + +func (t *KinCmdAbortDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + KinCmdAbortDataStart(builder) + KinCmdAbortDataAddType(builder, t.Type) + return KinCmdAbortDataEnd(builder) +} + +func (rcv *KinCmdAbortData) UnPackTo(t *KinCmdAbortDataT) { + t.Type = rcv.Type() +} + +func (rcv *KinCmdAbortData) UnPack() *KinCmdAbortDataT { + if rcv == nil { return nil } + t := &KinCmdAbortDataT{} + rcv.UnPackTo(t) + return t +} + +type KinCmdAbortData struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCmdAbortData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdAbortData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCmdAbortData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCmdAbortData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdAbortData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCmdAbortData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCmdAbortData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCmdAbortData) Table() flatbuffers.Table { + return rcv._tab +} + +/// dynamic limits of the deceleration ramp (default is "soft stop") +func (rcv *KinCmdAbortData) Type() BrakeLimit { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return BrakeLimit(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// dynamic limits of the deceleration ramp (default is "soft stop") +func (rcv *KinCmdAbortData) MutateType(n BrakeLimit) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func KinCmdAbortDataStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func KinCmdAbortDataAddType(builder *flatbuffers.Builder, type_ BrakeLimit) { + builder.PrependInt8Slot(0, int8(type_), 0) +} +func KinCmdAbortDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdContourData.go b/pkg/fbs/motion/core/fbtypes/KinCmdContourData.go new file mode 100644 index 0000000..acc1d9a --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCmdContourData.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters for the contour command for a kinematics +type KinCmdContourDataT struct { + IsStart bool + PrepCmds uint32 +} + +func (t *KinCmdContourDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + KinCmdContourDataStart(builder) + KinCmdContourDataAddIsStart(builder, t.IsStart) + KinCmdContourDataAddPrepCmds(builder, t.PrepCmds) + return KinCmdContourDataEnd(builder) +} + +func (rcv *KinCmdContourData) UnPackTo(t *KinCmdContourDataT) { + t.IsStart = rcv.IsStart() + t.PrepCmds = rcv.PrepCmds() +} + +func (rcv *KinCmdContourData) UnPack() *KinCmdContourDataT { + if rcv == nil { return nil } + t := &KinCmdContourDataT{} + rcv.UnPackTo(t) + return t +} + +type KinCmdContourData struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCmdContourData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdContourData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCmdContourData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCmdContourData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdContourData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCmdContourData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCmdContourData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCmdContourData) Table() flatbuffers.Table { + return rcv._tab +} + +/// is this the start of the contour? +func (rcv *KinCmdContourData) IsStart() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// is this the start of the contour? +func (rcv *KinCmdContourData) MutateIsStart(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// set the number of commands that should be prepared completely (only relevant when isStart=true) +func (rcv *KinCmdContourData) PrepCmds() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// set the number of commands that should be prepared completely (only relevant when isStart=true) +func (rcv *KinCmdContourData) MutatePrepCmds(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func KinCmdContourDataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func KinCmdContourDataAddIsStart(builder *flatbuffers.Builder, isStart bool) { + builder.PrependBoolSlot(0, isStart, true) +} +func KinCmdContourDataAddPrepCmds(builder *flatbuffers.Builder, prepCmds uint32) { + builder.PrependUint32Slot(1, prepCmds, 0) +} +func KinCmdContourDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdJogData.go b/pkg/fbs/motion/core/fbtypes/KinCmdJogData.go index 2451836..da6b574 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdJogData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdJogData.go @@ -7,6 +7,52 @@ import ( ) /// parameters for the jog commands for a kinematics +type KinCmdJogDataT struct { + JogDir []float64 + CoordSys string + JogIncrement float64 + Lim *DynamicLimitsT +} + +func (t *KinCmdJogDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + jogDirOffset := flatbuffers.UOffsetT(0) + if t.JogDir != nil { + jogDirLength := len(t.JogDir) + KinCmdJogDataStartJogDirVector(builder, jogDirLength) + for j := jogDirLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.JogDir[j]) + } + jogDirOffset = builder.EndVector(jogDirLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + limOffset := t.Lim.Pack(builder) + KinCmdJogDataStart(builder) + KinCmdJogDataAddJogDir(builder, jogDirOffset) + KinCmdJogDataAddCoordSys(builder, coordSysOffset) + KinCmdJogDataAddJogIncrement(builder, t.JogIncrement) + KinCmdJogDataAddLim(builder, limOffset) + return KinCmdJogDataEnd(builder) +} + +func (rcv *KinCmdJogData) UnPackTo(t *KinCmdJogDataT) { + jogDirLength := rcv.JogDirLength() + t.JogDir = make([]float64, jogDirLength) + for j := 0; j < jogDirLength; j++ { + t.JogDir[j] = rcv.JogDir(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.JogIncrement = rcv.JogIncrement() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *KinCmdJogData) UnPack() *KinCmdJogDataT { + if rcv == nil { return nil } + t := &KinCmdJogDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdJogData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdMoveData.go b/pkg/fbs/motion/core/fbtypes/KinCmdMoveData.go index 6d0f79f..7b667c6 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdMoveData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdMoveData.go @@ -7,6 +7,52 @@ import ( ) /// parameters for the move linear commands for a kinematics +type KinCmdMoveDataT struct { + KinPos []float64 + CoordSys string + Lim *DynamicLimitsT + Buffered bool +} + +func (t *KinCmdMoveDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + kinPosOffset := flatbuffers.UOffsetT(0) + if t.KinPos != nil { + kinPosLength := len(t.KinPos) + KinCmdMoveDataStartKinPosVector(builder, kinPosLength) + for j := kinPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.KinPos[j]) + } + kinPosOffset = builder.EndVector(kinPosLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + limOffset := t.Lim.Pack(builder) + KinCmdMoveDataStart(builder) + KinCmdMoveDataAddKinPos(builder, kinPosOffset) + KinCmdMoveDataAddCoordSys(builder, coordSysOffset) + KinCmdMoveDataAddLim(builder, limOffset) + KinCmdMoveDataAddBuffered(builder, t.Buffered) + return KinCmdMoveDataEnd(builder) +} + +func (rcv *KinCmdMoveData) UnPackTo(t *KinCmdMoveDataT) { + kinPosLength := rcv.KinPosLength() + t.KinPos = make([]float64, kinPosLength) + for j := 0; j < kinPosLength; j++ { + t.KinPos[j] = rcv.KinPos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.Lim = rcv.Lim(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *KinCmdMoveData) UnPack() *KinCmdMoveDataT { + if rcv == nil { return nil } + t := &KinCmdMoveDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdMoveData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectAsyncData.go b/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectAsyncData.go index 2e0a548..056c1f0 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectAsyncData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectAsyncData.go @@ -7,6 +7,52 @@ import ( ) /// parameters for the move direct asynchronous command for a kinematics +type KinCmdMoveDirectAsyncDataT struct { + KinPos []float64 + CoordSys string + DynLimFactors *DynamicLimitsT + Buffered bool +} + +func (t *KinCmdMoveDirectAsyncDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + kinPosOffset := flatbuffers.UOffsetT(0) + if t.KinPos != nil { + kinPosLength := len(t.KinPos) + KinCmdMoveDirectAsyncDataStartKinPosVector(builder, kinPosLength) + for j := kinPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.KinPos[j]) + } + kinPosOffset = builder.EndVector(kinPosLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + dynLimFactorsOffset := t.DynLimFactors.Pack(builder) + KinCmdMoveDirectAsyncDataStart(builder) + KinCmdMoveDirectAsyncDataAddKinPos(builder, kinPosOffset) + KinCmdMoveDirectAsyncDataAddCoordSys(builder, coordSysOffset) + KinCmdMoveDirectAsyncDataAddDynLimFactors(builder, dynLimFactorsOffset) + KinCmdMoveDirectAsyncDataAddBuffered(builder, t.Buffered) + return KinCmdMoveDirectAsyncDataEnd(builder) +} + +func (rcv *KinCmdMoveDirectAsyncData) UnPackTo(t *KinCmdMoveDirectAsyncDataT) { + kinPosLength := rcv.KinPosLength() + t.KinPos = make([]float64, kinPosLength) + for j := 0; j < kinPosLength; j++ { + t.KinPos[j] = rcv.KinPos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.DynLimFactors = rcv.DynLimFactors(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *KinCmdMoveDirectAsyncData) UnPack() *KinCmdMoveDirectAsyncDataT { + if rcv == nil { return nil } + t := &KinCmdMoveDirectAsyncDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdMoveDirectAsyncData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectData.go b/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectData.go index 5b1d81b..1f5fd12 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdMoveDirectData.go @@ -7,6 +7,48 @@ import ( ) /// parameters for the move direct commands for a kinematics +type KinCmdMoveDirectDataT struct { + KinPos []float64 + CoordSys string + Buffered bool +} + +func (t *KinCmdMoveDirectDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + kinPosOffset := flatbuffers.UOffsetT(0) + if t.KinPos != nil { + kinPosLength := len(t.KinPos) + KinCmdMoveDirectDataStartKinPosVector(builder, kinPosLength) + for j := kinPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.KinPos[j]) + } + kinPosOffset = builder.EndVector(kinPosLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + KinCmdMoveDirectDataStart(builder) + KinCmdMoveDirectDataAddKinPos(builder, kinPosOffset) + KinCmdMoveDirectDataAddCoordSys(builder, coordSysOffset) + KinCmdMoveDirectDataAddBuffered(builder, t.Buffered) + return KinCmdMoveDirectDataEnd(builder) +} + +func (rcv *KinCmdMoveDirectData) UnPackTo(t *KinCmdMoveDirectDataT) { + kinPosLength := rcv.KinPosLength() + t.KinPos = make([]float64, kinPosLength) + for j := 0; j < kinPosLength; j++ { + t.KinPos[j] = rcv.KinPos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.Buffered = rcv.Buffered() +} + +func (rcv *KinCmdMoveDirectData) UnPack() *KinCmdMoveDirectDataT { + if rcv == nil { return nil } + t := &KinCmdMoveDirectDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdMoveDirectData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptAxsDynLimData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptAxsDynLimData.go index 0c67220..07923e6 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptAxsDynLimData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptAxsDynLimData.go @@ -7,6 +7,33 @@ import ( ) /// parameters for the command option SafeArea (monitoring of safe zones and work areas) for kinematics +type KinCmdOptAxsDynLimDataT struct { + AxsName string + Lim *DynamicLimitsT +} + +func (t *KinCmdOptAxsDynLimDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsNameOffset := builder.CreateString(t.AxsName) + limOffset := t.Lim.Pack(builder) + KinCmdOptAxsDynLimDataStart(builder) + KinCmdOptAxsDynLimDataAddAxsName(builder, axsNameOffset) + KinCmdOptAxsDynLimDataAddLim(builder, limOffset) + return KinCmdOptAxsDynLimDataEnd(builder) +} + +func (rcv *KinCmdOptAxsDynLimData) UnPackTo(t *KinCmdOptAxsDynLimDataT) { + t.AxsName = string(rcv.AxsName()) + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *KinCmdOptAxsDynLimData) UnPack() *KinCmdOptAxsDynLimDataT { + if rcv == nil { return nil } + t := &KinCmdOptAxsDynLimDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptAxsDynLimData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go index d065685..972684b 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go @@ -7,6 +7,35 @@ import ( ) /// parameters for the command option blending for kinematics +type KinCmdOptBlendDataT struct { + PermType string + Dist1 float64 + Dist2 float64 +} + +func (t *KinCmdOptBlendDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + KinCmdOptBlendDataStart(builder) + KinCmdOptBlendDataAddPermType(builder, permTypeOffset) + KinCmdOptBlendDataAddDist1(builder, t.Dist1) + KinCmdOptBlendDataAddDist2(builder, t.Dist2) + return KinCmdOptBlendDataEnd(builder) +} + +func (rcv *KinCmdOptBlendData) UnPackTo(t *KinCmdOptBlendDataT) { + t.PermType = string(rcv.PermType()) + t.Dist1 = rcv.Dist1() + t.Dist2 = rcv.Dist2() +} + +func (rcv *KinCmdOptBlendData) UnPack() *KinCmdOptBlendDataT { + if rcv == nil { return nil } + t := &KinCmdOptBlendDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptBlendData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go index 9b6fc9b..4b3e046 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go @@ -7,6 +7,33 @@ import ( ) /// parameters for the command option MCS (machine coordinate system a.k.a. axis transformation) for kinematics +type KinCmdOptMCSDataT struct { + PermType string + SetName string +} + +func (t *KinCmdOptMCSDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + setNameOffset := builder.CreateString(t.SetName) + KinCmdOptMCSDataStart(builder) + KinCmdOptMCSDataAddPermType(builder, permTypeOffset) + KinCmdOptMCSDataAddSetName(builder, setNameOffset) + return KinCmdOptMCSDataEnd(builder) +} + +func (rcv *KinCmdOptMCSData) UnPackTo(t *KinCmdOptMCSDataT) { + t.PermType = string(rcv.PermType()) + t.SetName = string(rcv.SetName()) +} + +func (rcv *KinCmdOptMCSData) UnPack() *KinCmdOptMCSDataT { + if rcv == nil { return nil } + t := &KinCmdOptMCSDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptMCSData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go index ef95007..ff603a5 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go @@ -7,6 +7,33 @@ import ( ) /// parameters for the command option PCS (product coordinate system) for kinematics +type KinCmdOptPCSDataT struct { + PermType string + SetName string +} + +func (t *KinCmdOptPCSDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + setNameOffset := builder.CreateString(t.SetName) + KinCmdOptPCSDataStart(builder) + KinCmdOptPCSDataAddPermType(builder, permTypeOffset) + KinCmdOptPCSDataAddSetName(builder, setNameOffset) + return KinCmdOptPCSDataEnd(builder) +} + +func (rcv *KinCmdOptPCSData) UnPackTo(t *KinCmdOptPCSDataT) { + t.PermType = string(rcv.PermType()) + t.SetName = string(rcv.SetName()) +} + +func (rcv *KinCmdOptPCSData) UnPack() *KinCmdOptPCSDataT { + if rcv == nil { return nil } + t := &KinCmdOptPCSDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptPCSData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go index 91fc572..d11f3b4 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go @@ -7,6 +7,38 @@ import ( ) /// parameters for the command option PolyTrans (inserting polynomial commands between successively move commands) for kinematics +type KinCmdOptPolyTransDataT struct { + PermType string + Dist1 float64 + Dist2 float64 + Eps float64 +} + +func (t *KinCmdOptPolyTransDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + KinCmdOptPolyTransDataStart(builder) + KinCmdOptPolyTransDataAddPermType(builder, permTypeOffset) + KinCmdOptPolyTransDataAddDist1(builder, t.Dist1) + KinCmdOptPolyTransDataAddDist2(builder, t.Dist2) + KinCmdOptPolyTransDataAddEps(builder, t.Eps) + return KinCmdOptPolyTransDataEnd(builder) +} + +func (rcv *KinCmdOptPolyTransData) UnPackTo(t *KinCmdOptPolyTransDataT) { + t.PermType = string(rcv.PermType()) + t.Dist1 = rcv.Dist1() + t.Dist2 = rcv.Dist2() + t.Eps = rcv.Eps() +} + +func (rcv *KinCmdOptPolyTransData) UnPack() *KinCmdOptPolyTransDataT { + if rcv == nil { return nil } + t := &KinCmdOptPolyTransDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptPolyTransData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go index c552c3e..db29bc5 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go @@ -7,6 +7,33 @@ import ( ) /// parameters for the command option SafeArea (monitoring of safe zones and work areas) for kinematics +type KinCmdOptSafeAreaDataT struct { + PermType string + SafeArea string +} + +func (t *KinCmdOptSafeAreaDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := builder.CreateString(t.PermType) + safeAreaOffset := builder.CreateString(t.SafeArea) + KinCmdOptSafeAreaDataStart(builder) + KinCmdOptSafeAreaDataAddPermType(builder, permTypeOffset) + KinCmdOptSafeAreaDataAddSafeArea(builder, safeAreaOffset) + return KinCmdOptSafeAreaDataEnd(builder) +} + +func (rcv *KinCmdOptSafeAreaData) UnPackTo(t *KinCmdOptSafeAreaDataT) { + t.PermType = string(rcv.PermType()) + t.SafeArea = string(rcv.SafeArea()) +} + +func (rcv *KinCmdOptSafeAreaData) UnPack() *KinCmdOptSafeAreaDataT { + if rcv == nil { return nil } + t := &KinCmdOptSafeAreaDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdOptSafeAreaData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdValues.go b/pkg/fbs/motion/core/fbtypes/KinCmdValues.go index 542b8a1..91bb2d1 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdValues.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdValues.go @@ -7,6 +7,56 @@ import ( ) /// parameters and data of the active command +type KinCmdValuesT struct { + TargetPos []float64 + Lim *DynamicLimitsStateT + CoordSys string + CmdId uint64 + Src *CmdSourceT +} + +func (t *KinCmdValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + targetPosOffset := flatbuffers.UOffsetT(0) + if t.TargetPos != nil { + targetPosLength := len(t.TargetPos) + KinCmdValuesStartTargetPosVector(builder, targetPosLength) + for j := targetPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.TargetPos[j]) + } + targetPosOffset = builder.EndVector(targetPosLength) + } + limOffset := t.Lim.Pack(builder) + coordSysOffset := builder.CreateString(t.CoordSys) + srcOffset := t.Src.Pack(builder) + KinCmdValuesStart(builder) + KinCmdValuesAddTargetPos(builder, targetPosOffset) + KinCmdValuesAddLim(builder, limOffset) + KinCmdValuesAddCoordSys(builder, coordSysOffset) + KinCmdValuesAddCmdId(builder, t.CmdId) + KinCmdValuesAddSrc(builder, srcOffset) + return KinCmdValuesEnd(builder) +} + +func (rcv *KinCmdValues) UnPackTo(t *KinCmdValuesT) { + targetPosLength := rcv.TargetPosLength() + t.TargetPos = make([]float64, targetPosLength) + for j := 0; j < targetPosLength; j++ { + t.TargetPos[j] = rcv.TargetPos(j) + } + t.Lim = rcv.Lim(nil).UnPack() + t.CoordSys = string(rcv.CoordSys()) + t.CmdId = rcv.CmdId() + t.Src = rcv.Src(nil).UnPack() +} + +func (rcv *KinCmdValues) UnPack() *KinCmdValuesT { + if rcv == nil { return nil } + t := &KinCmdValuesT{} + rcv.UnPackTo(t) + return t +} + type KinCmdValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinCoordTransform.go b/pkg/fbs/motion/core/fbtypes/KinCoordTransform.go index cd68a4a..1d7084c 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCoordTransform.go +++ b/pkg/fbs/motion/core/fbtypes/KinCoordTransform.go @@ -7,6 +7,65 @@ import ( ) /// coordinate transformation based on the currently active transformations of the kinematics +type KinCoordTransformT struct { + InPos []float64 + InCoordSys string + OutPos []float64 + OutCoordSys string +} + +func (t *KinCoordTransformT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + inPosOffset := flatbuffers.UOffsetT(0) + if t.InPos != nil { + inPosLength := len(t.InPos) + KinCoordTransformStartInPosVector(builder, inPosLength) + for j := inPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.InPos[j]) + } + inPosOffset = builder.EndVector(inPosLength) + } + inCoordSysOffset := builder.CreateString(t.InCoordSys) + outPosOffset := flatbuffers.UOffsetT(0) + if t.OutPos != nil { + outPosLength := len(t.OutPos) + KinCoordTransformStartOutPosVector(builder, outPosLength) + for j := outPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.OutPos[j]) + } + outPosOffset = builder.EndVector(outPosLength) + } + outCoordSysOffset := builder.CreateString(t.OutCoordSys) + KinCoordTransformStart(builder) + KinCoordTransformAddInPos(builder, inPosOffset) + KinCoordTransformAddInCoordSys(builder, inCoordSysOffset) + KinCoordTransformAddOutPos(builder, outPosOffset) + KinCoordTransformAddOutCoordSys(builder, outCoordSysOffset) + return KinCoordTransformEnd(builder) +} + +func (rcv *KinCoordTransform) UnPackTo(t *KinCoordTransformT) { + inPosLength := rcv.InPosLength() + t.InPos = make([]float64, inPosLength) + for j := 0; j < inPosLength; j++ { + t.InPos[j] = rcv.InPos(j) + } + t.InCoordSys = string(rcv.InCoordSys()) + outPosLength := rcv.OutPosLength() + t.OutPos = make([]float64, outPosLength) + for j := 0; j < outPosLength; j++ { + t.OutPos[j] = rcv.OutPos(j) + } + t.OutCoordSys = string(rcv.OutCoordSys()) +} + +func (rcv *KinCoordTransform) UnPack() *KinCoordTransformT { + if rcv == nil { return nil } + t := &KinCoordTransformT{} + rcv.UnPackTo(t) + return t +} + type KinCoordTransform struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinIpoValues.go b/pkg/fbs/motion/core/fbtypes/KinIpoValues.go index bcccbdb..0b92822 100644 --- a/pkg/fbs/motion/core/fbtypes/KinIpoValues.go +++ b/pkg/fbs/motion/core/fbtypes/KinIpoValues.go @@ -7,6 +7,82 @@ import ( ) /// currently interpolated values +type KinIpoValuesT struct { + IpoPos []float64 + IpoVel float64 + IpoAcc float64 + IpoJrk float64 + IpoPosUnits []string + IpoVelUnits string + IpoAccUnits string + IpoJrkUnits string +} + +func (t *KinIpoValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ipoPosOffset := flatbuffers.UOffsetT(0) + if t.IpoPos != nil { + ipoPosLength := len(t.IpoPos) + KinIpoValuesStartIpoPosVector(builder, ipoPosLength) + for j := ipoPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.IpoPos[j]) + } + ipoPosOffset = builder.EndVector(ipoPosLength) + } + ipoPosUnitsOffset := flatbuffers.UOffsetT(0) + if t.IpoPosUnits != nil { + ipoPosUnitsLength := len(t.IpoPosUnits) + ipoPosUnitsOffsets := make([]flatbuffers.UOffsetT, ipoPosUnitsLength) + for j := 0; j < ipoPosUnitsLength; j++ { + ipoPosUnitsOffsets[j] = builder.CreateString(t.IpoPosUnits[j]) + } + KinIpoValuesStartIpoPosUnitsVector(builder, ipoPosUnitsLength) + for j := ipoPosUnitsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(ipoPosUnitsOffsets[j]) + } + ipoPosUnitsOffset = builder.EndVector(ipoPosUnitsLength) + } + ipoVelUnitsOffset := builder.CreateString(t.IpoVelUnits) + ipoAccUnitsOffset := builder.CreateString(t.IpoAccUnits) + ipoJrkUnitsOffset := builder.CreateString(t.IpoJrkUnits) + KinIpoValuesStart(builder) + KinIpoValuesAddIpoPos(builder, ipoPosOffset) + KinIpoValuesAddIpoVel(builder, t.IpoVel) + KinIpoValuesAddIpoAcc(builder, t.IpoAcc) + KinIpoValuesAddIpoJrk(builder, t.IpoJrk) + KinIpoValuesAddIpoPosUnits(builder, ipoPosUnitsOffset) + KinIpoValuesAddIpoVelUnits(builder, ipoVelUnitsOffset) + KinIpoValuesAddIpoAccUnits(builder, ipoAccUnitsOffset) + KinIpoValuesAddIpoJrkUnits(builder, ipoJrkUnitsOffset) + return KinIpoValuesEnd(builder) +} + +func (rcv *KinIpoValues) UnPackTo(t *KinIpoValuesT) { + ipoPosLength := rcv.IpoPosLength() + t.IpoPos = make([]float64, ipoPosLength) + for j := 0; j < ipoPosLength; j++ { + t.IpoPos[j] = rcv.IpoPos(j) + } + t.IpoVel = rcv.IpoVel() + t.IpoAcc = rcv.IpoAcc() + t.IpoJrk = rcv.IpoJrk() + ipoPosUnitsLength := rcv.IpoPosUnitsLength() + t.IpoPosUnits = make([]string, ipoPosUnitsLength) + for j := 0; j < ipoPosUnitsLength; j++ { + t.IpoPosUnits[j] = string(rcv.IpoPosUnits(j)) + } + t.IpoVelUnits = string(rcv.IpoVelUnits()) + t.IpoAccUnits = string(rcv.IpoAccUnits()) + t.IpoJrkUnits = string(rcv.IpoJrkUnits()) +} + +func (rcv *KinIpoValues) UnPack() *KinIpoValuesT { + if rcv == nil { return nil } + t := &KinIpoValuesT{} + rcv.UnPackTo(t) + return t +} + type KinIpoValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/KinPosValues.go b/pkg/fbs/motion/core/fbtypes/KinPosValues.go index cada81b..7a7d9a8 100644 --- a/pkg/fbs/motion/core/fbtypes/KinPosValues.go +++ b/pkg/fbs/motion/core/fbtypes/KinPosValues.go @@ -7,6 +7,61 @@ import ( ) /// position of a kinematics +type KinPosValuesT struct { + Pos []float64 + Units []string +} + +func (t *KinPosValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + posOffset := flatbuffers.UOffsetT(0) + if t.Pos != nil { + posLength := len(t.Pos) + KinPosValuesStartPosVector(builder, posLength) + for j := posLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Pos[j]) + } + posOffset = builder.EndVector(posLength) + } + unitsOffset := flatbuffers.UOffsetT(0) + if t.Units != nil { + unitsLength := len(t.Units) + unitsOffsets := make([]flatbuffers.UOffsetT, unitsLength) + for j := 0; j < unitsLength; j++ { + unitsOffsets[j] = builder.CreateString(t.Units[j]) + } + KinPosValuesStartUnitsVector(builder, unitsLength) + for j := unitsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(unitsOffsets[j]) + } + unitsOffset = builder.EndVector(unitsLength) + } + KinPosValuesStart(builder) + KinPosValuesAddPos(builder, posOffset) + KinPosValuesAddUnits(builder, unitsOffset) + return KinPosValuesEnd(builder) +} + +func (rcv *KinPosValues) UnPackTo(t *KinPosValuesT) { + posLength := rcv.PosLength() + t.Pos = make([]float64, posLength) + for j := 0; j < posLength; j++ { + t.Pos[j] = rcv.Pos(j) + } + unitsLength := rcv.UnitsLength() + t.Units = make([]string, unitsLength) + for j := 0; j < unitsLength; j++ { + t.Units[j] = string(rcv.Units(j)) + } +} + +func (rcv *KinPosValues) UnPack() *KinPosValuesT { + if rcv == nil { return nil } + t := &KinPosValuesT{} + rcv.UnPackTo(t) + return t +} + type KinPosValues struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/RTInputsCfg.go b/pkg/fbs/motion/core/fbtypes/RTInputsCfg.go new file mode 100644 index 0000000..f6cda40 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/RTInputsCfg.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// common configuration of real-time inputs +type RTInputsCfgT struct { + DoubleArraySize uint32 + Int64ArraySize uint32 +} + +func (t *RTInputsCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + RTInputsCfgStart(builder) + RTInputsCfgAddDoubleArraySize(builder, t.DoubleArraySize) + RTInputsCfgAddInt64ArraySize(builder, t.Int64ArraySize) + return RTInputsCfgEnd(builder) +} + +func (rcv *RTInputsCfg) UnPackTo(t *RTInputsCfgT) { + t.DoubleArraySize = rcv.DoubleArraySize() + t.Int64ArraySize = rcv.Int64ArraySize() +} + +func (rcv *RTInputsCfg) UnPack() *RTInputsCfgT { + if rcv == nil { return nil } + t := &RTInputsCfgT{} + rcv.UnPackTo(t) + return t +} + +type RTInputsCfg struct { + _tab flatbuffers.Table +} + +func GetRootAsRTInputsCfg(buf []byte, offset flatbuffers.UOffsetT) *RTInputsCfg { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &RTInputsCfg{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsRTInputsCfg(buf []byte, offset flatbuffers.UOffsetT) *RTInputsCfg { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &RTInputsCfg{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *RTInputsCfg) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *RTInputsCfg) Table() flatbuffers.Table { + return rcv._tab +} + +/// size of the double array +func (rcv *RTInputsCfg) DoubleArraySize() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// size of the double array +func (rcv *RTInputsCfg) MutateDoubleArraySize(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +/// size of the int64 array +func (rcv *RTInputsCfg) Int64ArraySize() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// size of the int64 array +func (rcv *RTInputsCfg) MutateInt64ArraySize(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func RTInputsCfgStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func RTInputsCfgAddDoubleArraySize(builder *flatbuffers.Builder, doubleArraySize uint32) { + builder.PrependUint32Slot(0, doubleArraySize, 0) +} +func RTInputsCfgAddInt64ArraySize(builder *flatbuffers.Builder, int64ArraySize uint32) { + builder.PrependUint32Slot(1, int64ArraySize, 0) +} +func RTInputsCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/SingleLicense.go b/pkg/fbs/motion/core/fbtypes/SingleLicense.go index 8f3f894..7e80cf8 100644 --- a/pkg/fbs/motion/core/fbtypes/SingleLicense.go +++ b/pkg/fbs/motion/core/fbtypes/SingleLicense.go @@ -7,6 +7,33 @@ import ( ) /// information of a single acquired license +type SingleLicenseT struct { + Name string + Version string +} + +func (t *SingleLicenseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + versionOffset := builder.CreateString(t.Version) + SingleLicenseStart(builder) + SingleLicenseAddName(builder, nameOffset) + SingleLicenseAddVersion(builder, versionOffset) + return SingleLicenseEnd(builder) +} + +func (rcv *SingleLicense) UnPackTo(t *SingleLicenseT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) +} + +func (rcv *SingleLicense) UnPack() *SingleLicenseT { + if rcv == nil { return nil } + t := &SingleLicenseT{} + rcv.UnPackTo(t) + return t +} + type SingleLicense struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfg.go b/pkg/fbs/motion/core/fbtypes/SysCfg.go index 0f59f3c..91ec57c 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfg.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfg.go @@ -7,6 +7,45 @@ import ( ) /// general system configuration +type SysCfgT struct { + Pcs *SysCfgPcsAllT + Function *SysCfgFunctionT + Internal *SysCfgInternalT + SafeAreas *SysCfgSafeAreaAllT + RtInputs *RTInputsCfgT +} + +func (t *SysCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pcsOffset := t.Pcs.Pack(builder) + functionOffset := t.Function.Pack(builder) + internalOffset := t.Internal.Pack(builder) + safeAreasOffset := t.SafeAreas.Pack(builder) + rtInputsOffset := t.RtInputs.Pack(builder) + SysCfgStart(builder) + SysCfgAddPcs(builder, pcsOffset) + SysCfgAddFunction(builder, functionOffset) + SysCfgAddInternal(builder, internalOffset) + SysCfgAddSafeAreas(builder, safeAreasOffset) + SysCfgAddRtInputs(builder, rtInputsOffset) + return SysCfgEnd(builder) +} + +func (rcv *SysCfg) UnPackTo(t *SysCfgT) { + t.Pcs = rcv.Pcs(nil).UnPack() + t.Function = rcv.Function(nil).UnPack() + t.Internal = rcv.Internal(nil).UnPack() + t.SafeAreas = rcv.SafeAreas(nil).UnPack() + t.RtInputs = rcv.RtInputs(nil).UnPack() +} + +func (rcv *SysCfg) UnPack() *SysCfgT { + if rcv == nil { return nil } + t := &SysCfgT{} + rcv.UnPackTo(t) + return t +} + type SysCfg struct { _tab flatbuffers.Table } @@ -94,8 +133,23 @@ func (rcv *SysCfg) SafeAreas(obj *SysCfgSafeAreaAll) *SysCfgSafeAreaAll { } /// configuration of the safe and work areas +/// configuration of the real-time inputs of the kinematics +func (rcv *SysCfg) RtInputs(obj *RTInputsCfg) *RTInputsCfg { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(RTInputsCfg) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of the real-time inputs of the kinematics func SysCfgStart(builder *flatbuffers.Builder) { - builder.StartObject(4) + builder.StartObject(5) } func SysCfgAddPcs(builder *flatbuffers.Builder, pcs flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pcs), 0) @@ -109,6 +163,9 @@ func SysCfgAddInternal(builder *flatbuffers.Builder, internal flatbuffers.UOffse func SysCfgAddSafeAreas(builder *flatbuffers.Builder, safeAreas flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(safeAreas), 0) } +func SysCfgAddRtInputs(builder *flatbuffers.Builder, rtInputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(rtInputs), 0) +} func SysCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgFunction.go b/pkg/fbs/motion/core/fbtypes/SysCfgFunction.go index ddf6bdb..fd1890b 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgFunction.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgFunction.go @@ -7,6 +7,28 @@ import ( ) /// system function configuration items +type SysCfgFunctionT struct { + IgnoreAxisProfiles bool +} + +func (t *SysCfgFunctionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SysCfgFunctionStart(builder) + SysCfgFunctionAddIgnoreAxisProfiles(builder, t.IgnoreAxisProfiles) + return SysCfgFunctionEnd(builder) +} + +func (rcv *SysCfgFunction) UnPackTo(t *SysCfgFunctionT) { + t.IgnoreAxisProfiles = rcv.IgnoreAxisProfiles() +} + +func (rcv *SysCfgFunction) UnPack() *SysCfgFunctionT { + if rcv == nil { return nil } + t := &SysCfgFunctionT{} + rcv.UnPackTo(t) + return t +} + type SysCfgFunction struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgInternal.go b/pkg/fbs/motion/core/fbtypes/SysCfgInternal.go index 3f977b1..ecc1ea4 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgInternal.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgInternal.go @@ -7,6 +7,34 @@ import ( ) /// internal system configuration items +type SysCfgInternalT struct { + Save bool + UseIpoIVAJ bool + TimeMeasurement bool +} + +func (t *SysCfgInternalT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SysCfgInternalStart(builder) + SysCfgInternalAddSave(builder, t.Save) + SysCfgInternalAddUseIpoIVAJ(builder, t.UseIpoIVAJ) + SysCfgInternalAddTimeMeasurement(builder, t.TimeMeasurement) + return SysCfgInternalEnd(builder) +} + +func (rcv *SysCfgInternal) UnPackTo(t *SysCfgInternalT) { + t.Save = rcv.Save() + t.UseIpoIVAJ = rcv.UseIpoIVAJ() + t.TimeMeasurement = rcv.TimeMeasurement() +} + +func (rcv *SysCfgInternal) UnPack() *SysCfgInternalT { + if rcv == nil { return nil } + t := &SysCfgInternalT{} + rcv.UnPackTo(t) + return t +} + type SysCfgInternal struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgPcsAll.go b/pkg/fbs/motion/core/fbtypes/SysCfgPcsAll.go index e71b780..1a41ec6 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgPcsAll.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgPcsAll.go @@ -7,6 +7,69 @@ import ( ) /// configuration of the product coordinate system of this kinematics +type SysCfgPcsAllT struct { + Sets []*SysCfgPcsSetT + Groups []*SysCfgPcsGroupT +} + +func (t *SysCfgPcsAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + setsOffset := flatbuffers.UOffsetT(0) + if t.Sets != nil { + setsLength := len(t.Sets) + setsOffsets := make([]flatbuffers.UOffsetT, setsLength) + for j := 0; j < setsLength; j++ { + setsOffsets[j] = t.Sets[j].Pack(builder) + } + SysCfgPcsAllStartSetsVector(builder, setsLength) + for j := setsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(setsOffsets[j]) + } + setsOffset = builder.EndVector(setsLength) + } + groupsOffset := flatbuffers.UOffsetT(0) + if t.Groups != nil { + groupsLength := len(t.Groups) + groupsOffsets := make([]flatbuffers.UOffsetT, groupsLength) + for j := 0; j < groupsLength; j++ { + groupsOffsets[j] = t.Groups[j].Pack(builder) + } + SysCfgPcsAllStartGroupsVector(builder, groupsLength) + for j := groupsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(groupsOffsets[j]) + } + groupsOffset = builder.EndVector(groupsLength) + } + SysCfgPcsAllStart(builder) + SysCfgPcsAllAddSets(builder, setsOffset) + SysCfgPcsAllAddGroups(builder, groupsOffset) + return SysCfgPcsAllEnd(builder) +} + +func (rcv *SysCfgPcsAll) UnPackTo(t *SysCfgPcsAllT) { + setsLength := rcv.SetsLength() + t.Sets = make([]*SysCfgPcsSetT, setsLength) + for j := 0; j < setsLength; j++ { + x := SysCfgPcsSet{} + rcv.Sets(&x, j) + t.Sets[j] = x.UnPack() + } + groupsLength := rcv.GroupsLength() + t.Groups = make([]*SysCfgPcsGroupT, groupsLength) + for j := 0; j < groupsLength; j++ { + x := SysCfgPcsGroup{} + rcv.Groups(&x, j) + t.Groups[j] = x.UnPack() + } +} + +func (rcv *SysCfgPcsAll) UnPack() *SysCfgPcsAllT { + if rcv == nil { return nil } + t := &SysCfgPcsAllT{} + rcv.UnPackTo(t) + return t +} + type SysCfgPcsAll struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgPcsGroup.go b/pkg/fbs/motion/core/fbtypes/SysCfgPcsGroup.go index 2666cbe..7033b1e 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgPcsGroup.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgPcsGroup.go @@ -7,6 +7,49 @@ import ( ) /// configuration of a single group of sets for a product coordinate system +type SysCfgPcsGroupT struct { + GroupName string + Sets []string +} + +func (t *SysCfgPcsGroupT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + groupNameOffset := builder.CreateString(t.GroupName) + setsOffset := flatbuffers.UOffsetT(0) + if t.Sets != nil { + setsLength := len(t.Sets) + setsOffsets := make([]flatbuffers.UOffsetT, setsLength) + for j := 0; j < setsLength; j++ { + setsOffsets[j] = builder.CreateString(t.Sets[j]) + } + SysCfgPcsGroupStartSetsVector(builder, setsLength) + for j := setsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(setsOffsets[j]) + } + setsOffset = builder.EndVector(setsLength) + } + SysCfgPcsGroupStart(builder) + SysCfgPcsGroupAddGroupName(builder, groupNameOffset) + SysCfgPcsGroupAddSets(builder, setsOffset) + return SysCfgPcsGroupEnd(builder) +} + +func (rcv *SysCfgPcsGroup) UnPackTo(t *SysCfgPcsGroupT) { + t.GroupName = string(rcv.GroupName()) + setsLength := rcv.SetsLength() + t.Sets = make([]string, setsLength) + for j := 0; j < setsLength; j++ { + t.Sets[j] = string(rcv.Sets(j)) + } +} + +func (rcv *SysCfgPcsGroup) UnPack() *SysCfgPcsGroupT { + if rcv == nil { return nil } + t := &SysCfgPcsGroupT{} + rcv.UnPackTo(t) + return t +} + type SysCfgPcsGroup struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgPcsSet.go b/pkg/fbs/motion/core/fbtypes/SysCfgPcsSet.go index 0606237..ae4509e 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgPcsSet.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgPcsSet.go @@ -7,6 +7,140 @@ import ( ) /// configuration of a single set for the product coordiate system of a kinematics +type SysCfgPcsSetT struct { + SetName string + OffsetXYZ []float64 + Orientation []float64 + OffsetAux []float64 + RelativeToPCS bool + OffsetXYZUnits []string + OrientationUnits []string + OffsetAuxUnits []string +} + +func (t *SysCfgPcsSetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + setNameOffset := builder.CreateString(t.SetName) + offsetXYZOffset := flatbuffers.UOffsetT(0) + if t.OffsetXYZ != nil { + offsetXYZLength := len(t.OffsetXYZ) + SysCfgPcsSetStartOffsetXYZVector(builder, offsetXYZLength) + for j := offsetXYZLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.OffsetXYZ[j]) + } + offsetXYZOffset = builder.EndVector(offsetXYZLength) + } + orientationOffset := flatbuffers.UOffsetT(0) + if t.Orientation != nil { + orientationLength := len(t.Orientation) + SysCfgPcsSetStartOrientationVector(builder, orientationLength) + for j := orientationLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Orientation[j]) + } + orientationOffset = builder.EndVector(orientationLength) + } + offsetAuxOffset := flatbuffers.UOffsetT(0) + if t.OffsetAux != nil { + offsetAuxLength := len(t.OffsetAux) + SysCfgPcsSetStartOffsetAuxVector(builder, offsetAuxLength) + for j := offsetAuxLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.OffsetAux[j]) + } + offsetAuxOffset = builder.EndVector(offsetAuxLength) + } + offsetXYZUnitsOffset := flatbuffers.UOffsetT(0) + if t.OffsetXYZUnits != nil { + offsetXYZUnitsLength := len(t.OffsetXYZUnits) + offsetXYZUnitsOffsets := make([]flatbuffers.UOffsetT, offsetXYZUnitsLength) + for j := 0; j < offsetXYZUnitsLength; j++ { + offsetXYZUnitsOffsets[j] = builder.CreateString(t.OffsetXYZUnits[j]) + } + SysCfgPcsSetStartOffsetXYZUnitsVector(builder, offsetXYZUnitsLength) + for j := offsetXYZUnitsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(offsetXYZUnitsOffsets[j]) + } + offsetXYZUnitsOffset = builder.EndVector(offsetXYZUnitsLength) + } + orientationUnitsOffset := flatbuffers.UOffsetT(0) + if t.OrientationUnits != nil { + orientationUnitsLength := len(t.OrientationUnits) + orientationUnitsOffsets := make([]flatbuffers.UOffsetT, orientationUnitsLength) + for j := 0; j < orientationUnitsLength; j++ { + orientationUnitsOffsets[j] = builder.CreateString(t.OrientationUnits[j]) + } + SysCfgPcsSetStartOrientationUnitsVector(builder, orientationUnitsLength) + for j := orientationUnitsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(orientationUnitsOffsets[j]) + } + orientationUnitsOffset = builder.EndVector(orientationUnitsLength) + } + offsetAuxUnitsOffset := flatbuffers.UOffsetT(0) + if t.OffsetAuxUnits != nil { + offsetAuxUnitsLength := len(t.OffsetAuxUnits) + offsetAuxUnitsOffsets := make([]flatbuffers.UOffsetT, offsetAuxUnitsLength) + for j := 0; j < offsetAuxUnitsLength; j++ { + offsetAuxUnitsOffsets[j] = builder.CreateString(t.OffsetAuxUnits[j]) + } + SysCfgPcsSetStartOffsetAuxUnitsVector(builder, offsetAuxUnitsLength) + for j := offsetAuxUnitsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(offsetAuxUnitsOffsets[j]) + } + offsetAuxUnitsOffset = builder.EndVector(offsetAuxUnitsLength) + } + SysCfgPcsSetStart(builder) + SysCfgPcsSetAddSetName(builder, setNameOffset) + SysCfgPcsSetAddOffsetXYZ(builder, offsetXYZOffset) + SysCfgPcsSetAddOrientation(builder, orientationOffset) + SysCfgPcsSetAddOffsetAux(builder, offsetAuxOffset) + SysCfgPcsSetAddRelativeToPCS(builder, t.RelativeToPCS) + SysCfgPcsSetAddOffsetXYZUnits(builder, offsetXYZUnitsOffset) + SysCfgPcsSetAddOrientationUnits(builder, orientationUnitsOffset) + SysCfgPcsSetAddOffsetAuxUnits(builder, offsetAuxUnitsOffset) + return SysCfgPcsSetEnd(builder) +} + +func (rcv *SysCfgPcsSet) UnPackTo(t *SysCfgPcsSetT) { + t.SetName = string(rcv.SetName()) + offsetXYZLength := rcv.OffsetXYZLength() + t.OffsetXYZ = make([]float64, offsetXYZLength) + for j := 0; j < offsetXYZLength; j++ { + t.OffsetXYZ[j] = rcv.OffsetXYZ(j) + } + orientationLength := rcv.OrientationLength() + t.Orientation = make([]float64, orientationLength) + for j := 0; j < orientationLength; j++ { + t.Orientation[j] = rcv.Orientation(j) + } + offsetAuxLength := rcv.OffsetAuxLength() + t.OffsetAux = make([]float64, offsetAuxLength) + for j := 0; j < offsetAuxLength; j++ { + t.OffsetAux[j] = rcv.OffsetAux(j) + } + t.RelativeToPCS = rcv.RelativeToPCS() + offsetXYZUnitsLength := rcv.OffsetXYZUnitsLength() + t.OffsetXYZUnits = make([]string, offsetXYZUnitsLength) + for j := 0; j < offsetXYZUnitsLength; j++ { + t.OffsetXYZUnits[j] = string(rcv.OffsetXYZUnits(j)) + } + orientationUnitsLength := rcv.OrientationUnitsLength() + t.OrientationUnits = make([]string, orientationUnitsLength) + for j := 0; j < orientationUnitsLength; j++ { + t.OrientationUnits[j] = string(rcv.OrientationUnits(j)) + } + offsetAuxUnitsLength := rcv.OffsetAuxUnitsLength() + t.OffsetAuxUnits = make([]string, offsetAuxUnitsLength) + for j := 0; j < offsetAuxUnitsLength; j++ { + t.OffsetAuxUnits[j] = string(rcv.OffsetAuxUnits(j)) + } +} + +func (rcv *SysCfgPcsSet) UnPack() *SysCfgPcsSetT { + if rcv == nil { return nil } + t := &SysCfgPcsSetT{} + rcv.UnPackTo(t) + return t +} + type SysCfgPcsSet struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgSafeArea.go b/pkg/fbs/motion/core/fbtypes/SysCfgSafeArea.go index 48975ac..e1cb3d9 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgSafeArea.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgSafeArea.go @@ -7,6 +7,58 @@ import ( ) /// configuration of a single safe area or work area +type SysCfgSafeAreaT struct { + Name string + CoordSystem string + Type SafeAreaType + Box []*SysCfgSafeAreaBoxT +} + +func (t *SysCfgSafeAreaT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + coordSystemOffset := builder.CreateString(t.CoordSystem) + boxOffset := flatbuffers.UOffsetT(0) + if t.Box != nil { + boxLength := len(t.Box) + boxOffsets := make([]flatbuffers.UOffsetT, boxLength) + for j := 0; j < boxLength; j++ { + boxOffsets[j] = t.Box[j].Pack(builder) + } + SysCfgSafeAreaStartBoxVector(builder, boxLength) + for j := boxLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(boxOffsets[j]) + } + boxOffset = builder.EndVector(boxLength) + } + SysCfgSafeAreaStart(builder) + SysCfgSafeAreaAddName(builder, nameOffset) + SysCfgSafeAreaAddCoordSystem(builder, coordSystemOffset) + SysCfgSafeAreaAddType(builder, t.Type) + SysCfgSafeAreaAddBox(builder, boxOffset) + return SysCfgSafeAreaEnd(builder) +} + +func (rcv *SysCfgSafeArea) UnPackTo(t *SysCfgSafeAreaT) { + t.Name = string(rcv.Name()) + t.CoordSystem = string(rcv.CoordSystem()) + t.Type = rcv.Type() + boxLength := rcv.BoxLength() + t.Box = make([]*SysCfgSafeAreaBoxT, boxLength) + for j := 0; j < boxLength; j++ { + x := SysCfgSafeAreaBox{} + rcv.Box(&x, j) + t.Box[j] = x.UnPack() + } +} + +func (rcv *SysCfgSafeArea) UnPack() *SysCfgSafeAreaT { + if rcv == nil { return nil } + t := &SysCfgSafeAreaT{} + rcv.UnPackTo(t) + return t +} + type SysCfgSafeArea struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaAll.go b/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaAll.go index 6f03a8a..6620b46 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaAll.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaAll.go @@ -7,6 +7,47 @@ import ( ) /// configuration of all safe areas and work areas for the whole motion system +type SysCfgSafeAreaAllT struct { + SafeAreas []*SysCfgSafeAreaT +} + +func (t *SysCfgSafeAreaAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + safeAreasOffset := flatbuffers.UOffsetT(0) + if t.SafeAreas != nil { + safeAreasLength := len(t.SafeAreas) + safeAreasOffsets := make([]flatbuffers.UOffsetT, safeAreasLength) + for j := 0; j < safeAreasLength; j++ { + safeAreasOffsets[j] = t.SafeAreas[j].Pack(builder) + } + SysCfgSafeAreaAllStartSafeAreasVector(builder, safeAreasLength) + for j := safeAreasLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(safeAreasOffsets[j]) + } + safeAreasOffset = builder.EndVector(safeAreasLength) + } + SysCfgSafeAreaAllStart(builder) + SysCfgSafeAreaAllAddSafeAreas(builder, safeAreasOffset) + return SysCfgSafeAreaAllEnd(builder) +} + +func (rcv *SysCfgSafeAreaAll) UnPackTo(t *SysCfgSafeAreaAllT) { + safeAreasLength := rcv.SafeAreasLength() + t.SafeAreas = make([]*SysCfgSafeAreaT, safeAreasLength) + for j := 0; j < safeAreasLength; j++ { + x := SysCfgSafeArea{} + rcv.SafeAreas(&x, j) + t.SafeAreas[j] = x.UnPack() + } +} + +func (rcv *SysCfgSafeAreaAll) UnPack() *SysCfgSafeAreaAllT { + if rcv == nil { return nil } + t := &SysCfgSafeAreaAllT{} + rcv.UnPackTo(t) + return t +} + type SysCfgSafeAreaAll struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaBox.go b/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaBox.go index 9f3c8ce..b694f6a 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaBox.go +++ b/pkg/fbs/motion/core/fbtypes/SysCfgSafeAreaBox.go @@ -7,6 +7,38 @@ import ( ) /// configuration of the limits in a single dimension of the box of a single safe area +type SysCfgSafeAreaBoxT struct { + Min float64 + Max float64 + Unit string + Active bool +} + +func (t *SysCfgSafeAreaBoxT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + unitOffset := builder.CreateString(t.Unit) + SysCfgSafeAreaBoxStart(builder) + SysCfgSafeAreaBoxAddMin(builder, t.Min) + SysCfgSafeAreaBoxAddMax(builder, t.Max) + SysCfgSafeAreaBoxAddUnit(builder, unitOffset) + SysCfgSafeAreaBoxAddActive(builder, t.Active) + return SysCfgSafeAreaBoxEnd(builder) +} + +func (rcv *SysCfgSafeAreaBox) UnPackTo(t *SysCfgSafeAreaBoxT) { + t.Min = rcv.Min() + t.Max = rcv.Max() + t.Unit = string(rcv.Unit()) + t.Active = rcv.Active() +} + +func (rcv *SysCfgSafeAreaBox) UnPack() *SysCfgSafeAreaBoxT { + if rcv == nil { return nil } + t := &SysCfgSafeAreaBoxT{} + rcv.UnPackTo(t) + return t +} + type SysCfgSafeAreaBox struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/SysCmdReset.go b/pkg/fbs/motion/core/fbtypes/SysCmdReset.go index 8528cdd..c3439ed 100644 --- a/pkg/fbs/motion/core/fbtypes/SysCmdReset.go +++ b/pkg/fbs/motion/core/fbtypes/SysCmdReset.go @@ -7,6 +7,28 @@ import ( ) /// request structure for the ResetAllMotionObjects nodes +type SysCmdResetT struct { + Type SysResetType +} + +func (t *SysCmdResetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SysCmdResetStart(builder) + SysCmdResetAddType(builder, t.Type) + return SysCmdResetEnd(builder) +} + +func (rcv *SysCmdReset) UnPackTo(t *SysCmdResetT) { + t.Type = rcv.Type() +} + +func (rcv *SysCmdReset) UnPack() *SysCmdResetT { + if rcv == nil { return nil } + t := &SysCmdResetT{} + rcv.UnPackTo(t) + return t +} + type SysCmdReset struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/UnitCfgKin.go b/pkg/fbs/motion/core/fbtypes/UnitCfgKin.go index d303835..038afc4 100644 --- a/pkg/fbs/motion/core/fbtypes/UnitCfgKin.go +++ b/pkg/fbs/motion/core/fbtypes/UnitCfgKin.go @@ -7,6 +7,67 @@ import ( ) /// General unit configuration for a kinematics object +type UnitCfgKinT struct { + Default []*UnitCfgObjSingleT + Position []string +} + +func (t *UnitCfgKinT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + defaultOffset := flatbuffers.UOffsetT(0) + if t.Default != nil { + defaultLength := len(t.Default) + defaultOffsets := make([]flatbuffers.UOffsetT, defaultLength) + for j := 0; j < defaultLength; j++ { + defaultOffsets[j] = t.Default[j].Pack(builder) + } + UnitCfgKinStartDefaultVector(builder, defaultLength) + for j := defaultLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(defaultOffsets[j]) + } + defaultOffset = builder.EndVector(defaultLength) + } + positionOffset := flatbuffers.UOffsetT(0) + if t.Position != nil { + positionLength := len(t.Position) + positionOffsets := make([]flatbuffers.UOffsetT, positionLength) + for j := 0; j < positionLength; j++ { + positionOffsets[j] = builder.CreateString(t.Position[j]) + } + UnitCfgKinStartPositionVector(builder, positionLength) + for j := positionLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(positionOffsets[j]) + } + positionOffset = builder.EndVector(positionLength) + } + UnitCfgKinStart(builder) + UnitCfgKinAddDefault(builder, defaultOffset) + UnitCfgKinAddPosition(builder, positionOffset) + return UnitCfgKinEnd(builder) +} + +func (rcv *UnitCfgKin) UnPackTo(t *UnitCfgKinT) { + defaultLength := rcv.DefaultLength() + t.Default = make([]*UnitCfgObjSingleT, defaultLength) + for j := 0; j < defaultLength; j++ { + x := UnitCfgObjSingle{} + rcv.Default(&x, j) + t.Default[j] = x.UnPack() + } + positionLength := rcv.PositionLength() + t.Position = make([]string, positionLength) + for j := 0; j < positionLength; j++ { + t.Position[j] = string(rcv.Position(j)) + } +} + +func (rcv *UnitCfgKin) UnPack() *UnitCfgKinT { + if rcv == nil { return nil } + t := &UnitCfgKinT{} + rcv.UnPackTo(t) + return t +} + type UnitCfgKin struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/UnitCfgObj.go b/pkg/fbs/motion/core/fbtypes/UnitCfgObj.go index 75d7146..551e69f 100644 --- a/pkg/fbs/motion/core/fbtypes/UnitCfgObj.go +++ b/pkg/fbs/motion/core/fbtypes/UnitCfgObj.go @@ -7,6 +7,47 @@ import ( ) /// General unit configuration for a motion object +type UnitCfgObjT struct { + Default []*UnitCfgObjSingleT +} + +func (t *UnitCfgObjT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + defaultOffset := flatbuffers.UOffsetT(0) + if t.Default != nil { + defaultLength := len(t.Default) + defaultOffsets := make([]flatbuffers.UOffsetT, defaultLength) + for j := 0; j < defaultLength; j++ { + defaultOffsets[j] = t.Default[j].Pack(builder) + } + UnitCfgObjStartDefaultVector(builder, defaultLength) + for j := defaultLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(defaultOffsets[j]) + } + defaultOffset = builder.EndVector(defaultLength) + } + UnitCfgObjStart(builder) + UnitCfgObjAddDefault(builder, defaultOffset) + return UnitCfgObjEnd(builder) +} + +func (rcv *UnitCfgObj) UnPackTo(t *UnitCfgObjT) { + defaultLength := rcv.DefaultLength() + t.Default = make([]*UnitCfgObjSingleT, defaultLength) + for j := 0; j < defaultLength; j++ { + x := UnitCfgObjSingle{} + rcv.Default(&x, j) + t.Default[j] = x.UnPack() + } +} + +func (rcv *UnitCfgObj) UnPack() *UnitCfgObjT { + if rcv == nil { return nil } + t := &UnitCfgObjT{} + rcv.UnPackTo(t) + return t +} + type UnitCfgObj struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/UnitCfgObjSingle.go b/pkg/fbs/motion/core/fbtypes/UnitCfgObjSingle.go index 9f883ad..15c865d 100644 --- a/pkg/fbs/motion/core/fbtypes/UnitCfgObjSingle.go +++ b/pkg/fbs/motion/core/fbtypes/UnitCfgObjSingle.go @@ -7,6 +7,33 @@ import ( ) /// Single entry of the general unit configuration for a motion object +type UnitCfgObjSingleT struct { + ValueType string + Abbreviation string +} + +func (t *UnitCfgObjSingleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueTypeOffset := builder.CreateString(t.ValueType) + abbreviationOffset := builder.CreateString(t.Abbreviation) + UnitCfgObjSingleStart(builder) + UnitCfgObjSingleAddValueType(builder, valueTypeOffset) + UnitCfgObjSingleAddAbbreviation(builder, abbreviationOffset) + return UnitCfgObjSingleEnd(builder) +} + +func (rcv *UnitCfgObjSingle) UnPackTo(t *UnitCfgObjSingleT) { + t.ValueType = string(rcv.ValueType()) + t.Abbreviation = string(rcv.Abbreviation()) +} + +func (rcv *UnitCfgObjSingle) UnPack() *UnitCfgObjSingleT { + if rcv == nil { return nil } + t := &UnitCfgObjSingleT{} + rcv.UnPackTo(t) + return t +} + type UnitCfgObjSingle struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/UnitDataAll.go b/pkg/fbs/motion/core/fbtypes/UnitDataAll.go index 0eee679..1d27fde 100644 --- a/pkg/fbs/motion/core/fbtypes/UnitDataAll.go +++ b/pkg/fbs/motion/core/fbtypes/UnitDataAll.go @@ -7,6 +7,47 @@ import ( ) /// Data of all supported units +type UnitDataAllT struct { + Supported []*UnitDataSingleT +} + +func (t *UnitDataAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + supportedOffset := flatbuffers.UOffsetT(0) + if t.Supported != nil { + supportedLength := len(t.Supported) + supportedOffsets := make([]flatbuffers.UOffsetT, supportedLength) + for j := 0; j < supportedLength; j++ { + supportedOffsets[j] = t.Supported[j].Pack(builder) + } + UnitDataAllStartSupportedVector(builder, supportedLength) + for j := supportedLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(supportedOffsets[j]) + } + supportedOffset = builder.EndVector(supportedLength) + } + UnitDataAllStart(builder) + UnitDataAllAddSupported(builder, supportedOffset) + return UnitDataAllEnd(builder) +} + +func (rcv *UnitDataAll) UnPackTo(t *UnitDataAllT) { + supportedLength := rcv.SupportedLength() + t.Supported = make([]*UnitDataSingleT, supportedLength) + for j := 0; j < supportedLength; j++ { + x := UnitDataSingle{} + rcv.Supported(&x, j) + t.Supported[j] = x.UnPack() + } +} + +func (rcv *UnitDataAll) UnPack() *UnitDataAllT { + if rcv == nil { return nil } + t := &UnitDataAllT{} + rcv.UnPackTo(t) + return t +} + type UnitDataAll struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/UnitDataSingle.go b/pkg/fbs/motion/core/fbtypes/UnitDataSingle.go index c706cde..fb06e18 100644 --- a/pkg/fbs/motion/core/fbtypes/UnitDataSingle.go +++ b/pkg/fbs/motion/core/fbtypes/UnitDataSingle.go @@ -7,6 +7,48 @@ import ( ) /// informations of a single unit, that is supported by the system +type UnitDataSingleT struct { + Name string + UnitObjType string + UnitValueType string + Abbreviation string + AbbreviationURI string + IsDefault bool +} + +func (t *UnitDataSingleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + unitObjTypeOffset := builder.CreateString(t.UnitObjType) + unitValueTypeOffset := builder.CreateString(t.UnitValueType) + abbreviationOffset := builder.CreateString(t.Abbreviation) + abbreviationURIOffset := builder.CreateString(t.AbbreviationURI) + UnitDataSingleStart(builder) + UnitDataSingleAddName(builder, nameOffset) + UnitDataSingleAddUnitObjType(builder, unitObjTypeOffset) + UnitDataSingleAddUnitValueType(builder, unitValueTypeOffset) + UnitDataSingleAddAbbreviation(builder, abbreviationOffset) + UnitDataSingleAddAbbreviationURI(builder, abbreviationURIOffset) + UnitDataSingleAddIsDefault(builder, t.IsDefault) + return UnitDataSingleEnd(builder) +} + +func (rcv *UnitDataSingle) UnPackTo(t *UnitDataSingleT) { + t.Name = string(rcv.Name()) + t.UnitObjType = string(rcv.UnitObjType()) + t.UnitValueType = string(rcv.UnitValueType()) + t.Abbreviation = string(rcv.Abbreviation()) + t.AbbreviationURI = string(rcv.AbbreviationURI()) + t.IsDefault = rcv.IsDefault() +} + +func (rcv *UnitDataSingle) UnPack() *UnitDataSingleT { + if rcv == nil { return nil } + t := &UnitDataSingleT{} + rcv.UnPackTo(t) + return t +} + type UnitDataSingle struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/actCmdJobObjects.go b/pkg/fbs/motion/core/fbtypes/actCmdJobObjects.go index 5b16604..d874b7b 100644 --- a/pkg/fbs/motion/core/fbtypes/actCmdJobObjects.go +++ b/pkg/fbs/motion/core/fbtypes/actCmdJobObjects.go @@ -7,6 +7,49 @@ import ( ) /// get informations of a single active command +type actCmdJobObjectsT struct { + CmdName string + JobObjects []string +} + +func (t *actCmdJobObjectsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdNameOffset := builder.CreateString(t.CmdName) + jobObjectsOffset := flatbuffers.UOffsetT(0) + if t.JobObjects != nil { + jobObjectsLength := len(t.JobObjects) + jobObjectsOffsets := make([]flatbuffers.UOffsetT, jobObjectsLength) + for j := 0; j < jobObjectsLength; j++ { + jobObjectsOffsets[j] = builder.CreateString(t.JobObjects[j]) + } + actCmdJobObjectsStartJobObjectsVector(builder, jobObjectsLength) + for j := jobObjectsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(jobObjectsOffsets[j]) + } + jobObjectsOffset = builder.EndVector(jobObjectsLength) + } + actCmdJobObjectsStart(builder) + actCmdJobObjectsAddCmdName(builder, cmdNameOffset) + actCmdJobObjectsAddJobObjects(builder, jobObjectsOffset) + return actCmdJobObjectsEnd(builder) +} + +func (rcv *actCmdJobObjects) UnPackTo(t *actCmdJobObjectsT) { + t.CmdName = string(rcv.CmdName()) + jobObjectsLength := rcv.JobObjectsLength() + t.JobObjects = make([]string, jobObjectsLength) + for j := 0; j < jobObjectsLength; j++ { + t.JobObjects[j] = string(rcv.JobObjects(j)) + } +} + +func (rcv *actCmdJobObjects) UnPack() *actCmdJobObjectsT { + if rcv == nil { return nil } + t := &actCmdJobObjectsT{} + rcv.UnPackTo(t) + return t +} + type actCmdJobObjects struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/allActCmdJobObjects.go b/pkg/fbs/motion/core/fbtypes/allActCmdJobObjects.go index 946e773..ede261b 100644 --- a/pkg/fbs/motion/core/fbtypes/allActCmdJobObjects.go +++ b/pkg/fbs/motion/core/fbtypes/allActCmdJobObjects.go @@ -7,6 +7,47 @@ import ( ) /// get informations of all active commands of a single motion object +type allActCmdJobObjectsT struct { + Cmds []*actCmdJobObjectsT +} + +func (t *allActCmdJobObjectsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdsOffset := flatbuffers.UOffsetT(0) + if t.Cmds != nil { + cmdsLength := len(t.Cmds) + cmdsOffsets := make([]flatbuffers.UOffsetT, cmdsLength) + for j := 0; j < cmdsLength; j++ { + cmdsOffsets[j] = t.Cmds[j].Pack(builder) + } + allActCmdJobObjectsStartCmdsVector(builder, cmdsLength) + for j := cmdsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(cmdsOffsets[j]) + } + cmdsOffset = builder.EndVector(cmdsLength) + } + allActCmdJobObjectsStart(builder) + allActCmdJobObjectsAddCmds(builder, cmdsOffset) + return allActCmdJobObjectsEnd(builder) +} + +func (rcv *allActCmdJobObjects) UnPackTo(t *allActCmdJobObjectsT) { + cmdsLength := rcv.CmdsLength() + t.Cmds = make([]*actCmdJobObjectsT, cmdsLength) + for j := 0; j < cmdsLength; j++ { + x := actCmdJobObjects{} + rcv.Cmds(&x, j) + t.Cmds[j] = x.UnPack() + } +} + +func (rcv *allActCmdJobObjects) UnPack() *allActCmdJobObjectsT { + if rcv == nil { return nil } + t := &allActCmdJobObjectsT{} + rcv.UnPackTo(t) + return t +} + type allActCmdJobObjects struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/allDebugCmdInfo.go b/pkg/fbs/motion/core/fbtypes/allDebugCmdInfo.go index 9f08fe7..29faebd 100644 --- a/pkg/fbs/motion/core/fbtypes/allDebugCmdInfo.go +++ b/pkg/fbs/motion/core/fbtypes/allDebugCmdInfo.go @@ -7,6 +7,69 @@ import ( ) /// get informations of all active commands and commands that were recently executed of a single motion object +type allDebugCmdInfoT struct { + MainCmds []*debugCmdInfoT + AddCmds []*debugCmdInfoT +} + +func (t *allDebugCmdInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mainCmdsOffset := flatbuffers.UOffsetT(0) + if t.MainCmds != nil { + mainCmdsLength := len(t.MainCmds) + mainCmdsOffsets := make([]flatbuffers.UOffsetT, mainCmdsLength) + for j := 0; j < mainCmdsLength; j++ { + mainCmdsOffsets[j] = t.MainCmds[j].Pack(builder) + } + allDebugCmdInfoStartMainCmdsVector(builder, mainCmdsLength) + for j := mainCmdsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(mainCmdsOffsets[j]) + } + mainCmdsOffset = builder.EndVector(mainCmdsLength) + } + addCmdsOffset := flatbuffers.UOffsetT(0) + if t.AddCmds != nil { + addCmdsLength := len(t.AddCmds) + addCmdsOffsets := make([]flatbuffers.UOffsetT, addCmdsLength) + for j := 0; j < addCmdsLength; j++ { + addCmdsOffsets[j] = t.AddCmds[j].Pack(builder) + } + allDebugCmdInfoStartAddCmdsVector(builder, addCmdsLength) + for j := addCmdsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(addCmdsOffsets[j]) + } + addCmdsOffset = builder.EndVector(addCmdsLength) + } + allDebugCmdInfoStart(builder) + allDebugCmdInfoAddMainCmds(builder, mainCmdsOffset) + allDebugCmdInfoAddAddCmds(builder, addCmdsOffset) + return allDebugCmdInfoEnd(builder) +} + +func (rcv *allDebugCmdInfo) UnPackTo(t *allDebugCmdInfoT) { + mainCmdsLength := rcv.MainCmdsLength() + t.MainCmds = make([]*debugCmdInfoT, mainCmdsLength) + for j := 0; j < mainCmdsLength; j++ { + x := debugCmdInfo{} + rcv.MainCmds(&x, j) + t.MainCmds[j] = x.UnPack() + } + addCmdsLength := rcv.AddCmdsLength() + t.AddCmds = make([]*debugCmdInfoT, addCmdsLength) + for j := 0; j < addCmdsLength; j++ { + x := debugCmdInfo{} + rcv.AddCmds(&x, j) + t.AddCmds[j] = x.UnPack() + } +} + +func (rcv *allDebugCmdInfo) UnPack() *allDebugCmdInfoT { + if rcv == nil { return nil } + t := &allDebugCmdInfoT{} + rcv.UnPackTo(t) + return t +} + type allDebugCmdInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/debugCmdInfo.go b/pkg/fbs/motion/core/fbtypes/debugCmdInfo.go index 5474396..db787ce 100644 --- a/pkg/fbs/motion/core/fbtypes/debugCmdInfo.go +++ b/pkg/fbs/motion/core/fbtypes/debugCmdInfo.go @@ -7,6 +7,60 @@ import ( ) /// get informations of a single active command +type debugCmdInfoT struct { + CmdName string + JobObjects []string + State string + CmdID uint64 + PrepLevel string +} + +func (t *debugCmdInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdNameOffset := builder.CreateString(t.CmdName) + jobObjectsOffset := flatbuffers.UOffsetT(0) + if t.JobObjects != nil { + jobObjectsLength := len(t.JobObjects) + jobObjectsOffsets := make([]flatbuffers.UOffsetT, jobObjectsLength) + for j := 0; j < jobObjectsLength; j++ { + jobObjectsOffsets[j] = builder.CreateString(t.JobObjects[j]) + } + debugCmdInfoStartJobObjectsVector(builder, jobObjectsLength) + for j := jobObjectsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(jobObjectsOffsets[j]) + } + jobObjectsOffset = builder.EndVector(jobObjectsLength) + } + stateOffset := builder.CreateString(t.State) + prepLevelOffset := builder.CreateString(t.PrepLevel) + debugCmdInfoStart(builder) + debugCmdInfoAddCmdName(builder, cmdNameOffset) + debugCmdInfoAddJobObjects(builder, jobObjectsOffset) + debugCmdInfoAddState(builder, stateOffset) + debugCmdInfoAddCmdID(builder, t.CmdID) + debugCmdInfoAddPrepLevel(builder, prepLevelOffset) + return debugCmdInfoEnd(builder) +} + +func (rcv *debugCmdInfo) UnPackTo(t *debugCmdInfoT) { + t.CmdName = string(rcv.CmdName()) + jobObjectsLength := rcv.JobObjectsLength() + t.JobObjects = make([]string, jobObjectsLength) + for j := 0; j < jobObjectsLength; j++ { + t.JobObjects[j] = string(rcv.JobObjects(j)) + } + t.State = string(rcv.State()) + t.CmdID = rcv.CmdID() + t.PrepLevel = string(rcv.PrepLevel()) +} + +func (rcv *debugCmdInfo) UnPack() *debugCmdInfoT { + if rcv == nil { return nil } + t := &debugCmdInfoT{} + rcv.UnPackTo(t) + return t +} + type debugCmdInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/core/fbtypes/dummyFbs.go b/pkg/fbs/motion/core/fbtypes/dummyFbs.go index d8a0f38..ab97411 100644 --- a/pkg/fbs/motion/core/fbtypes/dummyFbs.go +++ b/pkg/fbs/motion/core/fbtypes/dummyFbs.go @@ -7,6 +7,54 @@ import ( ) /// dummy flatbuffer for tests +type dummyFbsT struct { + DummyByte int8 + DummyStr string + DummyInt int32 + DummyDouble float64 + DummyDoublePtr []float64 +} + +func (t *dummyFbsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + dummyStrOffset := builder.CreateString(t.DummyStr) + dummyDoublePtrOffset := flatbuffers.UOffsetT(0) + if t.DummyDoublePtr != nil { + dummyDoublePtrLength := len(t.DummyDoublePtr) + dummyFbsStartDummyDoublePtrVector(builder, dummyDoublePtrLength) + for j := dummyDoublePtrLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.DummyDoublePtr[j]) + } + dummyDoublePtrOffset = builder.EndVector(dummyDoublePtrLength) + } + dummyFbsStart(builder) + dummyFbsAddDummyByte(builder, t.DummyByte) + dummyFbsAddDummyStr(builder, dummyStrOffset) + dummyFbsAddDummyInt(builder, t.DummyInt) + dummyFbsAddDummyDouble(builder, t.DummyDouble) + dummyFbsAddDummyDoublePtr(builder, dummyDoublePtrOffset) + return dummyFbsEnd(builder) +} + +func (rcv *dummyFbs) UnPackTo(t *dummyFbsT) { + t.DummyByte = rcv.DummyByte() + t.DummyStr = string(rcv.DummyStr()) + t.DummyInt = rcv.DummyInt() + t.DummyDouble = rcv.DummyDouble() + dummyDoublePtrLength := rcv.DummyDoublePtrLength() + t.DummyDoublePtr = make([]float64, dummyDoublePtrLength) + for j := 0; j < dummyDoublePtrLength; j++ { + t.DummyDoublePtr[j] = rcv.DummyDoublePtr(j) + } +} + +func (rcv *dummyFbs) UnPack() *dummyFbsT { + if rcv == nil { return nil } + t := &dummyFbsT{} + rcv.UnPackTo(t) + return t +} + type dummyFbs struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/motion/ext/fbtypes/AxsCmdCtrlBasedHomingGantryData.go b/pkg/fbs/motion/ext/fbtypes/AxsCmdCtrlBasedHomingGantryData.go new file mode 100644 index 0000000..8541022 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/AxsCmdCtrlBasedHomingGantryData.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of control based gantry homing +type AxsCmdCtrlBasedHomingGantryDataT struct { + HomingParam *HomingParamT + HomingSlaveParam *HomingSlaveParamAllT +} + +func (t *AxsCmdCtrlBasedHomingGantryDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + homingParamOffset := t.HomingParam.Pack(builder) + homingSlaveParamOffset := t.HomingSlaveParam.Pack(builder) + AxsCmdCtrlBasedHomingGantryDataStart(builder) + AxsCmdCtrlBasedHomingGantryDataAddHomingParam(builder, homingParamOffset) + AxsCmdCtrlBasedHomingGantryDataAddHomingSlaveParam(builder, homingSlaveParamOffset) + return AxsCmdCtrlBasedHomingGantryDataEnd(builder) +} + +func (rcv *AxsCmdCtrlBasedHomingGantryData) UnPackTo(t *AxsCmdCtrlBasedHomingGantryDataT) { + t.HomingParam = rcv.HomingParam(nil).UnPack() + t.HomingSlaveParam = rcv.HomingSlaveParam(nil).UnPack() +} + +func (rcv *AxsCmdCtrlBasedHomingGantryData) UnPack() *AxsCmdCtrlBasedHomingGantryDataT { + if rcv == nil { return nil } + t := &AxsCmdCtrlBasedHomingGantryDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdCtrlBasedHomingGantryData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdCtrlBasedHomingGantryData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCtrlBasedHomingGantryData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdCtrlBasedHomingGantryData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdCtrlBasedHomingGantryData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCtrlBasedHomingGantryData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdCtrlBasedHomingGantryData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdCtrlBasedHomingGantryData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdCtrlBasedHomingGantryData) Table() flatbuffers.Table { + return rcv._tab +} + +/// homing basic parameters +func (rcv *AxsCmdCtrlBasedHomingGantryData) HomingParam(obj *HomingParam) *HomingParam { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(HomingParam) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// homing basic parameters +/// slave axes parameters +func (rcv *AxsCmdCtrlBasedHomingGantryData) HomingSlaveParam(obj *HomingSlaveParamAll) *HomingSlaveParamAll { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(HomingSlaveParamAll) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// slave axes parameters +func AxsCmdCtrlBasedHomingGantryDataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func AxsCmdCtrlBasedHomingGantryDataAddHomingParam(builder *flatbuffers.Builder, homingParam flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(homingParam), 0) +} +func AxsCmdCtrlBasedHomingGantryDataAddHomingSlaveParam(builder *flatbuffers.Builder, homingSlaveParam flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(homingSlaveParam), 0) +} +func AxsCmdCtrlBasedHomingGantryDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/AxsCmdFixedstopData.go b/pkg/fbs/motion/ext/fbtypes/AxsCmdFixedstopData.go new file mode 100644 index 0000000..ff7e17d --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/AxsCmdFixedstopData.go @@ -0,0 +1,145 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + motion__core__fbtypes "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/motion/core/fbtypes" +) + +/// parameters of the axis position commands +type AxsCmdFixedstopDataT struct { + Buffered bool + AxsPos float64 + MaxTrq float64 + Lim *motion__core__fbtypes.DynamicLimitsT +} + +func (t *AxsCmdFixedstopDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + limOffset := t.Lim.Pack(builder) + AxsCmdFixedstopDataStart(builder) + AxsCmdFixedstopDataAddBuffered(builder, t.Buffered) + AxsCmdFixedstopDataAddAxsPos(builder, t.AxsPos) + AxsCmdFixedstopDataAddMaxTrq(builder, t.MaxTrq) + AxsCmdFixedstopDataAddLim(builder, limOffset) + return AxsCmdFixedstopDataEnd(builder) +} + +func (rcv *AxsCmdFixedstopData) UnPackTo(t *AxsCmdFixedstopDataT) { + t.Buffered = rcv.Buffered() + t.AxsPos = rcv.AxsPos() + t.MaxTrq = rcv.MaxTrq() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *AxsCmdFixedstopData) UnPack() *AxsCmdFixedstopDataT { + if rcv == nil { return nil } + t := &AxsCmdFixedstopDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdFixedstopData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdFixedstopData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdFixedstopData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdFixedstopData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdFixedstopData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdFixedstopData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdFixedstopData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdFixedstopData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdFixedstopData) Table() flatbuffers.Table { + return rcv._tab +} + +/// buffered type for generic command +func (rcv *AxsCmdFixedstopData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// buffered type for generic command +func (rcv *AxsCmdFixedstopData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdFixedstopData) AxsPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdFixedstopData) MutateAxsPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// commanded force / torque limitiation +func (rcv *AxsCmdFixedstopData) MaxTrq() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded force / torque limitiation +func (rcv *AxsCmdFixedstopData) MutateMaxTrq(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +/// dynamic limits for the motion of this command +func (rcv *AxsCmdFixedstopData) Lim(obj *motion__core__fbtypes.DynamicLimits) *motion__core__fbtypes.DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(motion__core__fbtypes.DynamicLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// dynamic limits for the motion of this command +func AxsCmdFixedstopDataStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsCmdFixedstopDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(0, buffered, false) +} +func AxsCmdFixedstopDataAddAxsPos(builder *flatbuffers.Builder, axsPos float64) { + builder.PrependFloat64Slot(1, axsPos, 0.0) +} +func AxsCmdFixedstopDataAddMaxTrq(builder *flatbuffers.Builder, maxTrq float64) { + builder.PrependFloat64Slot(2, maxTrq, 0.0) +} +func AxsCmdFixedstopDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func AxsCmdFixedstopDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/AxsCmdHomingData.go b/pkg/fbs/motion/ext/fbtypes/AxsCmdHomingData.go new file mode 100644 index 0000000..b073617 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/AxsCmdHomingData.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis position commands +type AxsCmdHomingDataT struct { + Buffered bool + NewRefPos float64 +} + +func (t *AxsCmdHomingDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCmdHomingDataStart(builder) + AxsCmdHomingDataAddBuffered(builder, t.Buffered) + AxsCmdHomingDataAddNewRefPos(builder, t.NewRefPos) + return AxsCmdHomingDataEnd(builder) +} + +func (rcv *AxsCmdHomingData) UnPackTo(t *AxsCmdHomingDataT) { + t.Buffered = rcv.Buffered() + t.NewRefPos = rcv.NewRefPos() +} + +func (rcv *AxsCmdHomingData) UnPack() *AxsCmdHomingDataT { + if rcv == nil { return nil } + t := &AxsCmdHomingDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdHomingData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdHomingData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdHomingData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdHomingData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdHomingData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdHomingData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdHomingData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdHomingData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdHomingData) Table() flatbuffers.Table { + return rcv._tab +} + +/// buffered type for generic command +func (rcv *AxsCmdHomingData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// buffered type for generic command +func (rcv *AxsCmdHomingData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdHomingData) NewRefPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdHomingData) MutateNewRefPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func AxsCmdHomingDataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func AxsCmdHomingDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(0, buffered, false) +} +func AxsCmdHomingDataAddNewRefPos(builder *flatbuffers.Builder, newRefPos float64) { + builder.PrependFloat64Slot(1, newRefPos, 0.0) +} +func AxsCmdHomingDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/AxsCmdSetAbsPosData.go b/pkg/fbs/motion/ext/fbtypes/AxsCmdSetAbsPosData.go new file mode 100644 index 0000000..7aa7474 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/AxsCmdSetAbsPosData.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis position commands +type AxsCmdSetAbsPosDataT struct { + Buffered bool + AxsPos float64 +} + +func (t *AxsCmdSetAbsPosDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCmdSetAbsPosDataStart(builder) + AxsCmdSetAbsPosDataAddBuffered(builder, t.Buffered) + AxsCmdSetAbsPosDataAddAxsPos(builder, t.AxsPos) + return AxsCmdSetAbsPosDataEnd(builder) +} + +func (rcv *AxsCmdSetAbsPosData) UnPackTo(t *AxsCmdSetAbsPosDataT) { + t.Buffered = rcv.Buffered() + t.AxsPos = rcv.AxsPos() +} + +func (rcv *AxsCmdSetAbsPosData) UnPack() *AxsCmdSetAbsPosDataT { + if rcv == nil { return nil } + t := &AxsCmdSetAbsPosDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdSetAbsPosData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdSetAbsPosData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdSetAbsPosData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdSetAbsPosData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdSetAbsPosData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdSetAbsPosData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdSetAbsPosData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdSetAbsPosData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdSetAbsPosData) Table() flatbuffers.Table { + return rcv._tab +} + +/// buffered type for generic command +func (rcv *AxsCmdSetAbsPosData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// buffered type for generic command +func (rcv *AxsCmdSetAbsPosData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdSetAbsPosData) AxsPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target position (or increment for relative position command) +func (rcv *AxsCmdSetAbsPosData) MutateAxsPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func AxsCmdSetAbsPosDataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func AxsCmdSetAbsPosDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(0, buffered, false) +} +func AxsCmdSetAbsPosDataAddAxsPos(builder *flatbuffers.Builder, axsPos float64) { + builder.PrependFloat64Slot(1, axsPos, 0.0) +} +func AxsCmdSetAbsPosDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/CmdBufferType.go b/pkg/fbs/motion/ext/fbtypes/CmdBufferType.go new file mode 100644 index 0000000..2bbea95 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/CmdBufferType.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameter defines the buffer type of generic command +type CmdBufferTypeT struct { + Buffered bool +} + +func (t *CmdBufferTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + CmdBufferTypeStart(builder) + CmdBufferTypeAddBuffered(builder, t.Buffered) + return CmdBufferTypeEnd(builder) +} + +func (rcv *CmdBufferType) UnPackTo(t *CmdBufferTypeT) { + t.Buffered = rcv.Buffered() +} + +func (rcv *CmdBufferType) UnPack() *CmdBufferTypeT { + if rcv == nil { return nil } + t := &CmdBufferTypeT{} + rcv.UnPackTo(t) + return t +} + +type CmdBufferType struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdBufferType(buf []byte, offset flatbuffers.UOffsetT) *CmdBufferType { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdBufferType{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdBufferType(buf []byte, offset flatbuffers.UOffsetT) *CmdBufferType { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdBufferType{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdBufferType) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdBufferType) Table() flatbuffers.Table { + return rcv._tab +} + +/// buffered type for generic command +func (rcv *CmdBufferType) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// buffered type for generic command +func (rcv *CmdBufferType) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func CmdBufferTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func CmdBufferTypeAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(0, buffered, false) +} +func CmdBufferTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/HomingParam.go b/pkg/fbs/motion/ext/fbtypes/HomingParam.go new file mode 100644 index 0000000..b862121 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/HomingParam.go @@ -0,0 +1,184 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + motion__core__fbtypes "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/motion/core/fbtypes" +) + +/// set of homing parameters +type HomingParamT struct { + NewRefPos float64 + TravelDisLim float64 + HomingDir string + RefType RefType + DynForward *motion__core__fbtypes.DynamicLimitsT + DynBackward *motion__core__fbtypes.DynamicLimitsT +} + +func (t *HomingParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + homingDirOffset := builder.CreateString(t.HomingDir) + dynForwardOffset := t.DynForward.Pack(builder) + dynBackwardOffset := t.DynBackward.Pack(builder) + HomingParamStart(builder) + HomingParamAddNewRefPos(builder, t.NewRefPos) + HomingParamAddTravelDisLim(builder, t.TravelDisLim) + HomingParamAddHomingDir(builder, homingDirOffset) + HomingParamAddRefType(builder, t.RefType) + HomingParamAddDynForward(builder, dynForwardOffset) + HomingParamAddDynBackward(builder, dynBackwardOffset) + return HomingParamEnd(builder) +} + +func (rcv *HomingParam) UnPackTo(t *HomingParamT) { + t.NewRefPos = rcv.NewRefPos() + t.TravelDisLim = rcv.TravelDisLim() + t.HomingDir = string(rcv.HomingDir()) + t.RefType = rcv.RefType() + t.DynForward = rcv.DynForward(nil).UnPack() + t.DynBackward = rcv.DynBackward(nil).UnPack() +} + +func (rcv *HomingParam) UnPack() *HomingParamT { + if rcv == nil { return nil } + t := &HomingParamT{} + rcv.UnPackTo(t) + return t +} + +type HomingParam struct { + _tab flatbuffers.Table +} + +func GetRootAsHomingParam(buf []byte, offset flatbuffers.UOffsetT) *HomingParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HomingParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsHomingParam(buf []byte, offset flatbuffers.UOffsetT) *HomingParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HomingParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *HomingParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HomingParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// commanded target position (or increment for relative position command +func (rcv *HomingParam) NewRefPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target position (or increment for relative position command +func (rcv *HomingParam) MutateNewRefPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// max travel distance to search the reference switch +func (rcv *HomingParam) TravelDisLim() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// max travel distance to search the reference switch +func (rcv *HomingParam) MutateTravelDisLim(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// homing direction +func (rcv *HomingParam) HomingDir() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// homing direction +/// reference type to indicates set which position as the reference position +func (rcv *HomingParam) RefType() RefType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return RefType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// reference type to indicates set which position as the reference position +func (rcv *HomingParam) MutateRefType(n RefType) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + +/// dynamic limit to search the reference switch(fast velocity) +func (rcv *HomingParam) DynForward(obj *motion__core__fbtypes.DynamicLimits) *motion__core__fbtypes.DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(motion__core__fbtypes.DynamicLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// dynamic limit to search the reference switch(fast velocity) +/// dynamic limit to move to reference switch(slow velocity) +func (rcv *HomingParam) DynBackward(obj *motion__core__fbtypes.DynamicLimits) *motion__core__fbtypes.DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(motion__core__fbtypes.DynamicLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// dynamic limit to move to reference switch(slow velocity) +func HomingParamStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func HomingParamAddNewRefPos(builder *flatbuffers.Builder, newRefPos float64) { + builder.PrependFloat64Slot(0, newRefPos, 0.0) +} +func HomingParamAddTravelDisLim(builder *flatbuffers.Builder, travelDisLim float64) { + builder.PrependFloat64Slot(1, travelDisLim, 0.0) +} +func HomingParamAddHomingDir(builder *flatbuffers.Builder, homingDir flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(homingDir), 0) +} +func HomingParamAddRefType(builder *flatbuffers.Builder, refType RefType) { + builder.PrependInt8Slot(3, int8(refType), 0) +} +func HomingParamAddDynForward(builder *flatbuffers.Builder, dynForward flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dynForward), 0) +} +func HomingParamAddDynBackward(builder *flatbuffers.Builder, dynBackward flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(dynBackward), 0) +} +func HomingParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamAll.go b/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamAll.go new file mode 100644 index 0000000..79a95dc --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamAll.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration of all slave axes parameters +type HomingSlaveParamAllT struct { + HomingSlaveParamAll []*HomingSlaveParamSingleT +} + +func (t *HomingSlaveParamAllT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + homingSlaveParamAllOffset := flatbuffers.UOffsetT(0) + if t.HomingSlaveParamAll != nil { + homingSlaveParamAllLength := len(t.HomingSlaveParamAll) + homingSlaveParamAllOffsets := make([]flatbuffers.UOffsetT, homingSlaveParamAllLength) + for j := 0; j < homingSlaveParamAllLength; j++ { + homingSlaveParamAllOffsets[j] = t.HomingSlaveParamAll[j].Pack(builder) + } + HomingSlaveParamAllStartHomingSlaveParamAllVector(builder, homingSlaveParamAllLength) + for j := homingSlaveParamAllLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(homingSlaveParamAllOffsets[j]) + } + homingSlaveParamAllOffset = builder.EndVector(homingSlaveParamAllLength) + } + HomingSlaveParamAllStart(builder) + HomingSlaveParamAllAddHomingSlaveParamAll(builder, homingSlaveParamAllOffset) + return HomingSlaveParamAllEnd(builder) +} + +func (rcv *HomingSlaveParamAll) UnPackTo(t *HomingSlaveParamAllT) { + homingSlaveParamAllLength := rcv.HomingSlaveParamAllLength() + t.HomingSlaveParamAll = make([]*HomingSlaveParamSingleT, homingSlaveParamAllLength) + for j := 0; j < homingSlaveParamAllLength; j++ { + x := HomingSlaveParamSingle{} + rcv.HomingSlaveParamAll(&x, j) + t.HomingSlaveParamAll[j] = x.UnPack() + } +} + +func (rcv *HomingSlaveParamAll) UnPack() *HomingSlaveParamAllT { + if rcv == nil { return nil } + t := &HomingSlaveParamAllT{} + rcv.UnPackTo(t) + return t +} + +type HomingSlaveParamAll struct { + _tab flatbuffers.Table +} + +func GetRootAsHomingSlaveParamAll(buf []byte, offset flatbuffers.UOffsetT) *HomingSlaveParamAll { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HomingSlaveParamAll{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsHomingSlaveParamAll(buf []byte, offset flatbuffers.UOffsetT) *HomingSlaveParamAll { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HomingSlaveParamAll{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *HomingSlaveParamAll) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HomingSlaveParamAll) Table() flatbuffers.Table { + return rcv._tab +} + +/// vector of all slave parameters +func (rcv *HomingSlaveParamAll) HomingSlaveParamAll(obj *HomingSlaveParamSingle, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *HomingSlaveParamAll) HomingSlaveParamAllLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of all slave parameters +func HomingSlaveParamAllStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func HomingSlaveParamAllAddHomingSlaveParamAll(builder *flatbuffers.Builder, homingSlaveParamAll flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(homingSlaveParamAll), 0) +} +func HomingSlaveParamAllStartHomingSlaveParamAllVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func HomingSlaveParamAllEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamSingle.go b/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamSingle.go new file mode 100644 index 0000000..f856a40 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/HomingSlaveParamSingle.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///slave axes parameter of control based gantry homing +type HomingSlaveParamSingleT struct { + SlaveId uint16 + NewRefPos float64 + MarkerSel RefMarkerSel +} + +func (t *HomingSlaveParamSingleT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + HomingSlaveParamSingleStart(builder) + HomingSlaveParamSingleAddSlaveId(builder, t.SlaveId) + HomingSlaveParamSingleAddNewRefPos(builder, t.NewRefPos) + HomingSlaveParamSingleAddMarkerSel(builder, t.MarkerSel) + return HomingSlaveParamSingleEnd(builder) +} + +func (rcv *HomingSlaveParamSingle) UnPackTo(t *HomingSlaveParamSingleT) { + t.SlaveId = rcv.SlaveId() + t.NewRefPos = rcv.NewRefPos() + t.MarkerSel = rcv.MarkerSel() +} + +func (rcv *HomingSlaveParamSingle) UnPack() *HomingSlaveParamSingleT { + if rcv == nil { return nil } + t := &HomingSlaveParamSingleT{} + rcv.UnPackTo(t) + return t +} + +type HomingSlaveParamSingle struct { + _tab flatbuffers.Table +} + +func GetRootAsHomingSlaveParamSingle(buf []byte, offset flatbuffers.UOffsetT) *HomingSlaveParamSingle { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HomingSlaveParamSingle{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsHomingSlaveParamSingle(buf []byte, offset flatbuffers.UOffsetT) *HomingSlaveParamSingle { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HomingSlaveParamSingle{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *HomingSlaveParamSingle) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HomingSlaveParamSingle) Table() flatbuffers.Table { + return rcv._tab +} + +///the id of slave axis +func (rcv *HomingSlaveParamSingle) SlaveId() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///the id of slave axis +func (rcv *HomingSlaveParamSingle) MutateSlaveId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +///commanded reference position of slave axis +func (rcv *HomingSlaveParamSingle) NewRefPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +///commanded reference position of slave axis +func (rcv *HomingSlaveParamSingle) MutateNewRefPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +///select which reference mark to set the reference position +func (rcv *HomingSlaveParamSingle) MarkerSel() RefMarkerSel { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return RefMarkerSel(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +///select which reference mark to set the reference position +func (rcv *HomingSlaveParamSingle) MutateMarkerSel(n RefMarkerSel) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +func HomingSlaveParamSingleStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func HomingSlaveParamSingleAddSlaveId(builder *flatbuffers.Builder, slaveId uint16) { + builder.PrependUint16Slot(0, slaveId, 0) +} +func HomingSlaveParamSingleAddNewRefPos(builder *flatbuffers.Builder, newRefPos float64) { + builder.PrependFloat64Slot(1, newRefPos, 0.0) +} +func HomingSlaveParamSingleAddMarkerSel(builder *flatbuffers.Builder, markerSel RefMarkerSel) { + builder.PrependInt8Slot(2, int8(markerSel), 0) +} +func HomingSlaveParamSingleEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/ext/fbtypes/RefMarkerSel.go b/pkg/fbs/motion/ext/fbtypes/RefMarkerSel.go new file mode 100644 index 0000000..6d20f14 --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/RefMarkerSel.go @@ -0,0 +1,29 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type RefMarkerSel int8 + +const ( + RefMarkerSelMASTER_SWITCH RefMarkerSel = 0 + RefMarkerSelSELF_SWITCH RefMarkerSel = 1 +) + +var EnumNamesRefMarkerSel = map[RefMarkerSel]string{ + RefMarkerSelMASTER_SWITCH: "MASTER_SWITCH", + RefMarkerSelSELF_SWITCH: "SELF_SWITCH", +} + +var EnumValuesRefMarkerSel = map[string]RefMarkerSel{ + "MASTER_SWITCH": RefMarkerSelMASTER_SWITCH, + "SELF_SWITCH": RefMarkerSelSELF_SWITCH, +} + +func (v RefMarkerSel) String() string { + if s, ok := EnumNamesRefMarkerSel[v]; ok { + return s + } + return "RefMarkerSel(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/ext/fbtypes/RefType.go b/pkg/fbs/motion/ext/fbtypes/RefType.go new file mode 100644 index 0000000..07e6b2c --- /dev/null +++ b/pkg/fbs/motion/ext/fbtypes/RefType.go @@ -0,0 +1,29 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type RefType int8 + +const ( + RefTypeSTOPPED_POS RefType = 0 + RefTypeMARKER_POS RefType = 1 +) + +var EnumNamesRefType = map[RefType]string{ + RefTypeSTOPPED_POS: "STOPPED_POS", + RefTypeMARKER_POS: "MARKER_POS", +} + +var EnumValuesRefType = map[string]RefType{ + "STOPPED_POS": RefTypeSTOPPED_POS, + "MARKER_POS": RefTypeMARKER_POS, +} + +func (v RefType) String() string { + if s, ok := EnumNamesRefType[v]; ok { + return s + } + return "RefType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdGearInPosData.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdGearInPosData.go new file mode 100644 index 0000000..9ae436b --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdGearInPosData.go @@ -0,0 +1,198 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis GearInPos command +type AxsCmdGearInPosDataT struct { + Master string + RatioMaster int32 + RatioSlave int32 + Offset float64 + OffsetDLIdx int32 + CmdMode SyncCmdMode + Buffered bool +} + +func (t *AxsCmdGearInPosDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterOffset := builder.CreateString(t.Master) + AxsCmdGearInPosDataStart(builder) + AxsCmdGearInPosDataAddMaster(builder, masterOffset) + AxsCmdGearInPosDataAddRatioMaster(builder, t.RatioMaster) + AxsCmdGearInPosDataAddRatioSlave(builder, t.RatioSlave) + AxsCmdGearInPosDataAddOffset(builder, t.Offset) + AxsCmdGearInPosDataAddOffsetDLIdx(builder, t.OffsetDLIdx) + AxsCmdGearInPosDataAddCmdMode(builder, t.CmdMode) + AxsCmdGearInPosDataAddBuffered(builder, t.Buffered) + return AxsCmdGearInPosDataEnd(builder) +} + +func (rcv *AxsCmdGearInPosData) UnPackTo(t *AxsCmdGearInPosDataT) { + t.Master = string(rcv.Master()) + t.RatioMaster = rcv.RatioMaster() + t.RatioSlave = rcv.RatioSlave() + t.Offset = rcv.Offset() + t.OffsetDLIdx = rcv.OffsetDLIdx() + t.CmdMode = rcv.CmdMode() + t.Buffered = rcv.Buffered() +} + +func (rcv *AxsCmdGearInPosData) UnPack() *AxsCmdGearInPosDataT { + if rcv == nil { return nil } + t := &AxsCmdGearInPosDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdGearInPosData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdGearInPosData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdGearInPosData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdGearInPosData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdGearInPosData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdGearInPosData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdGearInPosData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdGearInPosData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdGearInPosData) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the master axis +func (rcv *AxsCmdGearInPosData) Master() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the master axis +/// gear ratio, master side (can be negative) +func (rcv *AxsCmdGearInPosData) RatioMaster() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 1 +} + +/// gear ratio, master side (can be negative) +func (rcv *AxsCmdGearInPosData) MutateRatioMaster(n int32) bool { + return rcv._tab.MutateInt32Slot(6, n) +} + +/// gear ratio, slave side (can be negative) +func (rcv *AxsCmdGearInPosData) RatioSlave() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 1 +} + +/// gear ratio, slave side (can be negative) +func (rcv *AxsCmdGearInPosData) MutateRatioSlave(n int32) bool { + return rcv._tab.MutateInt32Slot(8, n) +} + +/// post gear position offset as a constant value (set to 0.0, to have no offset); only used, when offsetDLIdx < 0 +func (rcv *AxsCmdGearInPosData) Offset() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// post gear position offset as a constant value (set to 0.0, to have no offset); only used, when offsetDLIdx < 0 +func (rcv *AxsCmdGearInPosData) MutateOffset(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +/// index of the DataLayerRT motion input for the post gear position offset (set to -1, to use the constant offset) +func (rcv *AxsCmdGearInPosData) OffsetDLIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// index of the DataLayerRT motion input for the post gear position offset (set to -1, to use the constant offset) +func (rcv *AxsCmdGearInPosData) MutateOffsetDLIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(12, n) +} + +/// Sync command mode +func (rcv *AxsCmdGearInPosData) CmdMode() SyncCmdMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return SyncCmdMode(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 2 +} + +/// Sync command mode +func (rcv *AxsCmdGearInPosData) MutateCmdMode(n SyncCmdMode) bool { + return rcv._tab.MutateInt8Slot(14, int8(n)) +} + +/// should this be a buffered command? +func (rcv *AxsCmdGearInPosData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// should this be a buffered command? +func (rcv *AxsCmdGearInPosData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(16, n) +} + +func AxsCmdGearInPosDataStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func AxsCmdGearInPosDataAddMaster(builder *flatbuffers.Builder, master flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(master), 0) +} +func AxsCmdGearInPosDataAddRatioMaster(builder *flatbuffers.Builder, ratioMaster int32) { + builder.PrependInt32Slot(1, ratioMaster, 1) +} +func AxsCmdGearInPosDataAddRatioSlave(builder *flatbuffers.Builder, ratioSlave int32) { + builder.PrependInt32Slot(2, ratioSlave, 1) +} +func AxsCmdGearInPosDataAddOffset(builder *flatbuffers.Builder, offset float64) { + builder.PrependFloat64Slot(3, offset, 0.0) +} +func AxsCmdGearInPosDataAddOffsetDLIdx(builder *flatbuffers.Builder, offsetDLIdx int32) { + builder.PrependInt32Slot(4, offsetDLIdx, -1) +} +func AxsCmdGearInPosDataAddCmdMode(builder *flatbuffers.Builder, cmdMode SyncCmdMode) { + builder.PrependInt8Slot(5, int8(cmdMode), 2) +} +func AxsCmdGearInPosDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(6, buffered, false) +} +func AxsCmdGearInPosDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdSyncGenericData.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdSyncGenericData.go new file mode 100644 index 0000000..cbe5e1f --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdSyncGenericData.go @@ -0,0 +1,135 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis command for generic synchronized motion +type AxsCmdSyncGenericDataT struct { + Master string + Pipeline string + CmdMode SyncCmdMode + Buffered bool +} + +func (t *AxsCmdSyncGenericDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterOffset := builder.CreateString(t.Master) + pipelineOffset := builder.CreateString(t.Pipeline) + AxsCmdSyncGenericDataStart(builder) + AxsCmdSyncGenericDataAddMaster(builder, masterOffset) + AxsCmdSyncGenericDataAddPipeline(builder, pipelineOffset) + AxsCmdSyncGenericDataAddCmdMode(builder, t.CmdMode) + AxsCmdSyncGenericDataAddBuffered(builder, t.Buffered) + return AxsCmdSyncGenericDataEnd(builder) +} + +func (rcv *AxsCmdSyncGenericData) UnPackTo(t *AxsCmdSyncGenericDataT) { + t.Master = string(rcv.Master()) + t.Pipeline = string(rcv.Pipeline()) + t.CmdMode = rcv.CmdMode() + t.Buffered = rcv.Buffered() +} + +func (rcv *AxsCmdSyncGenericData) UnPack() *AxsCmdSyncGenericDataT { + if rcv == nil { return nil } + t := &AxsCmdSyncGenericDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdSyncGenericData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdSyncGenericData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdSyncGenericData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdSyncGenericData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdSyncGenericData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdSyncGenericData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdSyncGenericData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdSyncGenericData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdSyncGenericData) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the master axis +func (rcv *AxsCmdSyncGenericData) Master() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the master axis +/// name of the pipeline +func (rcv *AxsCmdSyncGenericData) Pipeline() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the pipeline +/// Sync command mode +func (rcv *AxsCmdSyncGenericData) CmdMode() SyncCmdMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return SyncCmdMode(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 2 +} + +/// Sync command mode +func (rcv *AxsCmdSyncGenericData) MutateCmdMode(n SyncCmdMode) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +/// should this be a buffered command? +func (rcv *AxsCmdSyncGenericData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// should this be a buffered command? +func (rcv *AxsCmdSyncGenericData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func AxsCmdSyncGenericDataStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsCmdSyncGenericDataAddMaster(builder *flatbuffers.Builder, master flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(master), 0) +} +func AxsCmdSyncGenericDataAddPipeline(builder *flatbuffers.Builder, pipeline flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(pipeline), 0) +} +func AxsCmdSyncGenericDataAddCmdMode(builder *flatbuffers.Builder, cmdMode SyncCmdMode) { + builder.PrependInt8Slot(2, int8(cmdMode), 2) +} +func AxsCmdSyncGenericDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(3, buffered, false) +} +func AxsCmdSyncGenericDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCalcPipelines.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcPipelines.go new file mode 100644 index 0000000..b5e4dd7 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcPipelines.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// all configured calculation pipelines of a single axis +type AxsStateCalcPipelinesT struct { + Pipeline []*AxsStateCalcSinglePipelineT +} + +func (t *AxsStateCalcPipelinesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pipelineOffset := flatbuffers.UOffsetT(0) + if t.Pipeline != nil { + pipelineLength := len(t.Pipeline) + pipelineOffsets := make([]flatbuffers.UOffsetT, pipelineLength) + for j := 0; j < pipelineLength; j++ { + pipelineOffsets[j] = t.Pipeline[j].Pack(builder) + } + AxsStateCalcPipelinesStartPipelineVector(builder, pipelineLength) + for j := pipelineLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(pipelineOffsets[j]) + } + pipelineOffset = builder.EndVector(pipelineLength) + } + AxsStateCalcPipelinesStart(builder) + AxsStateCalcPipelinesAddPipeline(builder, pipelineOffset) + return AxsStateCalcPipelinesEnd(builder) +} + +func (rcv *AxsStateCalcPipelines) UnPackTo(t *AxsStateCalcPipelinesT) { + pipelineLength := rcv.PipelineLength() + t.Pipeline = make([]*AxsStateCalcSinglePipelineT, pipelineLength) + for j := 0; j < pipelineLength; j++ { + x := AxsStateCalcSinglePipeline{} + rcv.Pipeline(&x, j) + t.Pipeline[j] = x.UnPack() + } +} + +func (rcv *AxsStateCalcPipelines) UnPack() *AxsStateCalcPipelinesT { + if rcv == nil { return nil } + t := &AxsStateCalcPipelinesT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCalcPipelines struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCalcPipelines(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcPipelines { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCalcPipelines{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCalcPipelines(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcPipelines { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCalcPipelines{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCalcPipelines) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCalcPipelines) Table() flatbuffers.Table { + return rcv._tab +} + +/// vector of all configured calculation pipelines of a single axis +func (rcv *AxsStateCalcPipelines) Pipeline(obj *AxsStateCalcSinglePipeline, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *AxsStateCalcPipelines) PipelineLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of all configured calculation pipelines of a single axis +func AxsStateCalcPipelinesStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AxsStateCalcPipelinesAddPipeline(builder *flatbuffers.Builder, pipeline flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pipeline), 0) +} +func AxsStateCalcPipelinesStartPipelineVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcPipelinesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSinglePipeline.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSinglePipeline.go new file mode 100644 index 0000000..6fe0b15 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSinglePipeline.go @@ -0,0 +1,218 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// current state of a single calculation pipeline of a single axis +type AxsStateCalcSinglePipelineT struct { + Name string + State PipelineState + Validation []*PipelineValidationT + IsBuiltIn bool + Steps []*AxsStateCalcSingleStepT +} + +func (t *AxsStateCalcSinglePipelineT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + validationOffset := flatbuffers.UOffsetT(0) + if t.Validation != nil { + validationLength := len(t.Validation) + validationOffsets := make([]flatbuffers.UOffsetT, validationLength) + for j := 0; j < validationLength; j++ { + validationOffsets[j] = t.Validation[j].Pack(builder) + } + AxsStateCalcSinglePipelineStartValidationVector(builder, validationLength) + for j := validationLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(validationOffsets[j]) + } + validationOffset = builder.EndVector(validationLength) + } + stepsOffset := flatbuffers.UOffsetT(0) + if t.Steps != nil { + stepsLength := len(t.Steps) + stepsOffsets := make([]flatbuffers.UOffsetT, stepsLength) + for j := 0; j < stepsLength; j++ { + stepsOffsets[j] = t.Steps[j].Pack(builder) + } + AxsStateCalcSinglePipelineStartStepsVector(builder, stepsLength) + for j := stepsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(stepsOffsets[j]) + } + stepsOffset = builder.EndVector(stepsLength) + } + AxsStateCalcSinglePipelineStart(builder) + AxsStateCalcSinglePipelineAddName(builder, nameOffset) + AxsStateCalcSinglePipelineAddState(builder, t.State) + AxsStateCalcSinglePipelineAddValidation(builder, validationOffset) + AxsStateCalcSinglePipelineAddIsBuiltIn(builder, t.IsBuiltIn) + AxsStateCalcSinglePipelineAddSteps(builder, stepsOffset) + return AxsStateCalcSinglePipelineEnd(builder) +} + +func (rcv *AxsStateCalcSinglePipeline) UnPackTo(t *AxsStateCalcSinglePipelineT) { + t.Name = string(rcv.Name()) + t.State = rcv.State() + validationLength := rcv.ValidationLength() + t.Validation = make([]*PipelineValidationT, validationLength) + for j := 0; j < validationLength; j++ { + x := PipelineValidation{} + rcv.Validation(&x, j) + t.Validation[j] = x.UnPack() + } + t.IsBuiltIn = rcv.IsBuiltIn() + stepsLength := rcv.StepsLength() + t.Steps = make([]*AxsStateCalcSingleStepT, stepsLength) + for j := 0; j < stepsLength; j++ { + x := AxsStateCalcSingleStep{} + rcv.Steps(&x, j) + t.Steps[j] = x.UnPack() + } +} + +func (rcv *AxsStateCalcSinglePipeline) UnPack() *AxsStateCalcSinglePipelineT { + if rcv == nil { return nil } + t := &AxsStateCalcSinglePipelineT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCalcSinglePipeline struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCalcSinglePipeline(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcSinglePipeline { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCalcSinglePipeline{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCalcSinglePipeline(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcSinglePipeline { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCalcSinglePipeline{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCalcSinglePipeline) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCalcSinglePipeline) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the calculation pipeline +func (rcv *AxsStateCalcSinglePipeline) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the calculation pipeline +/// state of the calculation pipeline +func (rcv *AxsStateCalcSinglePipeline) State() PipelineState { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return PipelineState(rcv._tab.GetInt32(o + rcv._tab.Pos)) + } + return 0 +} + +/// state of the calculation pipeline +func (rcv *AxsStateCalcSinglePipeline) MutateState(n PipelineState) bool { + return rcv._tab.MutateInt32Slot(6, int32(n)) +} + +/// validation on the calculation pipeline (multiple errors can occur) +func (rcv *AxsStateCalcSinglePipeline) Validation(obj *PipelineValidation, 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 *AxsStateCalcSinglePipeline) ValidationLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// validation on the calculation pipeline (multiple errors can occur) +/// if the pipeline is a built-in pipeline (which is read-only) +func (rcv *AxsStateCalcSinglePipeline) IsBuiltIn() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// if the pipeline is a built-in pipeline (which is read-only) +func (rcv *AxsStateCalcSinglePipeline) MutateIsBuiltIn(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +/// all calculation steps of the calculation pipeline +func (rcv *AxsStateCalcSinglePipeline) Steps(obj *AxsStateCalcSingleStep, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + 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 *AxsStateCalcSinglePipeline) StepsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// all calculation steps of the calculation pipeline +func AxsStateCalcSinglePipelineStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func AxsStateCalcSinglePipelineAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func AxsStateCalcSinglePipelineAddState(builder *flatbuffers.Builder, state PipelineState) { + builder.PrependInt32Slot(1, int32(state), 0) +} +func AxsStateCalcSinglePipelineAddValidation(builder *flatbuffers.Builder, validation flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(validation), 0) +} +func AxsStateCalcSinglePipelineStartValidationVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcSinglePipelineAddIsBuiltIn(builder *flatbuffers.Builder, isBuiltIn bool) { + builder.PrependBoolSlot(3, isBuiltIn, false) +} +func AxsStateCalcSinglePipelineAddSteps(builder *flatbuffers.Builder, steps flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(steps), 0) +} +func AxsStateCalcSinglePipelineStartStepsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcSinglePipelineEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSingleStep.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSingleStep.go new file mode 100644 index 0000000..23eb378 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcSingleStep.go @@ -0,0 +1,238 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// a single supported calculation step +type AxsStateCalcSingleStepT struct { + StepID uint32 + Type string + Inputs []string + Outputs []string + Parameter []*AxsStateCalcStepSingleParamT +} + +func (t *AxsStateCalcSingleStepT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + typeOffset := builder.CreateString(t.Type) + 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] = builder.CreateString(t.Inputs[j]) + } + AxsStateCalcSingleStepStartInputsVector(builder, inputsLength) + for j := inputsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(inputsOffsets[j]) + } + inputsOffset = builder.EndVector(inputsLength) + } + outputsOffset := flatbuffers.UOffsetT(0) + if t.Outputs != nil { + outputsLength := len(t.Outputs) + outputsOffsets := make([]flatbuffers.UOffsetT, outputsLength) + for j := 0; j < outputsLength; j++ { + outputsOffsets[j] = builder.CreateString(t.Outputs[j]) + } + AxsStateCalcSingleStepStartOutputsVector(builder, outputsLength) + for j := outputsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(outputsOffsets[j]) + } + outputsOffset = builder.EndVector(outputsLength) + } + parameterOffset := flatbuffers.UOffsetT(0) + if t.Parameter != nil { + parameterLength := len(t.Parameter) + parameterOffsets := make([]flatbuffers.UOffsetT, parameterLength) + for j := 0; j < parameterLength; j++ { + parameterOffsets[j] = t.Parameter[j].Pack(builder) + } + AxsStateCalcSingleStepStartParameterVector(builder, parameterLength) + for j := parameterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(parameterOffsets[j]) + } + parameterOffset = builder.EndVector(parameterLength) + } + AxsStateCalcSingleStepStart(builder) + AxsStateCalcSingleStepAddStepID(builder, t.StepID) + AxsStateCalcSingleStepAddType(builder, typeOffset) + AxsStateCalcSingleStepAddInputs(builder, inputsOffset) + AxsStateCalcSingleStepAddOutputs(builder, outputsOffset) + AxsStateCalcSingleStepAddParameter(builder, parameterOffset) + return AxsStateCalcSingleStepEnd(builder) +} + +func (rcv *AxsStateCalcSingleStep) UnPackTo(t *AxsStateCalcSingleStepT) { + t.StepID = rcv.StepID() + t.Type = string(rcv.Type()) + inputsLength := rcv.InputsLength() + t.Inputs = make([]string, inputsLength) + for j := 0; j < inputsLength; j++ { + t.Inputs[j] = string(rcv.Inputs(j)) + } + outputsLength := rcv.OutputsLength() + t.Outputs = make([]string, outputsLength) + for j := 0; j < outputsLength; j++ { + t.Outputs[j] = string(rcv.Outputs(j)) + } + parameterLength := rcv.ParameterLength() + t.Parameter = make([]*AxsStateCalcStepSingleParamT, parameterLength) + for j := 0; j < parameterLength; j++ { + x := AxsStateCalcStepSingleParam{} + rcv.Parameter(&x, j) + t.Parameter[j] = x.UnPack() + } +} + +func (rcv *AxsStateCalcSingleStep) UnPack() *AxsStateCalcSingleStepT { + if rcv == nil { return nil } + t := &AxsStateCalcSingleStepT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCalcSingleStep struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCalcSingleStep(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcSingleStep { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCalcSingleStep{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCalcSingleStep(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcSingleStep { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCalcSingleStep{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCalcSingleStep) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCalcSingleStep) Table() flatbuffers.Table { + return rcv._tab +} + +/// ID of the calculation step +func (rcv *AxsStateCalcSingleStep) StepID() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// ID of the calculation step +func (rcv *AxsStateCalcSingleStep) MutateStepID(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +/// Typestring of the calculation step +func (rcv *AxsStateCalcSingleStep) Type() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Typestring of the calculation step +/// current input values +func (rcv *AxsStateCalcSingleStep) Inputs(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *AxsStateCalcSingleStep) InputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// current input values +/// current output values +func (rcv *AxsStateCalcSingleStep) Outputs(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *AxsStateCalcSingleStep) OutputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// current output values +/// all parameter values of the calculation step +func (rcv *AxsStateCalcSingleStep) Parameter(obj *AxsStateCalcStepSingleParam, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + 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 *AxsStateCalcSingleStep) ParameterLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// all parameter values of the calculation step +func AxsStateCalcSingleStepStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func AxsStateCalcSingleStepAddStepID(builder *flatbuffers.Builder, stepID uint32) { + builder.PrependUint32Slot(0, stepID, 0) +} +func AxsStateCalcSingleStepAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(type_), 0) +} +func AxsStateCalcSingleStepAddInputs(builder *flatbuffers.Builder, inputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inputs), 0) +} +func AxsStateCalcSingleStepStartInputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcSingleStepAddOutputs(builder *flatbuffers.Builder, outputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(outputs), 0) +} +func AxsStateCalcSingleStepStartOutputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcSingleStepAddParameter(builder *flatbuffers.Builder, parameter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(parameter), 0) +} +func AxsStateCalcSingleStepStartParameterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func AxsStateCalcSingleStepEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCalcStepSingleParam.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcStepSingleParam.go new file mode 100644 index 0000000..b338da3 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCalcStepSingleParam.go @@ -0,0 +1,152 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// a single parameter of a calculation step +type AxsStateCalcStepSingleParamT struct { + Name string + ValueDouble float64 + ValueInt int64 + ValueString string + Detail string +} + +func (t *AxsStateCalcStepSingleParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + valueStringOffset := builder.CreateString(t.ValueString) + detailOffset := builder.CreateString(t.Detail) + AxsStateCalcStepSingleParamStart(builder) + AxsStateCalcStepSingleParamAddName(builder, nameOffset) + AxsStateCalcStepSingleParamAddValueDouble(builder, t.ValueDouble) + AxsStateCalcStepSingleParamAddValueInt(builder, t.ValueInt) + AxsStateCalcStepSingleParamAddValueString(builder, valueStringOffset) + AxsStateCalcStepSingleParamAddDetail(builder, detailOffset) + return AxsStateCalcStepSingleParamEnd(builder) +} + +func (rcv *AxsStateCalcStepSingleParam) UnPackTo(t *AxsStateCalcStepSingleParamT) { + t.Name = string(rcv.Name()) + t.ValueDouble = rcv.ValueDouble() + t.ValueInt = rcv.ValueInt() + t.ValueString = string(rcv.ValueString()) + t.Detail = string(rcv.Detail()) +} + +func (rcv *AxsStateCalcStepSingleParam) UnPack() *AxsStateCalcStepSingleParamT { + if rcv == nil { return nil } + t := &AxsStateCalcStepSingleParamT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCalcStepSingleParam struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCalcStepSingleParam(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcStepSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCalcStepSingleParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCalcStepSingleParam(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCalcStepSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCalcStepSingleParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCalcStepSingleParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCalcStepSingleParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the parameter +func (rcv *AxsStateCalcStepSingleParam) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the parameter +/// value of the parameter (when it's a double value) +func (rcv *AxsStateCalcStepSingleParam) ValueDouble() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// value of the parameter (when it's a double value) +func (rcv *AxsStateCalcStepSingleParam) MutateValueDouble(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// value of the parameter (when it's a integer value) +func (rcv *AxsStateCalcStepSingleParam) ValueInt() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +/// value of the parameter (when it's a integer value) +func (rcv *AxsStateCalcStepSingleParam) MutateValueInt(n int64) bool { + return rcv._tab.MutateInt64Slot(8, n) +} + +/// value of the parameter (when it's a string value) +func (rcv *AxsStateCalcStepSingleParam) ValueString() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// value of the parameter (when it's a string value) +/// detail information of the parameter (e.g. content, when it's a real-time input value) +func (rcv *AxsStateCalcStepSingleParam) Detail() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// detail information of the parameter (e.g. content, when it's a real-time input value) +func AxsStateCalcStepSingleParamStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func AxsStateCalcStepSingleParamAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func AxsStateCalcStepSingleParamAddValueDouble(builder *flatbuffers.Builder, valueDouble float64) { + builder.PrependFloat64Slot(1, valueDouble, 0.0) +} +func AxsStateCalcStepSingleParamAddValueInt(builder *flatbuffers.Builder, valueInt int64) { + builder.PrependInt64Slot(2, valueInt, 0) +} +func AxsStateCalcStepSingleParamAddValueString(builder *flatbuffers.Builder, valueString flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(valueString), 0) +} +func AxsStateCalcStepSingleParamAddDetail(builder *flatbuffers.Builder, detail flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(detail), 0) +} +func AxsStateCalcStepSingleParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/CalcPipelineCfg.go b/pkg/fbs/motion/sync/fbtypes/CalcPipelineCfg.go new file mode 100644 index 0000000..5d77123 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/CalcPipelineCfg.go @@ -0,0 +1,148 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration of a single calculation pipeline +type CalcPipelineCfgT struct { + Name string + Generic bool + Steps []*CalcStepCfgT +} + +func (t *CalcPipelineCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + stepsOffset := flatbuffers.UOffsetT(0) + if t.Steps != nil { + stepsLength := len(t.Steps) + stepsOffsets := make([]flatbuffers.UOffsetT, stepsLength) + for j := 0; j < stepsLength; j++ { + stepsOffsets[j] = t.Steps[j].Pack(builder) + } + CalcPipelineCfgStartStepsVector(builder, stepsLength) + for j := stepsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(stepsOffsets[j]) + } + stepsOffset = builder.EndVector(stepsLength) + } + CalcPipelineCfgStart(builder) + CalcPipelineCfgAddName(builder, nameOffset) + CalcPipelineCfgAddGeneric(builder, t.Generic) + CalcPipelineCfgAddSteps(builder, stepsOffset) + return CalcPipelineCfgEnd(builder) +} + +func (rcv *CalcPipelineCfg) UnPackTo(t *CalcPipelineCfgT) { + t.Name = string(rcv.Name()) + t.Generic = rcv.Generic() + stepsLength := rcv.StepsLength() + t.Steps = make([]*CalcStepCfgT, stepsLength) + for j := 0; j < stepsLength; j++ { + x := CalcStepCfg{} + rcv.Steps(&x, j) + t.Steps[j] = x.UnPack() + } +} + +func (rcv *CalcPipelineCfg) UnPack() *CalcPipelineCfgT { + if rcv == nil { return nil } + t := &CalcPipelineCfgT{} + rcv.UnPackTo(t) + return t +} + +type CalcPipelineCfg struct { + _tab flatbuffers.Table +} + +func GetRootAsCalcPipelineCfg(buf []byte, offset flatbuffers.UOffsetT) *CalcPipelineCfg { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CalcPipelineCfg{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCalcPipelineCfg(buf []byte, offset flatbuffers.UOffsetT) *CalcPipelineCfg { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CalcPipelineCfg{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CalcPipelineCfg) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CalcPipelineCfg) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the calculation pipeline +func (rcv *CalcPipelineCfg) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the calculation pipeline +/// is this a generic pipeline (when not, its provided by a command and is read-only) +func (rcv *CalcPipelineCfg) Generic() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// is this a generic pipeline (when not, its provided by a command and is read-only) +func (rcv *CalcPipelineCfg) MutateGeneric(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +/// vector of all calculation steps +func (rcv *CalcPipelineCfg) Steps(obj *CalcStepCfg, 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 *CalcPipelineCfg) StepsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of all calculation steps +func CalcPipelineCfgStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CalcPipelineCfgAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func CalcPipelineCfgAddGeneric(builder *flatbuffers.Builder, generic bool) { + builder.PrependBoolSlot(1, generic, true) +} +func CalcPipelineCfgAddSteps(builder *flatbuffers.Builder, steps flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(steps), 0) +} +func CalcPipelineCfgStartStepsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CalcPipelineCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/CalcStepCfg.go b/pkg/fbs/motion/sync/fbtypes/CalcStepCfg.go new file mode 100644 index 0000000..abf6d20 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/CalcStepCfg.go @@ -0,0 +1,193 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration of a single calculation step +type CalcStepCfgT struct { + StepID uint32 + Type string + Inputs []string + Parameter []*CalcStepCfgSingleParamT +} + +func (t *CalcStepCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + typeOffset := builder.CreateString(t.Type) + 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] = builder.CreateString(t.Inputs[j]) + } + CalcStepCfgStartInputsVector(builder, inputsLength) + for j := inputsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(inputsOffsets[j]) + } + inputsOffset = builder.EndVector(inputsLength) + } + parameterOffset := flatbuffers.UOffsetT(0) + if t.Parameter != nil { + parameterLength := len(t.Parameter) + parameterOffsets := make([]flatbuffers.UOffsetT, parameterLength) + for j := 0; j < parameterLength; j++ { + parameterOffsets[j] = t.Parameter[j].Pack(builder) + } + CalcStepCfgStartParameterVector(builder, parameterLength) + for j := parameterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(parameterOffsets[j]) + } + parameterOffset = builder.EndVector(parameterLength) + } + CalcStepCfgStart(builder) + CalcStepCfgAddStepID(builder, t.StepID) + CalcStepCfgAddType(builder, typeOffset) + CalcStepCfgAddInputs(builder, inputsOffset) + CalcStepCfgAddParameter(builder, parameterOffset) + return CalcStepCfgEnd(builder) +} + +func (rcv *CalcStepCfg) UnPackTo(t *CalcStepCfgT) { + t.StepID = rcv.StepID() + t.Type = string(rcv.Type()) + inputsLength := rcv.InputsLength() + t.Inputs = make([]string, inputsLength) + for j := 0; j < inputsLength; j++ { + t.Inputs[j] = string(rcv.Inputs(j)) + } + parameterLength := rcv.ParameterLength() + t.Parameter = make([]*CalcStepCfgSingleParamT, parameterLength) + for j := 0; j < parameterLength; j++ { + x := CalcStepCfgSingleParam{} + rcv.Parameter(&x, j) + t.Parameter[j] = x.UnPack() + } +} + +func (rcv *CalcStepCfg) UnPack() *CalcStepCfgT { + if rcv == nil { return nil } + t := &CalcStepCfgT{} + rcv.UnPackTo(t) + return t +} + +type CalcStepCfg struct { + _tab flatbuffers.Table +} + +func GetRootAsCalcStepCfg(buf []byte, offset flatbuffers.UOffsetT) *CalcStepCfg { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CalcStepCfg{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCalcStepCfg(buf []byte, offset flatbuffers.UOffsetT) *CalcStepCfg { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CalcStepCfg{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CalcStepCfg) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CalcStepCfg) Table() flatbuffers.Table { + return rcv._tab +} + +/// ID of the calculation step +func (rcv *CalcStepCfg) StepID() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// ID of the calculation step +func (rcv *CalcStepCfg) MutateStepID(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +/// type of the calculation step +func (rcv *CalcStepCfg) Type() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// type of the calculation step +/// inputs of the calculation step +func (rcv *CalcStepCfg) Inputs(j int) []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) + } + return nil +} + +func (rcv *CalcStepCfg) InputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// inputs of the calculation step +/// data of all parameters of a single calculation step +func (rcv *CalcStepCfg) Parameter(obj *CalcStepCfgSingleParam, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + 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 *CalcStepCfg) ParameterLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// data of all parameters of a single calculation step +func CalcStepCfgStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func CalcStepCfgAddStepID(builder *flatbuffers.Builder, stepID uint32) { + builder.PrependUint32Slot(0, stepID, 0) +} +func CalcStepCfgAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(type_), 0) +} +func CalcStepCfgAddInputs(builder *flatbuffers.Builder, inputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inputs), 0) +} +func CalcStepCfgStartInputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CalcStepCfgAddParameter(builder *flatbuffers.Builder, parameter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(parameter), 0) +} +func CalcStepCfgStartParameterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func CalcStepCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/CalcStepCfgSingleParam.go b/pkg/fbs/motion/sync/fbtypes/CalcStepCfgSingleParam.go new file mode 100644 index 0000000..826e553 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/CalcStepCfgSingleParam.go @@ -0,0 +1,135 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration of a single parameter of a calculation step +type CalcStepCfgSingleParamT struct { + Name string + ValueDouble float64 + ValueInt int64 + ValueString string +} + +func (t *CalcStepCfgSingleParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + valueStringOffset := builder.CreateString(t.ValueString) + CalcStepCfgSingleParamStart(builder) + CalcStepCfgSingleParamAddName(builder, nameOffset) + CalcStepCfgSingleParamAddValueDouble(builder, t.ValueDouble) + CalcStepCfgSingleParamAddValueInt(builder, t.ValueInt) + CalcStepCfgSingleParamAddValueString(builder, valueStringOffset) + return CalcStepCfgSingleParamEnd(builder) +} + +func (rcv *CalcStepCfgSingleParam) UnPackTo(t *CalcStepCfgSingleParamT) { + t.Name = string(rcv.Name()) + t.ValueDouble = rcv.ValueDouble() + t.ValueInt = rcv.ValueInt() + t.ValueString = string(rcv.ValueString()) +} + +func (rcv *CalcStepCfgSingleParam) UnPack() *CalcStepCfgSingleParamT { + if rcv == nil { return nil } + t := &CalcStepCfgSingleParamT{} + rcv.UnPackTo(t) + return t +} + +type CalcStepCfgSingleParam struct { + _tab flatbuffers.Table +} + +func GetRootAsCalcStepCfgSingleParam(buf []byte, offset flatbuffers.UOffsetT) *CalcStepCfgSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CalcStepCfgSingleParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCalcStepCfgSingleParam(buf []byte, offset flatbuffers.UOffsetT) *CalcStepCfgSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CalcStepCfgSingleParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CalcStepCfgSingleParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CalcStepCfgSingleParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the parameter +func (rcv *CalcStepCfgSingleParam) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the parameter +/// value of the parameter (when it's a double value) +func (rcv *CalcStepCfgSingleParam) ValueDouble() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// value of the parameter (when it's a double value) +func (rcv *CalcStepCfgSingleParam) MutateValueDouble(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// value of the parameter (when it's a integer value) +func (rcv *CalcStepCfgSingleParam) ValueInt() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +/// value of the parameter (when it's a integer value) +func (rcv *CalcStepCfgSingleParam) MutateValueInt(n int64) bool { + return rcv._tab.MutateInt64Slot(8, n) +} + +/// value of the parameter (when it's a string value) +func (rcv *CalcStepCfgSingleParam) ValueString() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// value of the parameter (when it's a string value) +func CalcStepCfgSingleParamStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func CalcStepCfgSingleParamAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func CalcStepCfgSingleParamAddValueDouble(builder *flatbuffers.Builder, valueDouble float64) { + builder.PrependFloat64Slot(1, valueDouble, 0.0) +} +func CalcStepCfgSingleParamAddValueInt(builder *flatbuffers.Builder, valueInt int64) { + builder.PrependInt64Slot(2, valueInt, 0) +} +func CalcStepCfgSingleParamAddValueString(builder *flatbuffers.Builder, valueString flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(valueString), 0) +} +func CalcStepCfgSingleParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/DataID.go b/pkg/fbs/motion/sync/fbtypes/DataID.go new file mode 100644 index 0000000..8e7aa9f --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/DataID.go @@ -0,0 +1,56 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Data, that could be input/output of a single calculation step +type DataID int8 + +const ( + /// reference position + DataIDREF_POS DataID = 0 + /// reference velocity + DataIDREF_VEL DataID = 1 + /// reference acceleration + DataIDREF_ACC DataID = 2 + /// reference jerk + DataIDREF_JRK DataID = 3 + /// actual position + DataIDACT_POS DataID = 4 + /// actual velocity + DataIDACT_VEL DataID = 5 + /// synchronization position reached + DataIDSYNC_POS_REACHED DataID = 6 + /// something else + DataIDSOMETHING_ELSE DataID = 7 +) + +var EnumNamesDataID = map[DataID]string{ + DataIDREF_POS: "REF_POS", + DataIDREF_VEL: "REF_VEL", + DataIDREF_ACC: "REF_ACC", + DataIDREF_JRK: "REF_JRK", + DataIDACT_POS: "ACT_POS", + DataIDACT_VEL: "ACT_VEL", + DataIDSYNC_POS_REACHED: "SYNC_POS_REACHED", + DataIDSOMETHING_ELSE: "SOMETHING_ELSE", +} + +var EnumValuesDataID = map[string]DataID{ + "REF_POS": DataIDREF_POS, + "REF_VEL": DataIDREF_VEL, + "REF_ACC": DataIDREF_ACC, + "REF_JRK": DataIDREF_JRK, + "ACT_POS": DataIDACT_POS, + "ACT_VEL": DataIDACT_VEL, + "SYNC_POS_REACHED": DataIDSYNC_POS_REACHED, + "SOMETHING_ELSE": DataIDSOMETHING_ELSE, +} + +func (v DataID) String() string { + if s, ok := EnumNamesDataID[v]; ok { + return s + } + return "DataID(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/sync/fbtypes/MutexGroupPart1.go b/pkg/fbs/motion/sync/fbtypes/MutexGroupPart1.go new file mode 100644 index 0000000..1b13a27 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/MutexGroupPart1.go @@ -0,0 +1,104 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// The first group of optional parameters, which mutually exclude each other +type MutexGroupPart1T struct { + GroupPart1 []string +} + +func (t *MutexGroupPart1T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + groupPart1Offset := flatbuffers.UOffsetT(0) + if t.GroupPart1 != nil { + groupPart1Length := len(t.GroupPart1) + groupPart1Offsets := make([]flatbuffers.UOffsetT, groupPart1Length) + for j := 0; j < groupPart1Length; j++ { + groupPart1Offsets[j] = builder.CreateString(t.GroupPart1[j]) + } + MutexGroupPart1StartGroupPart1Vector(builder, groupPart1Length) + for j := groupPart1Length - 1; j >= 0; j-- { + builder.PrependUOffsetT(groupPart1Offsets[j]) + } + groupPart1Offset = builder.EndVector(groupPart1Length) + } + MutexGroupPart1Start(builder) + MutexGroupPart1AddGroupPart1(builder, groupPart1Offset) + return MutexGroupPart1End(builder) +} + +func (rcv *MutexGroupPart1) UnPackTo(t *MutexGroupPart1T) { + groupPart1Length := rcv.GroupPart1Length() + t.GroupPart1 = make([]string, groupPart1Length) + for j := 0; j < groupPart1Length; j++ { + t.GroupPart1[j] = string(rcv.GroupPart1(j)) + } +} + +func (rcv *MutexGroupPart1) UnPack() *MutexGroupPart1T { + if rcv == nil { return nil } + t := &MutexGroupPart1T{} + rcv.UnPackTo(t) + return t +} + +type MutexGroupPart1 struct { + _tab flatbuffers.Table +} + +func GetRootAsMutexGroupPart1(buf []byte, offset flatbuffers.UOffsetT) *MutexGroupPart1 { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MutexGroupPart1{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMutexGroupPart1(buf []byte, offset flatbuffers.UOffsetT) *MutexGroupPart1 { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MutexGroupPart1{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MutexGroupPart1) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MutexGroupPart1) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MutexGroupPart1) GroupPart1(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 *MutexGroupPart1) GroupPart1Length() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func MutexGroupPart1Start(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MutexGroupPart1AddGroupPart1(builder *flatbuffers.Builder, groupPart1 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(groupPart1), 0) +} +func MutexGroupPart1StartGroupPart1Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func MutexGroupPart1End(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/MutexGroupPart2.go b/pkg/fbs/motion/sync/fbtypes/MutexGroupPart2.go new file mode 100644 index 0000000..b54c753 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/MutexGroupPart2.go @@ -0,0 +1,109 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// The second group of optional parameters, which mutually exclude each other +type MutexGroupPart2T struct { + GroupPart2 []*MutexGroupPart1T +} + +func (t *MutexGroupPart2T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + groupPart2Offset := flatbuffers.UOffsetT(0) + if t.GroupPart2 != nil { + groupPart2Length := len(t.GroupPart2) + groupPart2Offsets := make([]flatbuffers.UOffsetT, groupPart2Length) + for j := 0; j < groupPart2Length; j++ { + groupPart2Offsets[j] = t.GroupPart2[j].Pack(builder) + } + MutexGroupPart2StartGroupPart2Vector(builder, groupPart2Length) + for j := groupPart2Length - 1; j >= 0; j-- { + builder.PrependUOffsetT(groupPart2Offsets[j]) + } + groupPart2Offset = builder.EndVector(groupPart2Length) + } + MutexGroupPart2Start(builder) + MutexGroupPart2AddGroupPart2(builder, groupPart2Offset) + return MutexGroupPart2End(builder) +} + +func (rcv *MutexGroupPart2) UnPackTo(t *MutexGroupPart2T) { + groupPart2Length := rcv.GroupPart2Length() + t.GroupPart2 = make([]*MutexGroupPart1T, groupPart2Length) + for j := 0; j < groupPart2Length; j++ { + x := MutexGroupPart1{} + rcv.GroupPart2(&x, j) + t.GroupPart2[j] = x.UnPack() + } +} + +func (rcv *MutexGroupPart2) UnPack() *MutexGroupPart2T { + if rcv == nil { return nil } + t := &MutexGroupPart2T{} + rcv.UnPackTo(t) + return t +} + +type MutexGroupPart2 struct { + _tab flatbuffers.Table +} + +func GetRootAsMutexGroupPart2(buf []byte, offset flatbuffers.UOffsetT) *MutexGroupPart2 { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MutexGroupPart2{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMutexGroupPart2(buf []byte, offset flatbuffers.UOffsetT) *MutexGroupPart2 { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MutexGroupPart2{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MutexGroupPart2) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MutexGroupPart2) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MutexGroupPart2) GroupPart2(obj *MutexGroupPart1, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *MutexGroupPart2) GroupPart2Length() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func MutexGroupPart2Start(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MutexGroupPart2AddGroupPart2(builder *flatbuffers.Builder, groupPart2 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(groupPart2), 0) +} +func MutexGroupPart2StartGroupPart2Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func MutexGroupPart2End(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/ParameterType.go b/pkg/fbs/motion/sync/fbtypes/ParameterType.go new file mode 100644 index 0000000..4156dd6 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/ParameterType.go @@ -0,0 +1,36 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Type of a single parameter +type ParameterType int8 + +const ( + /// contains an integer value + ParameterTypeINTEGER ParameterType = 0 + /// contains a double value + ParameterTypeDOUBLE ParameterType = 1 + /// contains a string value + ParameterTypeSTRING ParameterType = 2 +) + +var EnumNamesParameterType = map[ParameterType]string{ + ParameterTypeINTEGER: "INTEGER", + ParameterTypeDOUBLE: "DOUBLE", + ParameterTypeSTRING: "STRING", +} + +var EnumValuesParameterType = map[string]ParameterType{ + "INTEGER": ParameterTypeINTEGER, + "DOUBLE": ParameterTypeDOUBLE, + "STRING": ParameterTypeSTRING, +} + +func (v ParameterType) String() string { + if s, ok := EnumNamesParameterType[v]; ok { + return s + } + return "ParameterType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/sync/fbtypes/PipelineState.go b/pkg/fbs/motion/sync/fbtypes/PipelineState.go new file mode 100644 index 0000000..026f06d --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/PipelineState.go @@ -0,0 +1,40 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// state of a calculation pipeline +type PipelineState int32 + +const ( + /// the pipeline has been changed and validation was not successful + PipelineStateUNVALIDATED PipelineState = 0 + /// the pipeline is currently being edited + PipelineStateIN_EDIT PipelineState = 1 + /// the pipeline has been successfully validated and can be used now + PipelineStateVALIDATED PipelineState = 2 + /// the pipeline is currently in use and may not be changed + PipelineStateIN_USE PipelineState = 3 +) + +var EnumNamesPipelineState = map[PipelineState]string{ + PipelineStateUNVALIDATED: "UNVALIDATED", + PipelineStateIN_EDIT: "IN_EDIT", + PipelineStateVALIDATED: "VALIDATED", + PipelineStateIN_USE: "IN_USE", +} + +var EnumValuesPipelineState = map[string]PipelineState{ + "UNVALIDATED": PipelineStateUNVALIDATED, + "IN_EDIT": PipelineStateIN_EDIT, + "VALIDATED": PipelineStateVALIDATED, + "IN_USE": PipelineStateIN_USE, +} + +func (v PipelineState) String() string { + if s, ok := EnumNamesPipelineState[v]; ok { + return s + } + return "PipelineState(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/sync/fbtypes/PipelineValidation.go b/pkg/fbs/motion/sync/fbtypes/PipelineValidation.go new file mode 100644 index 0000000..1b4f9d5 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/PipelineValidation.go @@ -0,0 +1,135 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// single result of the validation of a calculation pipeline +type PipelineValidationT struct { + MainDiag uint32 + DetailDiag uint32 + Uri string + AddInfo string +} + +func (t *PipelineValidationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + uriOffset := builder.CreateString(t.Uri) + addInfoOffset := builder.CreateString(t.AddInfo) + PipelineValidationStart(builder) + PipelineValidationAddMainDiag(builder, t.MainDiag) + PipelineValidationAddDetailDiag(builder, t.DetailDiag) + PipelineValidationAddUri(builder, uriOffset) + PipelineValidationAddAddInfo(builder, addInfoOffset) + return PipelineValidationEnd(builder) +} + +func (rcv *PipelineValidation) UnPackTo(t *PipelineValidationT) { + t.MainDiag = rcv.MainDiag() + t.DetailDiag = rcv.DetailDiag() + t.Uri = string(rcv.Uri()) + t.AddInfo = string(rcv.AddInfo()) +} + +func (rcv *PipelineValidation) UnPack() *PipelineValidationT { + if rcv == nil { return nil } + t := &PipelineValidationT{} + rcv.UnPackTo(t) + return t +} + +type PipelineValidation struct { + _tab flatbuffers.Table +} + +func GetRootAsPipelineValidation(buf []byte, offset flatbuffers.UOffsetT) *PipelineValidation { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &PipelineValidation{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPipelineValidation(buf []byte, offset flatbuffers.UOffsetT) *PipelineValidation { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &PipelineValidation{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *PipelineValidation) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *PipelineValidation) Table() flatbuffers.Table { + return rcv._tab +} + +/// main diagnosis code +func (rcv *PipelineValidation) MainDiag() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// main diagnosis code +func (rcv *PipelineValidation) MutateMainDiag(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +/// detail diagnosis code +func (rcv *PipelineValidation) DetailDiag() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// detail diagnosis code +func (rcv *PipelineValidation) MutateDetailDiag(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +/// URI of the faulty instance +func (rcv *PipelineValidation) Uri() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// URI of the faulty instance +/// additional infomation +func (rcv *PipelineValidation) AddInfo() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// additional infomation +func PipelineValidationStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func PipelineValidationAddMainDiag(builder *flatbuffers.Builder, mainDiag uint32) { + builder.PrependUint32Slot(0, mainDiag, 0) +} +func PipelineValidationAddDetailDiag(builder *flatbuffers.Builder, detailDiag uint32) { + builder.PrependUint32Slot(1, detailDiag, 0) +} +func PipelineValidationAddUri(builder *flatbuffers.Builder, uri flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(uri), 0) +} +func PipelineValidationAddAddInfo(builder *flatbuffers.Builder, addInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(addInfo), 0) +} +func PipelineValidationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/StateCalcSingleStep.go b/pkg/fbs/motion/sync/fbtypes/StateCalcSingleStep.go new file mode 100644 index 0000000..195e5dd --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/StateCalcSingleStep.go @@ -0,0 +1,284 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// a single supported calculation step +type StateCalcSingleStepT struct { + Name string + Description string + DocuRef string + Inputs []DataID + Outputs []DataID + Parameter []*StateCalcStepSingleParamT + MutexParameter *StateCalcStepMutexParamT +} + +func (t *StateCalcSingleStepT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + descriptionOffset := builder.CreateString(t.Description) + docuRefOffset := builder.CreateString(t.DocuRef) + inputsOffset := flatbuffers.UOffsetT(0) + if t.Inputs != nil { + inputsLength := len(t.Inputs) + StateCalcSingleStepStartInputsVector(builder, inputsLength) + for j := inputsLength - 1; j >= 0; j-- { + builder.PrependInt8(int8(t.Inputs[j])) + } + inputsOffset = builder.EndVector(inputsLength) + } + outputsOffset := flatbuffers.UOffsetT(0) + if t.Outputs != nil { + outputsLength := len(t.Outputs) + StateCalcSingleStepStartOutputsVector(builder, outputsLength) + for j := outputsLength - 1; j >= 0; j-- { + builder.PrependInt8(int8(t.Outputs[j])) + } + outputsOffset = builder.EndVector(outputsLength) + } + parameterOffset := flatbuffers.UOffsetT(0) + if t.Parameter != nil { + parameterLength := len(t.Parameter) + parameterOffsets := make([]flatbuffers.UOffsetT, parameterLength) + for j := 0; j < parameterLength; j++ { + parameterOffsets[j] = t.Parameter[j].Pack(builder) + } + StateCalcSingleStepStartParameterVector(builder, parameterLength) + for j := parameterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(parameterOffsets[j]) + } + parameterOffset = builder.EndVector(parameterLength) + } + mutexParameterOffset := t.MutexParameter.Pack(builder) + StateCalcSingleStepStart(builder) + StateCalcSingleStepAddName(builder, nameOffset) + StateCalcSingleStepAddDescription(builder, descriptionOffset) + StateCalcSingleStepAddDocuRef(builder, docuRefOffset) + StateCalcSingleStepAddInputs(builder, inputsOffset) + StateCalcSingleStepAddOutputs(builder, outputsOffset) + StateCalcSingleStepAddParameter(builder, parameterOffset) + StateCalcSingleStepAddMutexParameter(builder, mutexParameterOffset) + return StateCalcSingleStepEnd(builder) +} + +func (rcv *StateCalcSingleStep) UnPackTo(t *StateCalcSingleStepT) { + t.Name = string(rcv.Name()) + t.Description = string(rcv.Description()) + t.DocuRef = string(rcv.DocuRef()) + inputsLength := rcv.InputsLength() + t.Inputs = make([]DataID, inputsLength) + for j := 0; j < inputsLength; j++ { + t.Inputs[j] = rcv.Inputs(j) + } + outputsLength := rcv.OutputsLength() + t.Outputs = make([]DataID, outputsLength) + for j := 0; j < outputsLength; j++ { + t.Outputs[j] = rcv.Outputs(j) + } + parameterLength := rcv.ParameterLength() + t.Parameter = make([]*StateCalcStepSingleParamT, parameterLength) + for j := 0; j < parameterLength; j++ { + x := StateCalcStepSingleParam{} + rcv.Parameter(&x, j) + t.Parameter[j] = x.UnPack() + } + t.MutexParameter = rcv.MutexParameter(nil).UnPack() +} + +func (rcv *StateCalcSingleStep) UnPack() *StateCalcSingleStepT { + if rcv == nil { return nil } + t := &StateCalcSingleStepT{} + rcv.UnPackTo(t) + return t +} + +type StateCalcSingleStep struct { + _tab flatbuffers.Table +} + +func GetRootAsStateCalcSingleStep(buf []byte, offset flatbuffers.UOffsetT) *StateCalcSingleStep { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StateCalcSingleStep{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStateCalcSingleStep(buf []byte, offset flatbuffers.UOffsetT) *StateCalcSingleStep { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StateCalcSingleStep{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StateCalcSingleStep) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StateCalcSingleStep) Table() flatbuffers.Table { + return rcv._tab +} + +/// Name of the calculation step (indicated by its type ID) +func (rcv *StateCalcSingleStep) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Name of the calculation step (indicated by its type ID) +/// what the calculation step does +func (rcv *StateCalcSingleStep) Description() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// what the calculation step does +/// reference to user manual +func (rcv *StateCalcSingleStep) DocuRef() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// reference to user manual +/// vector of required input types +func (rcv *StateCalcSingleStep) Inputs(j int) DataID { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return DataID(rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))) + } + return 0 +} + +func (rcv *StateCalcSingleStep) InputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of required input types +func (rcv *StateCalcSingleStep) MutateInputs(j int, n DataID) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), int8(n)) + } + return false +} + +/// vector of required output types +func (rcv *StateCalcSingleStep) Outputs(j int) DataID { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return DataID(rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))) + } + return 0 +} + +func (rcv *StateCalcSingleStep) OutputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of required output types +func (rcv *StateCalcSingleStep) MutateOutputs(j int, n DataID) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), int8(n)) + } + return false +} + +/// vector of parameters of the calculation step +func (rcv *StateCalcSingleStep) Parameter(obj *StateCalcStepSingleParam, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + 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 *StateCalcSingleStep) ParameterLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of parameters of the calculation step +/// mutex groups of parameters (identified by the names), that are optional and exclude each other +func (rcv *StateCalcSingleStep) MutexParameter(obj *StateCalcStepMutexParam) *StateCalcStepMutexParam { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(StateCalcStepMutexParam) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// mutex groups of parameters (identified by the names), that are optional and exclude each other +func StateCalcSingleStepStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func StateCalcSingleStepAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func StateCalcSingleStepAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(description), 0) +} +func StateCalcSingleStepAddDocuRef(builder *flatbuffers.Builder, docuRef flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(docuRef), 0) +} +func StateCalcSingleStepAddInputs(builder *flatbuffers.Builder, inputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(inputs), 0) +} +func StateCalcSingleStepStartInputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func StateCalcSingleStepAddOutputs(builder *flatbuffers.Builder, outputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(outputs), 0) +} +func StateCalcSingleStepStartOutputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func StateCalcSingleStepAddParameter(builder *flatbuffers.Builder, parameter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(parameter), 0) +} +func StateCalcSingleStepStartParameterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func StateCalcSingleStepAddMutexParameter(builder *flatbuffers.Builder, mutexParameter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(mutexParameter), 0) +} +func StateCalcSingleStepEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/StateCalcStepMutexParam.go b/pkg/fbs/motion/sync/fbtypes/StateCalcStepMutexParam.go new file mode 100644 index 0000000..dc216b3 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/StateCalcStepMutexParam.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type StateCalcStepMutexParamT struct { + MutexParam []*MutexGroupPart2T +} + +func (t *StateCalcStepMutexParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + mutexParamOffset := flatbuffers.UOffsetT(0) + if t.MutexParam != nil { + mutexParamLength := len(t.MutexParam) + mutexParamOffsets := make([]flatbuffers.UOffsetT, mutexParamLength) + for j := 0; j < mutexParamLength; j++ { + mutexParamOffsets[j] = t.MutexParam[j].Pack(builder) + } + StateCalcStepMutexParamStartMutexParamVector(builder, mutexParamLength) + for j := mutexParamLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(mutexParamOffsets[j]) + } + mutexParamOffset = builder.EndVector(mutexParamLength) + } + StateCalcStepMutexParamStart(builder) + StateCalcStepMutexParamAddMutexParam(builder, mutexParamOffset) + return StateCalcStepMutexParamEnd(builder) +} + +func (rcv *StateCalcStepMutexParam) UnPackTo(t *StateCalcStepMutexParamT) { + mutexParamLength := rcv.MutexParamLength() + t.MutexParam = make([]*MutexGroupPart2T, mutexParamLength) + for j := 0; j < mutexParamLength; j++ { + x := MutexGroupPart2{} + rcv.MutexParam(&x, j) + t.MutexParam[j] = x.UnPack() + } +} + +func (rcv *StateCalcStepMutexParam) UnPack() *StateCalcStepMutexParamT { + if rcv == nil { return nil } + t := &StateCalcStepMutexParamT{} + rcv.UnPackTo(t) + return t +} + +type StateCalcStepMutexParam struct { + _tab flatbuffers.Table +} + +func GetRootAsStateCalcStepMutexParam(buf []byte, offset flatbuffers.UOffsetT) *StateCalcStepMutexParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StateCalcStepMutexParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStateCalcStepMutexParam(buf []byte, offset flatbuffers.UOffsetT) *StateCalcStepMutexParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StateCalcStepMutexParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StateCalcStepMutexParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StateCalcStepMutexParam) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *StateCalcStepMutexParam) MutexParam(obj *MutexGroupPart2, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *StateCalcStepMutexParam) MutexParamLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func StateCalcStepMutexParamStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func StateCalcStepMutexParamAddMutexParam(builder *flatbuffers.Builder, mutexParam flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(mutexParam), 0) +} +func StateCalcStepMutexParamStartMutexParamVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func StateCalcStepMutexParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/StateCalcStepSingleParam.go b/pkg/fbs/motion/sync/fbtypes/StateCalcStepSingleParam.go new file mode 100644 index 0000000..9f5c0ca --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/StateCalcStepSingleParam.go @@ -0,0 +1,135 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// a single parameter of a calculation step +type StateCalcStepSingleParamT struct { + Name string + Description string + Mandatory bool + Type ParameterType +} + +func (t *StateCalcStepSingleParamT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + descriptionOffset := builder.CreateString(t.Description) + StateCalcStepSingleParamStart(builder) + StateCalcStepSingleParamAddName(builder, nameOffset) + StateCalcStepSingleParamAddDescription(builder, descriptionOffset) + StateCalcStepSingleParamAddMandatory(builder, t.Mandatory) + StateCalcStepSingleParamAddType(builder, t.Type) + return StateCalcStepSingleParamEnd(builder) +} + +func (rcv *StateCalcStepSingleParam) UnPackTo(t *StateCalcStepSingleParamT) { + t.Name = string(rcv.Name()) + t.Description = string(rcv.Description()) + t.Mandatory = rcv.Mandatory() + t.Type = rcv.Type() +} + +func (rcv *StateCalcStepSingleParam) UnPack() *StateCalcStepSingleParamT { + if rcv == nil { return nil } + t := &StateCalcStepSingleParamT{} + rcv.UnPackTo(t) + return t +} + +type StateCalcStepSingleParam struct { + _tab flatbuffers.Table +} + +func GetRootAsStateCalcStepSingleParam(buf []byte, offset flatbuffers.UOffsetT) *StateCalcStepSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StateCalcStepSingleParam{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStateCalcStepSingleParam(buf []byte, offset flatbuffers.UOffsetT) *StateCalcStepSingleParam { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StateCalcStepSingleParam{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StateCalcStepSingleParam) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StateCalcStepSingleParam) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the parameter +func (rcv *StateCalcStepSingleParam) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the parameter +/// what the parameter of the calculation step does +func (rcv *StateCalcStepSingleParam) Description() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// what the parameter of the calculation step does +/// is this parameter mandatory? +func (rcv *StateCalcStepSingleParam) Mandatory() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// is this parameter mandatory? +func (rcv *StateCalcStepSingleParam) MutateMandatory(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +/// type of the parameter +func (rcv *StateCalcStepSingleParam) Type() ParameterType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return ParameterType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// type of the parameter +func (rcv *StateCalcStepSingleParam) MutateType(n ParameterType) bool { + return rcv._tab.MutateInt8Slot(10, int8(n)) +} + +func StateCalcStepSingleParamStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func StateCalcStepSingleParamAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func StateCalcStepSingleParamAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(description), 0) +} +func StateCalcStepSingleParamAddMandatory(builder *flatbuffers.Builder, mandatory bool) { + builder.PrependBoolSlot(2, mandatory, false) +} +func StateCalcStepSingleParamAddType(builder *flatbuffers.Builder, type_ ParameterType) { + builder.PrependInt8Slot(3, int8(type_), 0) +} +func StateCalcStepSingleParamEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/StateCalcSteps.go b/pkg/fbs/motion/sync/fbtypes/StateCalcSteps.go new file mode 100644 index 0000000..93acf26 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/StateCalcSteps.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// all supported calculation steps +type StateCalcStepsT struct { + Steps []*StateCalcSingleStepT +} + +func (t *StateCalcStepsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + stepsOffset := flatbuffers.UOffsetT(0) + if t.Steps != nil { + stepsLength := len(t.Steps) + stepsOffsets := make([]flatbuffers.UOffsetT, stepsLength) + for j := 0; j < stepsLength; j++ { + stepsOffsets[j] = t.Steps[j].Pack(builder) + } + StateCalcStepsStartStepsVector(builder, stepsLength) + for j := stepsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(stepsOffsets[j]) + } + stepsOffset = builder.EndVector(stepsLength) + } + StateCalcStepsStart(builder) + StateCalcStepsAddSteps(builder, stepsOffset) + return StateCalcStepsEnd(builder) +} + +func (rcv *StateCalcSteps) UnPackTo(t *StateCalcStepsT) { + stepsLength := rcv.StepsLength() + t.Steps = make([]*StateCalcSingleStepT, stepsLength) + for j := 0; j < stepsLength; j++ { + x := StateCalcSingleStep{} + rcv.Steps(&x, j) + t.Steps[j] = x.UnPack() + } +} + +func (rcv *StateCalcSteps) UnPack() *StateCalcStepsT { + if rcv == nil { return nil } + t := &StateCalcStepsT{} + rcv.UnPackTo(t) + return t +} + +type StateCalcSteps struct { + _tab flatbuffers.Table +} + +func GetRootAsStateCalcSteps(buf []byte, offset flatbuffers.UOffsetT) *StateCalcSteps { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StateCalcSteps{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStateCalcSteps(buf []byte, offset flatbuffers.UOffsetT) *StateCalcSteps { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StateCalcSteps{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StateCalcSteps) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StateCalcSteps) Table() flatbuffers.Table { + return rcv._tab +} + +/// vector of all supported calculation steps +func (rcv *StateCalcSteps) Steps(obj *StateCalcSingleStep, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + 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 *StateCalcSteps) StepsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// vector of all supported calculation steps +func StateCalcStepsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func StateCalcStepsAddSteps(builder *flatbuffers.Builder, steps flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(steps), 0) +} +func StateCalcStepsStartStepsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func StateCalcStepsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/SyncCmdMode.go b/pkg/fbs/motion/sync/fbtypes/SyncCmdMode.go new file mode 100644 index 0000000..3e1c9fa --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/SyncCmdMode.go @@ -0,0 +1,40 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// sync command mode (must fit the enum class motion::sync::cmd::SyncCmdMode) +type SyncCmdMode int8 + +const ( + /// The slave is moved relative and the calculation pipeline is initialized new. + SyncCmdModeCMDMODE_SLAVE_RELATIVE_INIT SyncCmdMode = 0 + /// The slave is moved relative and the calculation pipeline keeps its state. + SyncCmdModeCMDMODE_SLAVE_RELATIVE_KEEP_STATE SyncCmdMode = 1 + /// The slave is moved absolute and the calculation pipeline is initialized new. + SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_INIT SyncCmdMode = 2 + /// The slave is moved absolute and the calculation pipeline keeps its state. + SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_KEEP_STATE SyncCmdMode = 3 +) + +var EnumNamesSyncCmdMode = map[SyncCmdMode]string{ + SyncCmdModeCMDMODE_SLAVE_RELATIVE_INIT: "CMDMODE_SLAVE_RELATIVE_INIT", + SyncCmdModeCMDMODE_SLAVE_RELATIVE_KEEP_STATE: "CMDMODE_SLAVE_RELATIVE_KEEP_STATE", + SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_INIT: "CMDMODE_SLAVE_ABSOLUTE_INIT", + SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_KEEP_STATE: "CMDMODE_SLAVE_ABSOLUTE_KEEP_STATE", +} + +var EnumValuesSyncCmdMode = map[string]SyncCmdMode{ + "CMDMODE_SLAVE_RELATIVE_INIT": SyncCmdModeCMDMODE_SLAVE_RELATIVE_INIT, + "CMDMODE_SLAVE_RELATIVE_KEEP_STATE": SyncCmdModeCMDMODE_SLAVE_RELATIVE_KEEP_STATE, + "CMDMODE_SLAVE_ABSOLUTE_INIT": SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_INIT, + "CMDMODE_SLAVE_ABSOLUTE_KEEP_STATE": SyncCmdModeCMDMODE_SLAVE_ABSOLUTE_KEEP_STATE, +} + +func (v SyncCmdMode) String() string { + if s, ok := EnumNamesSyncCmdMode[v]; ok { + return s + } + return "SyncCmdMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/test/addbundle/fbtypes/KinCmdCircularData.go b/pkg/fbs/motion/test/addbundle/fbtypes/KinCmdCircularData.go index 722bb52..dd280fb 100644 --- a/pkg/fbs/motion/test/addbundle/fbtypes/KinCmdCircularData.go +++ b/pkg/fbs/motion/test/addbundle/fbtypes/KinCmdCircularData.go @@ -5,10 +5,68 @@ package fbtypes import ( flatbuffers "github.com/google/flatbuffers/go" - motion__core__fbtypes "motion/core/fbtypes" + motion__core__fbtypes "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/motion/core/fbtypes" ) /// just for test of additional bundle (motion extension API) +type KinCmdCircularDataT struct { + CmdPos []float64 + CenterPos []float64 + Direction bool + Limits *motion__core__fbtypes.DynamicLimitsT +} + +func (t *KinCmdCircularDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdPosOffset := flatbuffers.UOffsetT(0) + if t.CmdPos != nil { + cmdPosLength := len(t.CmdPos) + KinCmdCircularDataStartCmdPosVector(builder, cmdPosLength) + for j := cmdPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.CmdPos[j]) + } + cmdPosOffset = builder.EndVector(cmdPosLength) + } + centerPosOffset := flatbuffers.UOffsetT(0) + if t.CenterPos != nil { + centerPosLength := len(t.CenterPos) + KinCmdCircularDataStartCenterPosVector(builder, centerPosLength) + for j := centerPosLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.CenterPos[j]) + } + centerPosOffset = builder.EndVector(centerPosLength) + } + limitsOffset := t.Limits.Pack(builder) + KinCmdCircularDataStart(builder) + KinCmdCircularDataAddCmdPos(builder, cmdPosOffset) + KinCmdCircularDataAddCenterPos(builder, centerPosOffset) + KinCmdCircularDataAddDirection(builder, t.Direction) + KinCmdCircularDataAddLimits(builder, limitsOffset) + return KinCmdCircularDataEnd(builder) +} + +func (rcv *KinCmdCircularData) UnPackTo(t *KinCmdCircularDataT) { + cmdPosLength := rcv.CmdPosLength() + t.CmdPos = make([]float64, cmdPosLength) + for j := 0; j < cmdPosLength; j++ { + t.CmdPos[j] = rcv.CmdPos(j) + } + centerPosLength := rcv.CenterPosLength() + t.CenterPos = make([]float64, centerPosLength) + for j := 0; j < centerPosLength; j++ { + t.CenterPos[j] = rcv.CenterPos(j) + } + t.Direction = rcv.Direction() + t.Limits = rcv.Limits(nil).UnPack() +} + +func (rcv *KinCmdCircularData) UnPack() *KinCmdCircularDataT { + if rcv == nil { return nil } + t := &KinCmdCircularDataT{} + rcv.UnPackTo(t) + return t +} + type KinCmdCircularData struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeReq.go b/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeReq.go new file mode 100644 index 0000000..af87aee --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeReq.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type BrakingDistanceTypeReq int8 + +const ( + BrakingDistanceTypeReqUNDEFINED BrakingDistanceTypeReq = 0 + BrakingDistanceTypeReqESTOP BrakingDistanceTypeReq = 1 + BrakingDistanceTypeReqSOFT_STOP BrakingDistanceTypeReq = 2 +) + +var EnumNamesBrakingDistanceTypeReq = map[BrakingDistanceTypeReq]string{ + BrakingDistanceTypeReqUNDEFINED: "UNDEFINED", + BrakingDistanceTypeReqESTOP: "ESTOP", + BrakingDistanceTypeReqSOFT_STOP: "SOFT_STOP", +} + +var EnumValuesBrakingDistanceTypeReq = map[string]BrakingDistanceTypeReq{ + "UNDEFINED": BrakingDistanceTypeReqUNDEFINED, + "ESTOP": BrakingDistanceTypeReqESTOP, + "SOFT_STOP": BrakingDistanceTypeReqSOFT_STOP, +} + +func (v BrakingDistanceTypeReq) String() string { + if s, ok := EnumNamesBrakingDistanceTypeReq[v]; ok { + return s + } + return "BrakingDistanceTypeReq(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeResp.go b/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeResp.go new file mode 100644 index 0000000..afa56fc --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/BrakingDistanceTypeResp.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type BrakingDistanceTypeResp int8 + +const ( + BrakingDistanceTypeRespUNDEFINED BrakingDistanceTypeResp = 0 + BrakingDistanceTypeRespESTOP BrakingDistanceTypeResp = 1 + BrakingDistanceTypeRespSOFT_STOP BrakingDistanceTypeResp = 2 +) + +var EnumNamesBrakingDistanceTypeResp = map[BrakingDistanceTypeResp]string{ + BrakingDistanceTypeRespUNDEFINED: "UNDEFINED", + BrakingDistanceTypeRespESTOP: "ESTOP", + BrakingDistanceTypeRespSOFT_STOP: "SOFT_STOP", +} + +var EnumValuesBrakingDistanceTypeResp = map[string]BrakingDistanceTypeResp{ + "UNDEFINED": BrakingDistanceTypeRespUNDEFINED, + "ESTOP": BrakingDistanceTypeRespESTOP, + "SOFT_STOP": BrakingDistanceTypeRespSOFT_STOP, +} + +func (v BrakingDistanceTypeResp) String() string { + if s, ok := EnumNamesBrakingDistanceTypeResp[v]; ok { + return s + } + return "BrakingDistanceTypeResp(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/CfgGlobal.go b/pkg/fbs/script/manager/fbtypes/CfgGlobal.go index 54e35f5..7463fae 100644 --- a/pkg/fbs/script/manager/fbtypes/CfgGlobal.go +++ b/pkg/fbs/script/manager/fbtypes/CfgGlobal.go @@ -6,6 +6,29 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CfgGlobalT struct { + InitScript *CfgInitScriptT +} + +func (t *CfgGlobalT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + initScriptOffset := t.InitScript.Pack(builder) + CfgGlobalStart(builder) + CfgGlobalAddInitScript(builder, initScriptOffset) + return CfgGlobalEnd(builder) +} + +func (rcv *CfgGlobal) UnPackTo(t *CfgGlobalT) { + t.InitScript = rcv.InitScript(nil).UnPack() +} + +func (rcv *CfgGlobal) UnPack() *CfgGlobalT { + if rcv == nil { return nil } + t := &CfgGlobalT{} + rcv.UnPackTo(t) + return t +} + type CfgGlobal struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/CfgInitScript.go b/pkg/fbs/script/manager/fbtypes/CfgInitScript.go index 6a4086d..8f1ddf0 100644 --- a/pkg/fbs/script/manager/fbtypes/CfgInitScript.go +++ b/pkg/fbs/script/manager/fbtypes/CfgInitScript.go @@ -6,6 +6,53 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type CfgInitScriptT struct { + File string + Language string + Parameter []string +} + +func (t *CfgInitScriptT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + fileOffset := builder.CreateString(t.File) + languageOffset := builder.CreateString(t.Language) + parameterOffset := flatbuffers.UOffsetT(0) + if t.Parameter != nil { + parameterLength := len(t.Parameter) + parameterOffsets := make([]flatbuffers.UOffsetT, parameterLength) + for j := 0; j < parameterLength; j++ { + parameterOffsets[j] = builder.CreateString(t.Parameter[j]) + } + CfgInitScriptStartParameterVector(builder, parameterLength) + for j := parameterLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(parameterOffsets[j]) + } + parameterOffset = builder.EndVector(parameterLength) + } + CfgInitScriptStart(builder) + CfgInitScriptAddFile(builder, fileOffset) + CfgInitScriptAddLanguage(builder, languageOffset) + CfgInitScriptAddParameter(builder, parameterOffset) + return CfgInitScriptEnd(builder) +} + +func (rcv *CfgInitScript) UnPackTo(t *CfgInitScriptT) { + t.File = string(rcv.File()) + t.Language = string(rcv.Language()) + parameterLength := rcv.ParameterLength() + t.Parameter = make([]string, parameterLength) + for j := 0; j < parameterLength; j++ { + t.Parameter[j] = string(rcv.Parameter(j)) + } +} + +func (rcv *CfgInitScript) UnPack() *CfgInitScriptT { + if rcv == nil { return nil } + t := &CfgInitScriptT{} + rcv.UnPackTo(t) + return t +} + type CfgInitScript struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_Base.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_Base.go new file mode 100644 index 0000000..606f29b --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_Base.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_BaseT struct { + Base *Cmd_BaseT + PermType string +} + +func (t *CmdOpt_BaseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + permTypeOffset := builder.CreateString(t.PermType) + CmdOpt_BaseStart(builder) + CmdOpt_BaseAddBase(builder, baseOffset) + CmdOpt_BaseAddPermType(builder, permTypeOffset) + return CmdOpt_BaseEnd(builder) +} + +func (rcv *CmdOpt_Base) UnPackTo(t *CmdOpt_BaseT) { + t.Base = rcv.Base(nil).UnPack() + t.PermType = string(rcv.PermType()) +} + +func (rcv *CmdOpt_Base) UnPack() *CmdOpt_BaseT { + if rcv == nil { return nil } + t := &CmdOpt_BaseT{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_Base struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_Base(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_Base { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_Base{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_Base(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_Base { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_Base{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_Base) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_Base) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_Base) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_Base) PermType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CmdOpt_BaseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func CmdOpt_BaseAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_BaseAddPermType(builder *flatbuffers.Builder, permType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(permType), 0) +} +func CmdOpt_BaseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinAxsDynLim.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinAxsDynLim.go new file mode 100644 index 0000000..f3869c6 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinAxsDynLim.go @@ -0,0 +1,115 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinAxsDynLimT struct { + Base *CmdOpt_BaseT + AxsName string + Lim *Cmd_DynLimitsT +} + +func (t *CmdOpt_KinAxsDynLimT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + axsNameOffset := builder.CreateString(t.AxsName) + limOffset := t.Lim.Pack(builder) + CmdOpt_KinAxsDynLimStart(builder) + CmdOpt_KinAxsDynLimAddBase(builder, baseOffset) + CmdOpt_KinAxsDynLimAddAxsName(builder, axsNameOffset) + CmdOpt_KinAxsDynLimAddLim(builder, limOffset) + return CmdOpt_KinAxsDynLimEnd(builder) +} + +func (rcv *CmdOpt_KinAxsDynLim) UnPackTo(t *CmdOpt_KinAxsDynLimT) { + t.Base = rcv.Base(nil).UnPack() + t.AxsName = string(rcv.AxsName()) + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *CmdOpt_KinAxsDynLim) UnPack() *CmdOpt_KinAxsDynLimT { + if rcv == nil { return nil } + t := &CmdOpt_KinAxsDynLimT{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinAxsDynLim struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinAxsDynLim(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinAxsDynLim { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinAxsDynLim{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinAxsDynLim(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinAxsDynLim { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinAxsDynLim{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinAxsDynLim) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinAxsDynLim) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinAxsDynLim) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinAxsDynLim) AxsName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *CmdOpt_KinAxsDynLim) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func CmdOpt_KinAxsDynLimStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CmdOpt_KinAxsDynLimAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinAxsDynLimAddAxsName(builder *flatbuffers.Builder, axsName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(axsName), 0) +} +func CmdOpt_KinAxsDynLimAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(lim), 0) +} +func CmdOpt_KinAxsDynLimEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinBlend.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinBlend.go new file mode 100644 index 0000000..53caf68 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinBlend.go @@ -0,0 +1,116 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinBlendT struct { + Base *CmdOpt_BaseT + Dist1 float64 + Dist2 float64 +} + +func (t *CmdOpt_KinBlendT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + CmdOpt_KinBlendStart(builder) + CmdOpt_KinBlendAddBase(builder, baseOffset) + CmdOpt_KinBlendAddDist1(builder, t.Dist1) + CmdOpt_KinBlendAddDist2(builder, t.Dist2) + return CmdOpt_KinBlendEnd(builder) +} + +func (rcv *CmdOpt_KinBlend) UnPackTo(t *CmdOpt_KinBlendT) { + t.Base = rcv.Base(nil).UnPack() + t.Dist1 = rcv.Dist1() + t.Dist2 = rcv.Dist2() +} + +func (rcv *CmdOpt_KinBlend) UnPack() *CmdOpt_KinBlendT { + if rcv == nil { return nil } + t := &CmdOpt_KinBlendT{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinBlend struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinBlend(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinBlend { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinBlend{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinBlend(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinBlend { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinBlend{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinBlend) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinBlend) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinBlend) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinBlend) Dist1() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *CmdOpt_KinBlend) MutateDist1(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *CmdOpt_KinBlend) Dist2() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *CmdOpt_KinBlend) MutateDist2(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func CmdOpt_KinBlendStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CmdOpt_KinBlendAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinBlendAddDist1(builder *flatbuffers.Builder, dist1 float64) { + builder.PrependFloat64Slot(1, dist1, 0.0) +} +func CmdOpt_KinBlendAddDist2(builder *flatbuffers.Builder, dist2 float64) { + builder.PrependFloat64Slot(2, dist2, 0.0) +} +func CmdOpt_KinBlendEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinPolyTrans.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinPolyTrans.go new file mode 100644 index 0000000..7b443c9 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinPolyTrans.go @@ -0,0 +1,134 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinPolyTransT struct { + Base *CmdOpt_BaseT + Dist1 float64 + Dist2 float64 + Eps float64 +} + +func (t *CmdOpt_KinPolyTransT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + CmdOpt_KinPolyTransStart(builder) + CmdOpt_KinPolyTransAddBase(builder, baseOffset) + CmdOpt_KinPolyTransAddDist1(builder, t.Dist1) + CmdOpt_KinPolyTransAddDist2(builder, t.Dist2) + CmdOpt_KinPolyTransAddEps(builder, t.Eps) + return CmdOpt_KinPolyTransEnd(builder) +} + +func (rcv *CmdOpt_KinPolyTrans) UnPackTo(t *CmdOpt_KinPolyTransT) { + t.Base = rcv.Base(nil).UnPack() + t.Dist1 = rcv.Dist1() + t.Dist2 = rcv.Dist2() + t.Eps = rcv.Eps() +} + +func (rcv *CmdOpt_KinPolyTrans) UnPack() *CmdOpt_KinPolyTransT { + if rcv == nil { return nil } + t := &CmdOpt_KinPolyTransT{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinPolyTrans struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinPolyTrans(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinPolyTrans { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinPolyTrans{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinPolyTrans(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinPolyTrans { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinPolyTrans{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinPolyTrans) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinPolyTrans) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinPolyTrans) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinPolyTrans) Dist1() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *CmdOpt_KinPolyTrans) MutateDist1(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *CmdOpt_KinPolyTrans) Dist2() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *CmdOpt_KinPolyTrans) MutateDist2(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *CmdOpt_KinPolyTrans) Eps() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *CmdOpt_KinPolyTrans) MutateEps(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func CmdOpt_KinPolyTransStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func CmdOpt_KinPolyTransAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinPolyTransAddDist1(builder *flatbuffers.Builder, dist1 float64) { + builder.PrependFloat64Slot(1, dist1, 0.0) +} +func CmdOpt_KinPolyTransAddDist2(builder *flatbuffers.Builder, dist2 float64) { + builder.PrependFloat64Slot(2, dist2, 0.0) +} +func CmdOpt_KinPolyTransAddEps(builder *flatbuffers.Builder, eps float64) { + builder.PrependFloat64Slot(3, eps, 0.0) +} +func CmdOpt_KinPolyTransEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetMCS.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetMCS.go new file mode 100644 index 0000000..3d09f53 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetMCS.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinSetMCST struct { + Base *CmdOpt_BaseT + SetName string +} + +func (t *CmdOpt_KinSetMCST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + setNameOffset := builder.CreateString(t.SetName) + CmdOpt_KinSetMCSStart(builder) + CmdOpt_KinSetMCSAddBase(builder, baseOffset) + CmdOpt_KinSetMCSAddSetName(builder, setNameOffset) + return CmdOpt_KinSetMCSEnd(builder) +} + +func (rcv *CmdOpt_KinSetMCS) UnPackTo(t *CmdOpt_KinSetMCST) { + t.Base = rcv.Base(nil).UnPack() + t.SetName = string(rcv.SetName()) +} + +func (rcv *CmdOpt_KinSetMCS) UnPack() *CmdOpt_KinSetMCST { + if rcv == nil { return nil } + t := &CmdOpt_KinSetMCST{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinSetMCS struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinSetMCS(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetMCS { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinSetMCS{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinSetMCS(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetMCS { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinSetMCS{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinSetMCS) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinSetMCS) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinSetMCS) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinSetMCS) SetName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CmdOpt_KinSetMCSStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func CmdOpt_KinSetMCSAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinSetMCSAddSetName(builder *flatbuffers.Builder, setName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(setName), 0) +} +func CmdOpt_KinSetMCSEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetPCS.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetPCS.go new file mode 100644 index 0000000..ea4a281 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetPCS.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinSetPCST struct { + Base *CmdOpt_BaseT + SetName string +} + +func (t *CmdOpt_KinSetPCST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + setNameOffset := builder.CreateString(t.SetName) + CmdOpt_KinSetPCSStart(builder) + CmdOpt_KinSetPCSAddBase(builder, baseOffset) + CmdOpt_KinSetPCSAddSetName(builder, setNameOffset) + return CmdOpt_KinSetPCSEnd(builder) +} + +func (rcv *CmdOpt_KinSetPCS) UnPackTo(t *CmdOpt_KinSetPCST) { + t.Base = rcv.Base(nil).UnPack() + t.SetName = string(rcv.SetName()) +} + +func (rcv *CmdOpt_KinSetPCS) UnPack() *CmdOpt_KinSetPCST { + if rcv == nil { return nil } + t := &CmdOpt_KinSetPCST{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinSetPCS struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinSetPCS(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetPCS { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinSetPCS{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinSetPCS(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetPCS { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinSetPCS{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinSetPCS) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinSetPCS) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinSetPCS) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinSetPCS) SetName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CmdOpt_KinSetPCSStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func CmdOpt_KinSetPCSAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinSetPCSAddSetName(builder *flatbuffers.Builder, setName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(setName), 0) +} +func CmdOpt_KinSetPCSEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetSafeArea.go b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetSafeArea.go new file mode 100644 index 0000000..6e7d454 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdOpt_KinSetSafeArea.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CmdOpt_KinSetSafeAreaT struct { + Base *CmdOpt_BaseT + SafeArea string +} + +func (t *CmdOpt_KinSetSafeAreaT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + safeAreaOffset := builder.CreateString(t.SafeArea) + CmdOpt_KinSetSafeAreaStart(builder) + CmdOpt_KinSetSafeAreaAddBase(builder, baseOffset) + CmdOpt_KinSetSafeAreaAddSafeArea(builder, safeAreaOffset) + return CmdOpt_KinSetSafeAreaEnd(builder) +} + +func (rcv *CmdOpt_KinSetSafeArea) UnPackTo(t *CmdOpt_KinSetSafeAreaT) { + t.Base = rcv.Base(nil).UnPack() + t.SafeArea = string(rcv.SafeArea()) +} + +func (rcv *CmdOpt_KinSetSafeArea) UnPack() *CmdOpt_KinSetSafeAreaT { + if rcv == nil { return nil } + t := &CmdOpt_KinSetSafeAreaT{} + rcv.UnPackTo(t) + return t +} + +type CmdOpt_KinSetSafeArea struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOpt_KinSetSafeArea(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetSafeArea { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOpt_KinSetSafeArea{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOpt_KinSetSafeArea(buf []byte, offset flatbuffers.UOffsetT) *CmdOpt_KinSetSafeArea { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOpt_KinSetSafeArea{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOpt_KinSetSafeArea) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOpt_KinSetSafeArea) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CmdOpt_KinSetSafeArea) Base(obj *CmdOpt_Base) *CmdOpt_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CmdOpt_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *CmdOpt_KinSetSafeArea) SafeArea() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CmdOpt_KinSetSafeAreaStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func CmdOpt_KinSetSafeAreaAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func CmdOpt_KinSetSafeAreaAddSafeArea(builder *flatbuffers.Builder, safeArea flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(safeArea), 0) +} +func CmdOpt_KinSetSafeAreaEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go b/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go new file mode 100644 index 0000000..93140a7 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type CmdTypeCmdOptionInfoReq int8 + +const ( + CmdType_CmdOptionInfoReqUNKNOWN CmdTypeCmdOptionInfoReq = 0 + CmdType_CmdOptionInfoReqCMD CmdTypeCmdOptionInfoReq = 1 + CmdType_CmdOptionInfoReqCMD_OPTION CmdTypeCmdOptionInfoReq = 2 +) + +var EnumNamesCmdType_CmdOptionInfoReq = map[CmdTypeCmdOptionInfoReq]string{ + CmdType_CmdOptionInfoReqUNKNOWN: "UNKNOWN", + CmdType_CmdOptionInfoReqCMD: "CMD", + CmdType_CmdOptionInfoReqCMD_OPTION: "CMD_OPTION", +} + +var EnumValuesCmdType_CmdOptionInfoReq = map[string]CmdTypeCmdOptionInfoReq{ + "UNKNOWN": CmdType_CmdOptionInfoReqUNKNOWN, + "CMD": CmdType_CmdOptionInfoReqCMD, + "CMD_OPTION": CmdType_CmdOptionInfoReqCMD_OPTION, +} + +func (v CmdTypeCmdOptionInfoReq) String() string { + if s, ok := EnumNamesCmdType_CmdOptionInfoReq[v]; ok { + return s + } + return "CmdTypeCmdOptionInfoReq(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go b/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go new file mode 100644 index 0000000..09fb90c --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type CmdTypeListRegisteredCmdsOptions int8 + +const ( + CmdType_ListRegisteredCmdsOptionsUNKNOWN CmdTypeListRegisteredCmdsOptions = 0 + CmdType_ListRegisteredCmdsOptionsCMD CmdTypeListRegisteredCmdsOptions = 1 + CmdType_ListRegisteredCmdsOptionsCMD_OPTION CmdTypeListRegisteredCmdsOptions = 2 +) + +var EnumNamesCmdType_ListRegisteredCmdsOptions = map[CmdTypeListRegisteredCmdsOptions]string{ + CmdType_ListRegisteredCmdsOptionsUNKNOWN: "UNKNOWN", + CmdType_ListRegisteredCmdsOptionsCMD: "CMD", + CmdType_ListRegisteredCmdsOptionsCMD_OPTION: "CMD_OPTION", +} + +var EnumValuesCmdType_ListRegisteredCmdsOptions = map[string]CmdTypeListRegisteredCmdsOptions{ + "UNKNOWN": CmdType_ListRegisteredCmdsOptionsUNKNOWN, + "CMD": CmdType_ListRegisteredCmdsOptionsCMD, + "CMD_OPTION": CmdType_ListRegisteredCmdsOptionsCMD_OPTION, +} + +func (v CmdTypeListRegisteredCmdsOptions) String() string { + if s, ok := EnumNamesCmdType_ListRegisteredCmdsOptions[v]; ok { + return s + } + return "CmdTypeListRegisteredCmdsOptions(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsAbort.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAbort.go new file mode 100644 index 0000000..6b36cb4 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAbort.go @@ -0,0 +1,116 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsAbortT struct { + Base *Cmd_BaseT + Dec float64 + JrkDec float64 +} + +func (t *Cmd_AxsAbortT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + Cmd_AxsAbortStart(builder) + Cmd_AxsAbortAddBase(builder, baseOffset) + Cmd_AxsAbortAddDec(builder, t.Dec) + Cmd_AxsAbortAddJrkDec(builder, t.JrkDec) + return Cmd_AxsAbortEnd(builder) +} + +func (rcv *Cmd_AxsAbort) UnPackTo(t *Cmd_AxsAbortT) { + t.Base = rcv.Base(nil).UnPack() + t.Dec = rcv.Dec() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *Cmd_AxsAbort) UnPack() *Cmd_AxsAbortT { + if rcv == nil { return nil } + t := &Cmd_AxsAbortT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsAbort struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsAbort(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAbort { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsAbort{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsAbort(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAbort { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsAbort{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsAbort) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsAbort) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsAbort) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsAbort) Dec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsAbort) MutateDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *Cmd_AxsAbort) JrkDec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsAbort) MutateJrkDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func Cmd_AxsAbortStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Cmd_AxsAbortAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsAbortAddDec(builder *flatbuffers.Builder, dec float64) { + builder.PrependFloat64Slot(1, dec, 0.0) +} +func Cmd_AxsAbortAddJrkDec(builder *flatbuffers.Builder, jrkDec float64) { + builder.PrependFloat64Slot(2, jrkDec, 0.0) +} +func Cmd_AxsAbortEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToGantry.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToGantry.go new file mode 100644 index 0000000..29635ee --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToGantry.go @@ -0,0 +1,113 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsAddToGantryT struct { + Base *Cmd_BaseT + MasterName string + Buffered bool +} + +func (t *Cmd_AxsAddToGantryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + masterNameOffset := builder.CreateString(t.MasterName) + Cmd_AxsAddToGantryStart(builder) + Cmd_AxsAddToGantryAddBase(builder, baseOffset) + Cmd_AxsAddToGantryAddMasterName(builder, masterNameOffset) + Cmd_AxsAddToGantryAddBuffered(builder, t.Buffered) + return Cmd_AxsAddToGantryEnd(builder) +} + +func (rcv *Cmd_AxsAddToGantry) UnPackTo(t *Cmd_AxsAddToGantryT) { + t.Base = rcv.Base(nil).UnPack() + t.MasterName = string(rcv.MasterName()) + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_AxsAddToGantry) UnPack() *Cmd_AxsAddToGantryT { + if rcv == nil { return nil } + t := &Cmd_AxsAddToGantryT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsAddToGantry struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsAddToGantry(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAddToGantry { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsAddToGantry{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsAddToGantry(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAddToGantry { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsAddToGantry{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsAddToGantry) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsAddToGantry) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsAddToGantry) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsAddToGantry) MasterName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_AxsAddToGantry) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsAddToGantry) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func Cmd_AxsAddToGantryStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Cmd_AxsAddToGantryAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsAddToGantryAddMasterName(builder *flatbuffers.Builder, masterName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(masterName), 0) +} +func Cmd_AxsAddToGantryAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(2, buffered, false) +} +func Cmd_AxsAddToGantryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToKin.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToKin.go new file mode 100644 index 0000000..165d775 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsAddToKin.go @@ -0,0 +1,113 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsAddToKinT struct { + Base *Cmd_BaseT + KinName string + Buffered bool +} + +func (t *Cmd_AxsAddToKinT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + kinNameOffset := builder.CreateString(t.KinName) + Cmd_AxsAddToKinStart(builder) + Cmd_AxsAddToKinAddBase(builder, baseOffset) + Cmd_AxsAddToKinAddKinName(builder, kinNameOffset) + Cmd_AxsAddToKinAddBuffered(builder, t.Buffered) + return Cmd_AxsAddToKinEnd(builder) +} + +func (rcv *Cmd_AxsAddToKin) UnPackTo(t *Cmd_AxsAddToKinT) { + t.Base = rcv.Base(nil).UnPack() + t.KinName = string(rcv.KinName()) + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_AxsAddToKin) UnPack() *Cmd_AxsAddToKinT { + if rcv == nil { return nil } + t := &Cmd_AxsAddToKinT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsAddToKin struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsAddToKin(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAddToKin { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsAddToKin{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsAddToKin(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsAddToKin { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsAddToKin{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsAddToKin) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsAddToKin) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsAddToKin) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsAddToKin) KinName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_AxsAddToKin) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsAddToKin) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func Cmd_AxsAddToKinStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Cmd_AxsAddToKinAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsAddToKinAddKinName(builder *flatbuffers.Builder, kinName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(kinName), 0) +} +func Cmd_AxsAddToKinAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(2, buffered, false) +} +func Cmd_AxsAddToKinEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsJog.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsJog.go new file mode 100644 index 0000000..ad6381b --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsJog.go @@ -0,0 +1,133 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsJogT struct { + Base *Cmd_BaseT + Dir string + Incr float64 + Lim *Cmd_DynLimitsT +} + +func (t *Cmd_AxsJogT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + dirOffset := builder.CreateString(t.Dir) + limOffset := t.Lim.Pack(builder) + Cmd_AxsJogStart(builder) + Cmd_AxsJogAddBase(builder, baseOffset) + Cmd_AxsJogAddDir(builder, dirOffset) + Cmd_AxsJogAddIncr(builder, t.Incr) + Cmd_AxsJogAddLim(builder, limOffset) + return Cmd_AxsJogEnd(builder) +} + +func (rcv *Cmd_AxsJog) UnPackTo(t *Cmd_AxsJogT) { + t.Base = rcv.Base(nil).UnPack() + t.Dir = string(rcv.Dir()) + t.Incr = rcv.Incr() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *Cmd_AxsJog) UnPack() *Cmd_AxsJogT { + if rcv == nil { return nil } + t := &Cmd_AxsJogT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsJog struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsJog(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsJog { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsJog{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsJog(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsJog { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsJog{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsJog) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsJog) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsJog) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsJog) Dir() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_AxsJog) Incr() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsJog) MutateIncr(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *Cmd_AxsJog) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func Cmd_AxsJogStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_AxsJogAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsJogAddDir(builder *flatbuffers.Builder, dir flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dir), 0) +} +func Cmd_AxsJogAddIncr(builder *flatbuffers.Builder, incr float64) { + builder.PrependFloat64Slot(2, incr, 0.0) +} +func Cmd_AxsJogAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_AxsJogEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsPos.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsPos.go new file mode 100644 index 0000000..5af4bb1 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsPos.go @@ -0,0 +1,136 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsPosT struct { + Base *Cmd_BaseT + Pos float64 + Buffered bool + Lim *Cmd_DynLimitsT +} + +func (t *Cmd_AxsPosT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + limOffset := t.Lim.Pack(builder) + Cmd_AxsPosStart(builder) + Cmd_AxsPosAddBase(builder, baseOffset) + Cmd_AxsPosAddPos(builder, t.Pos) + Cmd_AxsPosAddBuffered(builder, t.Buffered) + Cmd_AxsPosAddLim(builder, limOffset) + return Cmd_AxsPosEnd(builder) +} + +func (rcv *Cmd_AxsPos) UnPackTo(t *Cmd_AxsPosT) { + t.Base = rcv.Base(nil).UnPack() + t.Pos = rcv.Pos() + t.Buffered = rcv.Buffered() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *Cmd_AxsPos) UnPack() *Cmd_AxsPosT { + if rcv == nil { return nil } + t := &Cmd_AxsPosT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsPos struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsPos(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsPos { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsPos{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsPos(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsPos { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsPos{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsPos) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsPos) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsPos) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsPos) Pos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsPos) MutatePos(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *Cmd_AxsPos) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsPos) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func (rcv *Cmd_AxsPos) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func Cmd_AxsPosStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_AxsPosAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsPosAddPos(builder *flatbuffers.Builder, pos float64) { + builder.PrependFloat64Slot(1, pos, 0.0) +} +func Cmd_AxsPosAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(2, buffered, false) +} +func Cmd_AxsPosAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_AxsPosEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsPower.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsPower.go new file mode 100644 index 0000000..959a3de --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsPower.go @@ -0,0 +1,98 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsPowerT struct { + Base *Cmd_BaseT + SwitchOn bool +} + +func (t *Cmd_AxsPowerT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + Cmd_AxsPowerStart(builder) + Cmd_AxsPowerAddBase(builder, baseOffset) + Cmd_AxsPowerAddSwitchOn(builder, t.SwitchOn) + return Cmd_AxsPowerEnd(builder) +} + +func (rcv *Cmd_AxsPower) UnPackTo(t *Cmd_AxsPowerT) { + t.Base = rcv.Base(nil).UnPack() + t.SwitchOn = rcv.SwitchOn() +} + +func (rcv *Cmd_AxsPower) UnPack() *Cmd_AxsPowerT { + if rcv == nil { return nil } + t := &Cmd_AxsPowerT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsPower struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsPower(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsPower { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsPower{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsPower(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsPower { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsPower{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsPower) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsPower) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsPower) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsPower) SwitchOn() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsPower) MutateSwitchOn(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func Cmd_AxsPowerStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Cmd_AxsPowerAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsPowerAddSwitchOn(builder *flatbuffers.Builder, switchOn bool) { + builder.PrependBoolSlot(1, switchOn, false) +} +func Cmd_AxsPowerEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsVelocity.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsVelocity.go new file mode 100644 index 0000000..96de9fe --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsVelocity.go @@ -0,0 +1,154 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsVelocityT struct { + Base *Cmd_BaseT + Vel float64 + DriveVelMode bool + Buffered bool + Lim *Cmd_DynLimitsT +} + +func (t *Cmd_AxsVelocityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + limOffset := t.Lim.Pack(builder) + Cmd_AxsVelocityStart(builder) + Cmd_AxsVelocityAddBase(builder, baseOffset) + Cmd_AxsVelocityAddVel(builder, t.Vel) + Cmd_AxsVelocityAddDriveVelMode(builder, t.DriveVelMode) + Cmd_AxsVelocityAddBuffered(builder, t.Buffered) + Cmd_AxsVelocityAddLim(builder, limOffset) + return Cmd_AxsVelocityEnd(builder) +} + +func (rcv *Cmd_AxsVelocity) UnPackTo(t *Cmd_AxsVelocityT) { + t.Base = rcv.Base(nil).UnPack() + t.Vel = rcv.Vel() + t.DriveVelMode = rcv.DriveVelMode() + t.Buffered = rcv.Buffered() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *Cmd_AxsVelocity) UnPack() *Cmd_AxsVelocityT { + if rcv == nil { return nil } + t := &Cmd_AxsVelocityT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsVelocity struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsVelocity(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsVelocity { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsVelocity{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsVelocity(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsVelocity { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsVelocity{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsVelocity) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsVelocity) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsVelocity) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsVelocity) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsVelocity) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *Cmd_AxsVelocity) DriveVelMode() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsVelocity) MutateDriveVelMode(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func (rcv *Cmd_AxsVelocity) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsVelocity) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func (rcv *Cmd_AxsVelocity) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func Cmd_AxsVelocityStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func Cmd_AxsVelocityAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsVelocityAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(1, vel, 0.0) +} +func Cmd_AxsVelocityAddDriveVelMode(builder *flatbuffers.Builder, driveVelMode bool) { + builder.PrependBoolSlot(2, driveVelMode, false) +} +func Cmd_AxsVelocityAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(3, buffered, false) +} +func Cmd_AxsVelocityAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_AxsVelocityEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_Base.go b/pkg/fbs/script/manager/fbtypes/Cmd_Base.go index c59b788..723599f 100644 --- a/pkg/fbs/script/manager/fbtypes/Cmd_Base.go +++ b/pkg/fbs/script/manager/fbtypes/Cmd_Base.go @@ -6,6 +6,36 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Cmd_BaseT struct { + Name string + Source string + Line uint64 +} + +func (t *Cmd_BaseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + sourceOffset := builder.CreateString(t.Source) + Cmd_BaseStart(builder) + Cmd_BaseAddName(builder, nameOffset) + Cmd_BaseAddSource(builder, sourceOffset) + Cmd_BaseAddLine(builder, t.Line) + return Cmd_BaseEnd(builder) +} + +func (rcv *Cmd_Base) UnPackTo(t *Cmd_BaseT) { + t.Name = string(rcv.Name()) + t.Source = string(rcv.Source()) + t.Line = rcv.Line() +} + +func (rcv *Cmd_Base) UnPack() *Cmd_BaseT { + if rcv == nil { return nil } + t := &Cmd_BaseT{} + rcv.UnPackTo(t) + return t +} + type Cmd_Base struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_DynLimits.go b/pkg/fbs/script/manager/fbtypes/Cmd_DynLimits.go new file mode 100644 index 0000000..0e25e0a --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_DynLimits.go @@ -0,0 +1,150 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_DynLimitsT struct { + Vel float64 + Acc float64 + Dec float64 + JrkAcc float64 + JrkDec float64 +} + +func (t *Cmd_DynLimitsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Cmd_DynLimitsStart(builder) + Cmd_DynLimitsAddVel(builder, t.Vel) + Cmd_DynLimitsAddAcc(builder, t.Acc) + Cmd_DynLimitsAddDec(builder, t.Dec) + Cmd_DynLimitsAddJrkAcc(builder, t.JrkAcc) + Cmd_DynLimitsAddJrkDec(builder, t.JrkDec) + return Cmd_DynLimitsEnd(builder) +} + +func (rcv *Cmd_DynLimits) UnPackTo(t *Cmd_DynLimitsT) { + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Dec = rcv.Dec() + t.JrkAcc = rcv.JrkAcc() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *Cmd_DynLimits) UnPack() *Cmd_DynLimitsT { + if rcv == nil { return nil } + t := &Cmd_DynLimitsT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_DynLimits struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_DynLimits(buf []byte, offset flatbuffers.UOffsetT) *Cmd_DynLimits { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_DynLimits{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_DynLimits(buf []byte, offset flatbuffers.UOffsetT) *Cmd_DynLimits { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_DynLimits{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_DynLimits) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_DynLimits) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_DynLimits) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_DynLimits) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *Cmd_DynLimits) Acc() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_DynLimits) MutateAcc(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *Cmd_DynLimits) Dec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_DynLimits) MutateDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *Cmd_DynLimits) JrkAcc() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_DynLimits) MutateJrkAcc(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func (rcv *Cmd_DynLimits) JrkDec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_DynLimits) MutateJrkDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(12, n) +} + +func Cmd_DynLimitsStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func Cmd_DynLimitsAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(0, vel, 0.0) +} +func Cmd_DynLimitsAddAcc(builder *flatbuffers.Builder, acc float64) { + builder.PrependFloat64Slot(1, acc, 0.0) +} +func Cmd_DynLimitsAddDec(builder *flatbuffers.Builder, dec float64) { + builder.PrependFloat64Slot(2, dec, 0.0) +} +func Cmd_DynLimitsAddJrkAcc(builder *flatbuffers.Builder, jrkAcc float64) { + builder.PrependFloat64Slot(3, jrkAcc, 0.0) +} +func Cmd_DynLimitsAddJrkDec(builder *flatbuffers.Builder, jrkDec float64) { + builder.PrependFloat64Slot(4, jrkDec, 0.0) +} +func Cmd_DynLimitsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_GenCmdOption.go b/pkg/fbs/script/manager/fbtypes/Cmd_GenCmdOption.go new file mode 100644 index 0000000..1f950bf --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_GenCmdOption.go @@ -0,0 +1,160 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_GenCmdOptionT struct { + Base *Cmd_BaseT + CmdName string + ObjType ObjectTypeGenCmdOption + Params []byte +} + +func (t *Cmd_GenCmdOptionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + cmdNameOffset := builder.CreateString(t.CmdName) + paramsOffset := flatbuffers.UOffsetT(0) + if t.Params != nil { + paramsOffset = builder.CreateByteString(t.Params) + } + Cmd_GenCmdOptionStart(builder) + Cmd_GenCmdOptionAddBase(builder, baseOffset) + Cmd_GenCmdOptionAddCmdName(builder, cmdNameOffset) + Cmd_GenCmdOptionAddObjType(builder, t.ObjType) + Cmd_GenCmdOptionAddParams(builder, paramsOffset) + return Cmd_GenCmdOptionEnd(builder) +} + +func (rcv *Cmd_GenCmdOption) UnPackTo(t *Cmd_GenCmdOptionT) { + t.Base = rcv.Base(nil).UnPack() + t.CmdName = string(rcv.CmdName()) + t.ObjType = rcv.ObjType() + t.Params = rcv.ParamsBytes() +} + +func (rcv *Cmd_GenCmdOption) UnPack() *Cmd_GenCmdOptionT { + if rcv == nil { return nil } + t := &Cmd_GenCmdOptionT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_GenCmdOption struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_GenCmdOption(buf []byte, offset flatbuffers.UOffsetT) *Cmd_GenCmdOption { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_GenCmdOption{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_GenCmdOption(buf []byte, offset flatbuffers.UOffsetT) *Cmd_GenCmdOption { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_GenCmdOption{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_GenCmdOption) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_GenCmdOption) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_GenCmdOption) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_GenCmdOption) CmdName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_GenCmdOption) ObjType() ObjectTypeGenCmdOption { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return ObjectTypeGenCmdOption(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Cmd_GenCmdOption) MutateObjType(n ObjectTypeGenCmdOption) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +func (rcv *Cmd_GenCmdOption) Params(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *Cmd_GenCmdOption) ParamsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Cmd_GenCmdOption) ParamsBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_GenCmdOption) MutateParams(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func Cmd_GenCmdOptionStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_GenCmdOptionAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_GenCmdOptionAddCmdName(builder *flatbuffers.Builder, cmdName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(cmdName), 0) +} +func Cmd_GenCmdOptionAddObjType(builder *flatbuffers.Builder, objType ObjectTypeGenCmdOption) { + builder.PrependInt8Slot(2, int8(objType), 0) +} +func Cmd_GenCmdOptionAddParams(builder *flatbuffers.Builder, params flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(params), 0) +} +func Cmd_GenCmdOptionStartParamsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func Cmd_GenCmdOptionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinAbort.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinAbort.go new file mode 100644 index 0000000..adb9c07 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinAbort.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinAbortT struct { + Base *Cmd_BaseT + Type string +} + +func (t *Cmd_KinAbortT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + typeOffset := builder.CreateString(t.Type) + Cmd_KinAbortStart(builder) + Cmd_KinAbortAddBase(builder, baseOffset) + Cmd_KinAbortAddType(builder, typeOffset) + return Cmd_KinAbortEnd(builder) +} + +func (rcv *Cmd_KinAbort) UnPackTo(t *Cmd_KinAbortT) { + t.Base = rcv.Base(nil).UnPack() + t.Type = string(rcv.Type()) +} + +func (rcv *Cmd_KinAbort) UnPack() *Cmd_KinAbortT { + if rcv == nil { return nil } + t := &Cmd_KinAbortT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinAbort struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinAbort(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinAbort { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinAbort{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinAbort(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinAbort { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinAbort{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinAbort) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinAbort) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinAbort) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinAbort) Type() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func Cmd_KinAbortStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Cmd_KinAbortAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinAbortAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(type_), 0) +} +func Cmd_KinAbortEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinContour.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinContour.go new file mode 100644 index 0000000..2e677c3 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinContour.go @@ -0,0 +1,116 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinContourT struct { + Base *Cmd_BaseT + IsStart bool + PrepCmds uint32 +} + +func (t *Cmd_KinContourT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + Cmd_KinContourStart(builder) + Cmd_KinContourAddBase(builder, baseOffset) + Cmd_KinContourAddIsStart(builder, t.IsStart) + Cmd_KinContourAddPrepCmds(builder, t.PrepCmds) + return Cmd_KinContourEnd(builder) +} + +func (rcv *Cmd_KinContour) UnPackTo(t *Cmd_KinContourT) { + t.Base = rcv.Base(nil).UnPack() + t.IsStart = rcv.IsStart() + t.PrepCmds = rcv.PrepCmds() +} + +func (rcv *Cmd_KinContour) UnPack() *Cmd_KinContourT { + if rcv == nil { return nil } + t := &Cmd_KinContourT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinContour struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinContour(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinContour { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinContour{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinContour(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinContour { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinContour{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinContour) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinContour) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinContour) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinContour) IsStart() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +func (rcv *Cmd_KinContour) MutateIsStart(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *Cmd_KinContour) PrepCmds() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Cmd_KinContour) MutatePrepCmds(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func Cmd_KinContourStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Cmd_KinContourAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinContourAddIsStart(builder *flatbuffers.Builder, isStart bool) { + builder.PrependBoolSlot(1, isStart, true) +} +func Cmd_KinContourAddPrepCmds(builder *flatbuffers.Builder, prepCmds uint32) { + builder.PrependUint32Slot(2, prepCmds, 0) +} +func Cmd_KinContourEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinJog.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinJog.go new file mode 100644 index 0000000..5bdf991 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinJog.go @@ -0,0 +1,181 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinJogT struct { + Base *Cmd_BaseT + Dir []float64 + CoordSys string + Incr float64 + Lim *Cmd_DynLimitsT +} + +func (t *Cmd_KinJogT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + dirOffset := flatbuffers.UOffsetT(0) + if t.Dir != nil { + dirLength := len(t.Dir) + Cmd_KinJogStartDirVector(builder, dirLength) + for j := dirLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Dir[j]) + } + dirOffset = builder.EndVector(dirLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + limOffset := t.Lim.Pack(builder) + Cmd_KinJogStart(builder) + Cmd_KinJogAddBase(builder, baseOffset) + Cmd_KinJogAddDir(builder, dirOffset) + Cmd_KinJogAddCoordSys(builder, coordSysOffset) + Cmd_KinJogAddIncr(builder, t.Incr) + Cmd_KinJogAddLim(builder, limOffset) + return Cmd_KinJogEnd(builder) +} + +func (rcv *Cmd_KinJog) UnPackTo(t *Cmd_KinJogT) { + t.Base = rcv.Base(nil).UnPack() + dirLength := rcv.DirLength() + t.Dir = make([]float64, dirLength) + for j := 0; j < dirLength; j++ { + t.Dir[j] = rcv.Dir(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.Incr = rcv.Incr() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *Cmd_KinJog) UnPack() *Cmd_KinJogT { + if rcv == nil { return nil } + t := &Cmd_KinJogT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinJog struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinJog(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinJog { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinJog{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinJog(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinJog { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinJog{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinJog) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinJog) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinJog) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinJog) Dir(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *Cmd_KinJog) DirLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Cmd_KinJog) MutateDir(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *Cmd_KinJog) CoordSys() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_KinJog) Incr() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_KinJog) MutateIncr(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func (rcv *Cmd_KinJog) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func Cmd_KinJogStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func Cmd_KinJogAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinJogAddDir(builder *flatbuffers.Builder, dir flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dir), 0) +} +func Cmd_KinJogStartDirVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func Cmd_KinJogAddCoordSys(builder *flatbuffers.Builder, coordSys flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(coordSys), 0) +} +func Cmd_KinJogAddIncr(builder *flatbuffers.Builder, incr float64) { + builder.PrependFloat64Slot(3, incr, 0.0) +} +func Cmd_KinJogAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_KinJogEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirect.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirect.go new file mode 100644 index 0000000..dfbc8c2 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirect.go @@ -0,0 +1,161 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinMoveDirectT struct { + Base *Cmd_BaseT + Pos []float64 + CoordSys string + Buffered bool +} + +func (t *Cmd_KinMoveDirectT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + posOffset := flatbuffers.UOffsetT(0) + if t.Pos != nil { + posLength := len(t.Pos) + Cmd_KinMoveDirectStartPosVector(builder, posLength) + for j := posLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Pos[j]) + } + posOffset = builder.EndVector(posLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + Cmd_KinMoveDirectStart(builder) + Cmd_KinMoveDirectAddBase(builder, baseOffset) + Cmd_KinMoveDirectAddPos(builder, posOffset) + Cmd_KinMoveDirectAddCoordSys(builder, coordSysOffset) + Cmd_KinMoveDirectAddBuffered(builder, t.Buffered) + return Cmd_KinMoveDirectEnd(builder) +} + +func (rcv *Cmd_KinMoveDirect) UnPackTo(t *Cmd_KinMoveDirectT) { + t.Base = rcv.Base(nil).UnPack() + posLength := rcv.PosLength() + t.Pos = make([]float64, posLength) + for j := 0; j < posLength; j++ { + t.Pos[j] = rcv.Pos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_KinMoveDirect) UnPack() *Cmd_KinMoveDirectT { + if rcv == nil { return nil } + t := &Cmd_KinMoveDirectT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinMoveDirect struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinMoveDirect(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveDirect { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinMoveDirect{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinMoveDirect(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveDirect { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinMoveDirect{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinMoveDirect) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinMoveDirect) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinMoveDirect) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinMoveDirect) Pos(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *Cmd_KinMoveDirect) PosLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Cmd_KinMoveDirect) MutatePos(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *Cmd_KinMoveDirect) CoordSys() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_KinMoveDirect) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +func (rcv *Cmd_KinMoveDirect) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func Cmd_KinMoveDirectStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_KinMoveDirectAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinMoveDirectAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(pos), 0) +} +func Cmd_KinMoveDirectStartPosVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func Cmd_KinMoveDirectAddCoordSys(builder *flatbuffers.Builder, coordSys flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(coordSys), 0) +} +func Cmd_KinMoveDirectAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(3, buffered, true) +} +func Cmd_KinMoveDirectEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirectAsync.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirectAsync.go new file mode 100644 index 0000000..27376f8 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveDirectAsync.go @@ -0,0 +1,181 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinMoveDirectAsyncT struct { + Base *Cmd_BaseT + Pos []float64 + CoordSys string + DynLimFactors *Cmd_DynLimitsT + Buffered bool +} + +func (t *Cmd_KinMoveDirectAsyncT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + posOffset := flatbuffers.UOffsetT(0) + if t.Pos != nil { + posLength := len(t.Pos) + Cmd_KinMoveDirectAsyncStartPosVector(builder, posLength) + for j := posLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Pos[j]) + } + posOffset = builder.EndVector(posLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + dynLimFactorsOffset := t.DynLimFactors.Pack(builder) + Cmd_KinMoveDirectAsyncStart(builder) + Cmd_KinMoveDirectAsyncAddBase(builder, baseOffset) + Cmd_KinMoveDirectAsyncAddPos(builder, posOffset) + Cmd_KinMoveDirectAsyncAddCoordSys(builder, coordSysOffset) + Cmd_KinMoveDirectAsyncAddDynLimFactors(builder, dynLimFactorsOffset) + Cmd_KinMoveDirectAsyncAddBuffered(builder, t.Buffered) + return Cmd_KinMoveDirectAsyncEnd(builder) +} + +func (rcv *Cmd_KinMoveDirectAsync) UnPackTo(t *Cmd_KinMoveDirectAsyncT) { + t.Base = rcv.Base(nil).UnPack() + posLength := rcv.PosLength() + t.Pos = make([]float64, posLength) + for j := 0; j < posLength; j++ { + t.Pos[j] = rcv.Pos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.DynLimFactors = rcv.DynLimFactors(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_KinMoveDirectAsync) UnPack() *Cmd_KinMoveDirectAsyncT { + if rcv == nil { return nil } + t := &Cmd_KinMoveDirectAsyncT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinMoveDirectAsync struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinMoveDirectAsync(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveDirectAsync { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinMoveDirectAsync{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinMoveDirectAsync(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveDirectAsync { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinMoveDirectAsync{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinMoveDirectAsync) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinMoveDirectAsync) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinMoveDirectAsync) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinMoveDirectAsync) Pos(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *Cmd_KinMoveDirectAsync) PosLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Cmd_KinMoveDirectAsync) MutatePos(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *Cmd_KinMoveDirectAsync) CoordSys() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_KinMoveDirectAsync) DynLimFactors(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinMoveDirectAsync) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +func (rcv *Cmd_KinMoveDirectAsync) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(12, n) +} + +func Cmd_KinMoveDirectAsyncStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func Cmd_KinMoveDirectAsyncAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinMoveDirectAsyncAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(pos), 0) +} +func Cmd_KinMoveDirectAsyncStartPosVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func Cmd_KinMoveDirectAsyncAddCoordSys(builder *flatbuffers.Builder, coordSys flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(coordSys), 0) +} +func Cmd_KinMoveDirectAsyncAddDynLimFactors(builder *flatbuffers.Builder, dynLimFactors flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(dynLimFactors), 0) +} +func Cmd_KinMoveDirectAsyncAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(4, buffered, true) +} +func Cmd_KinMoveDirectAsyncEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveLin.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveLin.go new file mode 100644 index 0000000..c6c275f --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveLin.go @@ -0,0 +1,181 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinMoveLinT struct { + Base *Cmd_BaseT + Pos []float64 + CoordSys string + Lim *Cmd_DynLimitsT + Buffered bool +} + +func (t *Cmd_KinMoveLinT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + posOffset := flatbuffers.UOffsetT(0) + if t.Pos != nil { + posLength := len(t.Pos) + Cmd_KinMoveLinStartPosVector(builder, posLength) + for j := posLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Pos[j]) + } + posOffset = builder.EndVector(posLength) + } + coordSysOffset := builder.CreateString(t.CoordSys) + limOffset := t.Lim.Pack(builder) + Cmd_KinMoveLinStart(builder) + Cmd_KinMoveLinAddBase(builder, baseOffset) + Cmd_KinMoveLinAddPos(builder, posOffset) + Cmd_KinMoveLinAddCoordSys(builder, coordSysOffset) + Cmd_KinMoveLinAddLim(builder, limOffset) + Cmd_KinMoveLinAddBuffered(builder, t.Buffered) + return Cmd_KinMoveLinEnd(builder) +} + +func (rcv *Cmd_KinMoveLin) UnPackTo(t *Cmd_KinMoveLinT) { + t.Base = rcv.Base(nil).UnPack() + posLength := rcv.PosLength() + t.Pos = make([]float64, posLength) + for j := 0; j < posLength; j++ { + t.Pos[j] = rcv.Pos(j) + } + t.CoordSys = string(rcv.CoordSys()) + t.Lim = rcv.Lim(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_KinMoveLin) UnPack() *Cmd_KinMoveLinT { + if rcv == nil { return nil } + t := &Cmd_KinMoveLinT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinMoveLin struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinMoveLin(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveLin { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinMoveLin{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinMoveLin(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveLin { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinMoveLin{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinMoveLin) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinMoveLin) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinMoveLin) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinMoveLin) Pos(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *Cmd_KinMoveLin) PosLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *Cmd_KinMoveLin) MutatePos(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *Cmd_KinMoveLin) CoordSys() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Cmd_KinMoveLin) Lim(obj *Cmd_DynLimits) *Cmd_DynLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_DynLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_KinMoveLin) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +func (rcv *Cmd_KinMoveLin) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(12, n) +} + +func Cmd_KinMoveLinStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func Cmd_KinMoveLinAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinMoveLinAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(pos), 0) +} +func Cmd_KinMoveLinStartPosVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func Cmd_KinMoveLinAddCoordSys(builder *flatbuffers.Builder, coordSys flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(coordSys), 0) +} +func Cmd_KinMoveLinAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_KinMoveLinAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(4, buffered, true) +} +func Cmd_KinMoveLinEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/DL_Write.go b/pkg/fbs/script/manager/fbtypes/DL_Write.go index 0747db3..d112bb7 100644 --- a/pkg/fbs/script/manager/fbtypes/DL_Write.go +++ b/pkg/fbs/script/manager/fbtypes/DL_Write.go @@ -6,6 +6,45 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DL_WriteT struct { + Path string + Type int32 + S string + I int64 + B bool + D float64 +} + +func (t *DL_WriteT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pathOffset := builder.CreateString(t.Path) + sOffset := builder.CreateString(t.S) + DL_WriteStart(builder) + DL_WriteAddPath(builder, pathOffset) + DL_WriteAddType(builder, t.Type) + DL_WriteAddS(builder, sOffset) + DL_WriteAddI(builder, t.I) + DL_WriteAddB(builder, t.B) + DL_WriteAddD(builder, t.D) + return DL_WriteEnd(builder) +} + +func (rcv *DL_Write) UnPackTo(t *DL_WriteT) { + t.Path = string(rcv.Path()) + t.Type = rcv.Type() + t.S = string(rcv.S()) + t.I = rcv.I() + t.B = rcv.B() + t.D = rcv.D() +} + +func (rcv *DL_Write) UnPack() *DL_WriteT { + if rcv == nil { return nil } + t := &DL_WriteT{} + rcv.UnPackTo(t) + return t +} + type DL_Write struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/DiagInfo.go b/pkg/fbs/script/manager/fbtypes/DiagInfo.go index 3ad4406..9c0ce49 100644 --- a/pkg/fbs/script/manager/fbtypes/DiagInfo.go +++ b/pkg/fbs/script/manager/fbtypes/DiagInfo.go @@ -6,6 +6,55 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type DiagInfoT struct { + LastMainDiag uint32 + LastDetailDiag uint32 + LastErrText string + LastErrTrace []string +} + +func (t *DiagInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + lastErrTextOffset := builder.CreateString(t.LastErrText) + lastErrTraceOffset := flatbuffers.UOffsetT(0) + if t.LastErrTrace != nil { + lastErrTraceLength := len(t.LastErrTrace) + lastErrTraceOffsets := make([]flatbuffers.UOffsetT, lastErrTraceLength) + for j := 0; j < lastErrTraceLength; j++ { + lastErrTraceOffsets[j] = builder.CreateString(t.LastErrTrace[j]) + } + DiagInfoStartLastErrTraceVector(builder, lastErrTraceLength) + for j := lastErrTraceLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(lastErrTraceOffsets[j]) + } + lastErrTraceOffset = builder.EndVector(lastErrTraceLength) + } + DiagInfoStart(builder) + DiagInfoAddLastMainDiag(builder, t.LastMainDiag) + DiagInfoAddLastDetailDiag(builder, t.LastDetailDiag) + DiagInfoAddLastErrText(builder, lastErrTextOffset) + DiagInfoAddLastErrTrace(builder, lastErrTraceOffset) + return DiagInfoEnd(builder) +} + +func (rcv *DiagInfo) UnPackTo(t *DiagInfoT) { + t.LastMainDiag = rcv.LastMainDiag() + t.LastDetailDiag = rcv.LastDetailDiag() + t.LastErrText = string(rcv.LastErrText()) + lastErrTraceLength := rcv.LastErrTraceLength() + t.LastErrTrace = make([]string, lastErrTraceLength) + for j := 0; j < lastErrTraceLength; j++ { + t.LastErrTrace[j] = string(rcv.LastErrTrace(j)) + } +} + +func (rcv *DiagInfo) UnPack() *DiagInfoT { + if rcv == nil { return nil } + t := &DiagInfoT{} + rcv.UnPackTo(t) + return t +} + type DiagInfo struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/GlobalCfg.go b/pkg/fbs/script/manager/fbtypes/GlobalCfg.go index 8602b13..ad5bded 100644 --- a/pkg/fbs/script/manager/fbtypes/GlobalCfg.go +++ b/pkg/fbs/script/manager/fbtypes/GlobalCfg.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type GlobalCfgT struct { + InitScript string + InitScriptParam []string +} + +func (t *GlobalCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + initScriptOffset := builder.CreateString(t.InitScript) + initScriptParamOffset := flatbuffers.UOffsetT(0) + if t.InitScriptParam != nil { + initScriptParamLength := len(t.InitScriptParam) + initScriptParamOffsets := make([]flatbuffers.UOffsetT, initScriptParamLength) + for j := 0; j < initScriptParamLength; j++ { + initScriptParamOffsets[j] = builder.CreateString(t.InitScriptParam[j]) + } + GlobalCfgStartInitScriptParamVector(builder, initScriptParamLength) + for j := initScriptParamLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(initScriptParamOffsets[j]) + } + initScriptParamOffset = builder.EndVector(initScriptParamLength) + } + GlobalCfgStart(builder) + GlobalCfgAddInitScript(builder, initScriptOffset) + GlobalCfgAddInitScriptParam(builder, initScriptParamOffset) + return GlobalCfgEnd(builder) +} + +func (rcv *GlobalCfg) UnPackTo(t *GlobalCfgT) { + t.InitScript = string(rcv.InitScript()) + initScriptParamLength := rcv.InitScriptParamLength() + t.InitScriptParam = make([]string, initScriptParamLength) + for j := 0; j < initScriptParamLength; j++ { + t.InitScriptParam[j] = string(rcv.InitScriptParam(j)) + } +} + +func (rcv *GlobalCfg) UnPack() *GlobalCfgT { + if rcv == nil { return nil } + t := &GlobalCfgT{} + rcv.UnPackTo(t) + return t +} + type GlobalCfg struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/Misc_ActCmdData.go b/pkg/fbs/script/manager/fbtypes/Misc_ActCmdData.go new file mode 100644 index 0000000..0befbd8 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_ActCmdData.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_ActCmdDataT struct { + SrcName string + SrcType string + SrcLine uint64 +} + +func (t *Misc_ActCmdDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + srcNameOffset := builder.CreateString(t.SrcName) + srcTypeOffset := builder.CreateString(t.SrcType) + Misc_ActCmdDataStart(builder) + Misc_ActCmdDataAddSrcName(builder, srcNameOffset) + Misc_ActCmdDataAddSrcType(builder, srcTypeOffset) + Misc_ActCmdDataAddSrcLine(builder, t.SrcLine) + return Misc_ActCmdDataEnd(builder) +} + +func (rcv *Misc_ActCmdData) UnPackTo(t *Misc_ActCmdDataT) { + t.SrcName = string(rcv.SrcName()) + t.SrcType = string(rcv.SrcType()) + t.SrcLine = rcv.SrcLine() +} + +func (rcv *Misc_ActCmdData) UnPack() *Misc_ActCmdDataT { + if rcv == nil { return nil } + t := &Misc_ActCmdDataT{} + rcv.UnPackTo(t) + return t +} + +type Misc_ActCmdData struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_ActCmdData(buf []byte, offset flatbuffers.UOffsetT) *Misc_ActCmdData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_ActCmdData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_ActCmdData(buf []byte, offset flatbuffers.UOffsetT) *Misc_ActCmdData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_ActCmdData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_ActCmdData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_ActCmdData) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_ActCmdData) SrcName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Misc_ActCmdData) SrcType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Misc_ActCmdData) SrcLine() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Misc_ActCmdData) MutateSrcLine(n uint64) bool { + return rcv._tab.MutateUint64Slot(8, n) +} + +func Misc_ActCmdDataStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Misc_ActCmdDataAddSrcName(builder *flatbuffers.Builder, srcName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(srcName), 0) +} +func Misc_ActCmdDataAddSrcType(builder *flatbuffers.Builder, srcType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(srcType), 0) +} +func Misc_ActCmdDataAddSrcLine(builder *flatbuffers.Builder, srcLine uint64) { + builder.PrependUint64Slot(2, srcLine, 0) +} +func Misc_ActCmdDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoReq.go b/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoReq.go new file mode 100644 index 0000000..45399e8 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoReq.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_CmdOptionInfoReqT struct { + CmdName string + ObjType ObjectTypeCmdOptionInfoReq + CmdType CmdTypeCmdOptionInfoReq +} + +func (t *Misc_CmdOptionInfoReqT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdNameOffset := builder.CreateString(t.CmdName) + Misc_CmdOptionInfoReqStart(builder) + Misc_CmdOptionInfoReqAddCmdName(builder, cmdNameOffset) + Misc_CmdOptionInfoReqAddObjType(builder, t.ObjType) + Misc_CmdOptionInfoReqAddCmdType(builder, t.CmdType) + return Misc_CmdOptionInfoReqEnd(builder) +} + +func (rcv *Misc_CmdOptionInfoReq) UnPackTo(t *Misc_CmdOptionInfoReqT) { + t.CmdName = string(rcv.CmdName()) + t.ObjType = rcv.ObjType() + t.CmdType = rcv.CmdType() +} + +func (rcv *Misc_CmdOptionInfoReq) UnPack() *Misc_CmdOptionInfoReqT { + if rcv == nil { return nil } + t := &Misc_CmdOptionInfoReqT{} + rcv.UnPackTo(t) + return t +} + +type Misc_CmdOptionInfoReq struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_CmdOptionInfoReq(buf []byte, offset flatbuffers.UOffsetT) *Misc_CmdOptionInfoReq { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_CmdOptionInfoReq{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_CmdOptionInfoReq(buf []byte, offset flatbuffers.UOffsetT) *Misc_CmdOptionInfoReq { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_CmdOptionInfoReq{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_CmdOptionInfoReq) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_CmdOptionInfoReq) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_CmdOptionInfoReq) CmdName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Misc_CmdOptionInfoReq) ObjType() ObjectTypeCmdOptionInfoReq { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return ObjectTypeCmdOptionInfoReq(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Misc_CmdOptionInfoReq) MutateObjType(n ObjectTypeCmdOptionInfoReq) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func (rcv *Misc_CmdOptionInfoReq) CmdType() CmdTypeCmdOptionInfoReq { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return CmdTypeCmdOptionInfoReq(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Misc_CmdOptionInfoReq) MutateCmdType(n CmdTypeCmdOptionInfoReq) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +func Misc_CmdOptionInfoReqStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func Misc_CmdOptionInfoReqAddCmdName(builder *flatbuffers.Builder, cmdName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(cmdName), 0) +} +func Misc_CmdOptionInfoReqAddObjType(builder *flatbuffers.Builder, objType ObjectTypeCmdOptionInfoReq) { + builder.PrependInt8Slot(1, int8(objType), 0) +} +func Misc_CmdOptionInfoReqAddCmdType(builder *flatbuffers.Builder, cmdType CmdTypeCmdOptionInfoReq) { + builder.PrependInt8Slot(2, int8(cmdType), 0) +} +func Misc_CmdOptionInfoReqEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoResp.go b/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoResp.go new file mode 100644 index 0000000..b1e18e4 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_CmdOptionInfoResp.go @@ -0,0 +1,90 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_CmdOptionInfoRespT struct { + Bfbs string + Description string +} + +func (t *Misc_CmdOptionInfoRespT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + bfbsOffset := builder.CreateString(t.Bfbs) + descriptionOffset := builder.CreateString(t.Description) + Misc_CmdOptionInfoRespStart(builder) + Misc_CmdOptionInfoRespAddBfbs(builder, bfbsOffset) + Misc_CmdOptionInfoRespAddDescription(builder, descriptionOffset) + return Misc_CmdOptionInfoRespEnd(builder) +} + +func (rcv *Misc_CmdOptionInfoResp) UnPackTo(t *Misc_CmdOptionInfoRespT) { + t.Bfbs = string(rcv.Bfbs()) + t.Description = string(rcv.Description()) +} + +func (rcv *Misc_CmdOptionInfoResp) UnPack() *Misc_CmdOptionInfoRespT { + if rcv == nil { return nil } + t := &Misc_CmdOptionInfoRespT{} + rcv.UnPackTo(t) + return t +} + +type Misc_CmdOptionInfoResp struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_CmdOptionInfoResp(buf []byte, offset flatbuffers.UOffsetT) *Misc_CmdOptionInfoResp { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_CmdOptionInfoResp{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_CmdOptionInfoResp(buf []byte, offset flatbuffers.UOffsetT) *Misc_CmdOptionInfoResp { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_CmdOptionInfoResp{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_CmdOptionInfoResp) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_CmdOptionInfoResp) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_CmdOptionInfoResp) Bfbs() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Misc_CmdOptionInfoResp) Description() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func Misc_CmdOptionInfoRespStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Misc_CmdOptionInfoRespAddBfbs(builder *flatbuffers.Builder, bfbs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(bfbs), 0) +} +func Misc_CmdOptionInfoRespAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(description), 0) +} +func Misc_CmdOptionInfoRespEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Misc_ListRegisteredCmdsOptions.go b/pkg/fbs/script/manager/fbtypes/Misc_ListRegisteredCmdsOptions.go new file mode 100644 index 0000000..e564ed2 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_ListRegisteredCmdsOptions.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_ListRegisteredCmdsOptionsT struct { + ObjType ObjectTypeListRegisteredCmdsOptions + CmdType CmdTypeListRegisteredCmdsOptions +} + +func (t *Misc_ListRegisteredCmdsOptionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Misc_ListRegisteredCmdsOptionsStart(builder) + Misc_ListRegisteredCmdsOptionsAddObjType(builder, t.ObjType) + Misc_ListRegisteredCmdsOptionsAddCmdType(builder, t.CmdType) + return Misc_ListRegisteredCmdsOptionsEnd(builder) +} + +func (rcv *Misc_ListRegisteredCmdsOptions) UnPackTo(t *Misc_ListRegisteredCmdsOptionsT) { + t.ObjType = rcv.ObjType() + t.CmdType = rcv.CmdType() +} + +func (rcv *Misc_ListRegisteredCmdsOptions) UnPack() *Misc_ListRegisteredCmdsOptionsT { + if rcv == nil { return nil } + t := &Misc_ListRegisteredCmdsOptionsT{} + rcv.UnPackTo(t) + return t +} + +type Misc_ListRegisteredCmdsOptions struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_ListRegisteredCmdsOptions(buf []byte, offset flatbuffers.UOffsetT) *Misc_ListRegisteredCmdsOptions { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_ListRegisteredCmdsOptions{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_ListRegisteredCmdsOptions(buf []byte, offset flatbuffers.UOffsetT) *Misc_ListRegisteredCmdsOptions { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_ListRegisteredCmdsOptions{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_ListRegisteredCmdsOptions) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_ListRegisteredCmdsOptions) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_ListRegisteredCmdsOptions) ObjType() ObjectTypeListRegisteredCmdsOptions { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return ObjectTypeListRegisteredCmdsOptions(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Misc_ListRegisteredCmdsOptions) MutateObjType(n ObjectTypeListRegisteredCmdsOptions) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func (rcv *Misc_ListRegisteredCmdsOptions) CmdType() CmdTypeListRegisteredCmdsOptions { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return CmdTypeListRegisteredCmdsOptions(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Misc_ListRegisteredCmdsOptions) MutateCmdType(n CmdTypeListRegisteredCmdsOptions) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func Misc_ListRegisteredCmdsOptionsStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Misc_ListRegisteredCmdsOptionsAddObjType(builder *flatbuffers.Builder, objType ObjectTypeListRegisteredCmdsOptions) { + builder.PrependInt8Slot(0, int8(objType), 0) +} +func Misc_ListRegisteredCmdsOptionsAddCmdType(builder *flatbuffers.Builder, cmdType CmdTypeListRegisteredCmdsOptions) { + builder.PrependInt8Slot(1, int8(cmdType), 0) +} +func Misc_ListRegisteredCmdsOptionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Misc_SetErrLevel.go b/pkg/fbs/script/manager/fbtypes/Misc_SetErrLevel.go new file mode 100644 index 0000000..08995f7 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_SetErrLevel.go @@ -0,0 +1,95 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_SetErrLevelT struct { + Base *Cmd_BaseT + ErrLvl string +} + +func (t *Misc_SetErrLevelT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + errLvlOffset := builder.CreateString(t.ErrLvl) + Misc_SetErrLevelStart(builder) + Misc_SetErrLevelAddBase(builder, baseOffset) + Misc_SetErrLevelAddErrLvl(builder, errLvlOffset) + return Misc_SetErrLevelEnd(builder) +} + +func (rcv *Misc_SetErrLevel) UnPackTo(t *Misc_SetErrLevelT) { + t.Base = rcv.Base(nil).UnPack() + t.ErrLvl = string(rcv.ErrLvl()) +} + +func (rcv *Misc_SetErrLevel) UnPack() *Misc_SetErrLevelT { + if rcv == nil { return nil } + t := &Misc_SetErrLevelT{} + rcv.UnPackTo(t) + return t +} + +type Misc_SetErrLevel struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_SetErrLevel(buf []byte, offset flatbuffers.UOffsetT) *Misc_SetErrLevel { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_SetErrLevel{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_SetErrLevel(buf []byte, offset flatbuffers.UOffsetT) *Misc_SetErrLevel { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_SetErrLevel{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_SetErrLevel) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_SetErrLevel) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_SetErrLevel) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Misc_SetErrLevel) ErrLvl() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func Misc_SetErrLevelStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Misc_SetErrLevelAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Misc_SetErrLevelAddErrLvl(builder *flatbuffers.Builder, errLvl flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(errLvl), 0) +} +func Misc_SetErrLevelEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Misc_SetOverride.go b/pkg/fbs/script/manager/fbtypes/Misc_SetOverride.go new file mode 100644 index 0000000..6d4da09 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Misc_SetOverride.go @@ -0,0 +1,98 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Misc_SetOverrideT struct { + Base *Cmd_BaseT + Value float64 +} + +func (t *Misc_SetOverrideT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + Misc_SetOverrideStart(builder) + Misc_SetOverrideAddBase(builder, baseOffset) + Misc_SetOverrideAddValue(builder, t.Value) + return Misc_SetOverrideEnd(builder) +} + +func (rcv *Misc_SetOverride) UnPackTo(t *Misc_SetOverrideT) { + t.Base = rcv.Base(nil).UnPack() + t.Value = rcv.Value() +} + +func (rcv *Misc_SetOverride) UnPack() *Misc_SetOverrideT { + if rcv == nil { return nil } + t := &Misc_SetOverrideT{} + rcv.UnPackTo(t) + return t +} + +type Misc_SetOverride struct { + _tab flatbuffers.Table +} + +func GetRootAsMisc_SetOverride(buf []byte, offset flatbuffers.UOffsetT) *Misc_SetOverride { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Misc_SetOverride{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMisc_SetOverride(buf []byte, offset flatbuffers.UOffsetT) *Misc_SetOverride { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Misc_SetOverride{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Misc_SetOverride) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Misc_SetOverride) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Misc_SetOverride) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Misc_SetOverride) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Misc_SetOverride) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func Misc_SetOverrideStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Misc_SetOverrideAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Misc_SetOverrideAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(1, value, 0.0) +} +func Misc_SetOverrideEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/ObjectType_CmdOptionInfoReq.go b/pkg/fbs/script/manager/fbtypes/ObjectType_CmdOptionInfoReq.go new file mode 100644 index 0000000..c81db0a --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/ObjectType_CmdOptionInfoReq.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type ObjectTypeCmdOptionInfoReq int8 + +const ( + ObjectType_CmdOptionInfoReqUNKNOWN ObjectTypeCmdOptionInfoReq = 0 + ObjectType_CmdOptionInfoReqAXS ObjectTypeCmdOptionInfoReq = 1 + ObjectType_CmdOptionInfoReqKIN ObjectTypeCmdOptionInfoReq = 2 +) + +var EnumNamesObjectType_CmdOptionInfoReq = map[ObjectTypeCmdOptionInfoReq]string{ + ObjectType_CmdOptionInfoReqUNKNOWN: "UNKNOWN", + ObjectType_CmdOptionInfoReqAXS: "AXS", + ObjectType_CmdOptionInfoReqKIN: "KIN", +} + +var EnumValuesObjectType_CmdOptionInfoReq = map[string]ObjectTypeCmdOptionInfoReq{ + "UNKNOWN": ObjectType_CmdOptionInfoReqUNKNOWN, + "AXS": ObjectType_CmdOptionInfoReqAXS, + "KIN": ObjectType_CmdOptionInfoReqKIN, +} + +func (v ObjectTypeCmdOptionInfoReq) String() string { + if s, ok := EnumNamesObjectType_CmdOptionInfoReq[v]; ok { + return s + } + return "ObjectType_CmdOptionInfoReq(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/ObjectType_GenCmdOption.go b/pkg/fbs/script/manager/fbtypes/ObjectType_GenCmdOption.go new file mode 100644 index 0000000..0e00463 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/ObjectType_GenCmdOption.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type ObjectTypeGenCmdOption int8 + +const ( + ObjectType_GenCmdOptionUNKNOWN ObjectTypeGenCmdOption = 0 + ObjectType_GenCmdOptionAXS ObjectTypeGenCmdOption = 1 + ObjectType_GenCmdOptionKIN ObjectTypeGenCmdOption = 2 +) + +var EnumNamesObjectType_GenCmdOption = map[ObjectTypeGenCmdOption]string{ + ObjectType_GenCmdOptionUNKNOWN: "UNKNOWN", + ObjectType_GenCmdOptionAXS: "AXS", + ObjectType_GenCmdOptionKIN: "KIN", +} + +var EnumValuesObjectType_GenCmdOption = map[string]ObjectTypeGenCmdOption{ + "UNKNOWN": ObjectType_GenCmdOptionUNKNOWN, + "AXS": ObjectType_GenCmdOptionAXS, + "KIN": ObjectType_GenCmdOptionKIN, +} + +func (v ObjectTypeGenCmdOption) String() string { + if s, ok := EnumNamesObjectType_GenCmdOption[v]; ok { + return s + } + return "ObjectTypeGenCmdOption(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/ObjectType_ListRegisteredCmdsOptions.go b/pkg/fbs/script/manager/fbtypes/ObjectType_ListRegisteredCmdsOptions.go new file mode 100644 index 0000000..64bc68f --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/ObjectType_ListRegisteredCmdsOptions.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type ObjectTypeListRegisteredCmdsOptions int8 + +const ( + ObjectType_ListRegisteredCmdsOptionsUNKNOWN ObjectTypeListRegisteredCmdsOptions = 0 + ObjectType_ListRegisteredCmdsOptionsAXS ObjectTypeListRegisteredCmdsOptions = 1 + ObjectType_ListRegisteredCmdsOptionsKIN ObjectTypeListRegisteredCmdsOptions = 2 +) + +var EnumNamesObjectType_ListRegisteredCmdsOptions = map[ObjectTypeListRegisteredCmdsOptions]string{ + ObjectType_ListRegisteredCmdsOptionsUNKNOWN: "UNKNOWN", + ObjectType_ListRegisteredCmdsOptionsAXS: "AXS", + ObjectType_ListRegisteredCmdsOptionsKIN: "KIN", +} + +var EnumValuesObjectType_ListRegisteredCmdsOptions = map[string]ObjectTypeListRegisteredCmdsOptions{ + "UNKNOWN": ObjectType_ListRegisteredCmdsOptionsUNKNOWN, + "AXS": ObjectType_ListRegisteredCmdsOptionsAXS, + "KIN": ObjectType_ListRegisteredCmdsOptionsKIN, +} + +func (v ObjectTypeListRegisteredCmdsOptions) String() string { + if s, ok := EnumNamesObjectType_ListRegisteredCmdsOptions[v]; ok { + return s + } + return "ObjectTypeListRegisteredCmdsOptions(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/Resp_Error.go b/pkg/fbs/script/manager/fbtypes/Resp_Error.go index 6a825ee..5372bcc 100644 --- a/pkg/fbs/script/manager/fbtypes/Resp_Error.go +++ b/pkg/fbs/script/manager/fbtypes/Resp_Error.go @@ -6,6 +6,55 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Resp_ErrorT struct { + MainCode uint32 + DetailCode uint32 + Text string + Trace []string +} + +func (t *Resp_ErrorT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + textOffset := builder.CreateString(t.Text) + traceOffset := flatbuffers.UOffsetT(0) + if t.Trace != nil { + traceLength := len(t.Trace) + traceOffsets := make([]flatbuffers.UOffsetT, traceLength) + for j := 0; j < traceLength; j++ { + traceOffsets[j] = builder.CreateString(t.Trace[j]) + } + Resp_ErrorStartTraceVector(builder, traceLength) + for j := traceLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(traceOffsets[j]) + } + traceOffset = builder.EndVector(traceLength) + } + Resp_ErrorStart(builder) + Resp_ErrorAddMainCode(builder, t.MainCode) + Resp_ErrorAddDetailCode(builder, t.DetailCode) + Resp_ErrorAddText(builder, textOffset) + Resp_ErrorAddTrace(builder, traceOffset) + return Resp_ErrorEnd(builder) +} + +func (rcv *Resp_Error) UnPackTo(t *Resp_ErrorT) { + t.MainCode = rcv.MainCode() + t.DetailCode = rcv.DetailCode() + t.Text = string(rcv.Text()) + traceLength := rcv.TraceLength() + t.Trace = make([]string, traceLength) + for j := 0; j < traceLength; j++ { + t.Trace[j] = string(rcv.Trace(j)) + } +} + +func (rcv *Resp_Error) UnPack() *Resp_ErrorT { + if rcv == nil { return nil } + t := &Resp_ErrorT{} + rcv.UnPackTo(t) + return t +} + type Resp_Error struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/ScriptDescription.go b/pkg/fbs/script/manager/fbtypes/ScriptDescription.go index a90a44f..37796df 100644 --- a/pkg/fbs/script/manager/fbtypes/ScriptDescription.go +++ b/pkg/fbs/script/manager/fbtypes/ScriptDescription.go @@ -6,6 +6,61 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type ScriptDescriptionT struct { + Language string + Version string + Executable string + FileEnding []string + License string +} + +func (t *ScriptDescriptionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + languageOffset := builder.CreateString(t.Language) + versionOffset := builder.CreateString(t.Version) + executableOffset := builder.CreateString(t.Executable) + fileEndingOffset := flatbuffers.UOffsetT(0) + if t.FileEnding != nil { + fileEndingLength := len(t.FileEnding) + fileEndingOffsets := make([]flatbuffers.UOffsetT, fileEndingLength) + for j := 0; j < fileEndingLength; j++ { + fileEndingOffsets[j] = builder.CreateString(t.FileEnding[j]) + } + ScriptDescriptionStartFileEndingVector(builder, fileEndingLength) + for j := fileEndingLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(fileEndingOffsets[j]) + } + fileEndingOffset = builder.EndVector(fileEndingLength) + } + licenseOffset := builder.CreateString(t.License) + ScriptDescriptionStart(builder) + ScriptDescriptionAddLanguage(builder, languageOffset) + ScriptDescriptionAddVersion(builder, versionOffset) + ScriptDescriptionAddExecutable(builder, executableOffset) + ScriptDescriptionAddFileEnding(builder, fileEndingOffset) + ScriptDescriptionAddLicense(builder, licenseOffset) + return ScriptDescriptionEnd(builder) +} + +func (rcv *ScriptDescription) UnPackTo(t *ScriptDescriptionT) { + t.Language = string(rcv.Language()) + t.Version = string(rcv.Version()) + t.Executable = string(rcv.Executable()) + fileEndingLength := rcv.FileEndingLength() + t.FileEnding = make([]string, fileEndingLength) + for j := 0; j < fileEndingLength; j++ { + t.FileEnding[j] = string(rcv.FileEnding(j)) + } + t.License = string(rcv.License()) +} + +func (rcv *ScriptDescription) UnPack() *ScriptDescriptionT { + if rcv == nil { return nil } + t := &ScriptDescriptionT{} + rcv.UnPackTo(t) + return t +} + type ScriptDescription struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/State_AxsActValues.go b/pkg/fbs/script/manager/fbtypes/State_AxsActValues.go new file mode 100644 index 0000000..9b4eeb6 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_AxsActValues.go @@ -0,0 +1,150 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_AxsActValuesT struct { + Pos float64 + DistLeft float64 + Vel float64 + Acc float64 + Torque float64 +} + +func (t *State_AxsActValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + State_AxsActValuesStart(builder) + State_AxsActValuesAddPos(builder, t.Pos) + State_AxsActValuesAddDistLeft(builder, t.DistLeft) + State_AxsActValuesAddVel(builder, t.Vel) + State_AxsActValuesAddAcc(builder, t.Acc) + State_AxsActValuesAddTorque(builder, t.Torque) + return State_AxsActValuesEnd(builder) +} + +func (rcv *State_AxsActValues) UnPackTo(t *State_AxsActValuesT) { + t.Pos = rcv.Pos() + t.DistLeft = rcv.DistLeft() + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Torque = rcv.Torque() +} + +func (rcv *State_AxsActValues) UnPack() *State_AxsActValuesT { + if rcv == nil { return nil } + t := &State_AxsActValuesT{} + rcv.UnPackTo(t) + return t +} + +type State_AxsActValues struct { + _tab flatbuffers.Table +} + +func GetRootAsState_AxsActValues(buf []byte, offset flatbuffers.UOffsetT) *State_AxsActValues { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_AxsActValues{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_AxsActValues(buf []byte, offset flatbuffers.UOffsetT) *State_AxsActValues { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_AxsActValues{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_AxsActValues) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_AxsActValues) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_AxsActValues) Pos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsActValues) MutatePos(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *State_AxsActValues) DistLeft() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsActValues) MutateDistLeft(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *State_AxsActValues) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsActValues) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *State_AxsActValues) Acc() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsActValues) MutateAcc(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func (rcv *State_AxsActValues) Torque() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsActValues) MutateTorque(n float64) bool { + return rcv._tab.MutateFloat64Slot(12, n) +} + +func State_AxsActValuesStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func State_AxsActValuesAddPos(builder *flatbuffers.Builder, pos float64) { + builder.PrependFloat64Slot(0, pos, 0.0) +} +func State_AxsActValuesAddDistLeft(builder *flatbuffers.Builder, distLeft float64) { + builder.PrependFloat64Slot(1, distLeft, 0.0) +} +func State_AxsActValuesAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(2, vel, 0.0) +} +func State_AxsActValuesAddAcc(builder *flatbuffers.Builder, acc float64) { + builder.PrependFloat64Slot(3, acc, 0.0) +} +func State_AxsActValuesAddTorque(builder *flatbuffers.Builder, torque float64) { + builder.PrependFloat64Slot(4, torque, 0.0) +} +func State_AxsActValuesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExReq.go b/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExReq.go new file mode 100644 index 0000000..135d39e --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExReq.go @@ -0,0 +1,123 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_AxsBrakingDistanceExReqT struct { + AxsName string + SelectedTypes []BrakingDistanceTypeReq +} + +func (t *State_AxsBrakingDistanceExReqT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + axsNameOffset := builder.CreateString(t.AxsName) + selectedTypesOffset := flatbuffers.UOffsetT(0) + if t.SelectedTypes != nil { + selectedTypesLength := len(t.SelectedTypes) + State_AxsBrakingDistanceExReqStartSelectedTypesVector(builder, selectedTypesLength) + for j := selectedTypesLength - 1; j >= 0; j-- { + builder.PrependInt8(int8(t.SelectedTypes[j])) + } + selectedTypesOffset = builder.EndVector(selectedTypesLength) + } + State_AxsBrakingDistanceExReqStart(builder) + State_AxsBrakingDistanceExReqAddAxsName(builder, axsNameOffset) + State_AxsBrakingDistanceExReqAddSelectedTypes(builder, selectedTypesOffset) + return State_AxsBrakingDistanceExReqEnd(builder) +} + +func (rcv *State_AxsBrakingDistanceExReq) UnPackTo(t *State_AxsBrakingDistanceExReqT) { + t.AxsName = string(rcv.AxsName()) + selectedTypesLength := rcv.SelectedTypesLength() + t.SelectedTypes = make([]BrakingDistanceTypeReq, selectedTypesLength) + for j := 0; j < selectedTypesLength; j++ { + t.SelectedTypes[j] = rcv.SelectedTypes(j) + } +} + +func (rcv *State_AxsBrakingDistanceExReq) UnPack() *State_AxsBrakingDistanceExReqT { + if rcv == nil { return nil } + t := &State_AxsBrakingDistanceExReqT{} + rcv.UnPackTo(t) + return t +} + +type State_AxsBrakingDistanceExReq struct { + _tab flatbuffers.Table +} + +func GetRootAsState_AxsBrakingDistanceExReq(buf []byte, offset flatbuffers.UOffsetT) *State_AxsBrakingDistanceExReq { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_AxsBrakingDistanceExReq{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_AxsBrakingDistanceExReq(buf []byte, offset flatbuffers.UOffsetT) *State_AxsBrakingDistanceExReq { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_AxsBrakingDistanceExReq{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_AxsBrakingDistanceExReq) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_AxsBrakingDistanceExReq) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_AxsBrakingDistanceExReq) AxsName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *State_AxsBrakingDistanceExReq) SelectedTypes(j int) BrakingDistanceTypeReq { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return BrakingDistanceTypeReq(rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))) + } + return 0 +} + +func (rcv *State_AxsBrakingDistanceExReq) SelectedTypesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *State_AxsBrakingDistanceExReq) MutateSelectedTypes(j int, n BrakingDistanceTypeReq) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), int8(n)) + } + return false +} + +func State_AxsBrakingDistanceExReqStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func State_AxsBrakingDistanceExReqAddAxsName(builder *flatbuffers.Builder, axsName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(axsName), 0) +} +func State_AxsBrakingDistanceExReqAddSelectedTypes(builder *flatbuffers.Builder, selectedTypes flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(selectedTypes), 0) +} +func State_AxsBrakingDistanceExReqStartSelectedTypesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func State_AxsBrakingDistanceExReqEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExResp.go b/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExResp.go new file mode 100644 index 0000000..621929a --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_AxsBrakingDistanceExResp.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_AxsBrakingDistanceExRespT struct { + BrakingDistance float64 + DistanceType BrakingDistanceTypeResp +} + +func (t *State_AxsBrakingDistanceExRespT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + State_AxsBrakingDistanceExRespStart(builder) + State_AxsBrakingDistanceExRespAddBrakingDistance(builder, t.BrakingDistance) + State_AxsBrakingDistanceExRespAddDistanceType(builder, t.DistanceType) + return State_AxsBrakingDistanceExRespEnd(builder) +} + +func (rcv *State_AxsBrakingDistanceExResp) UnPackTo(t *State_AxsBrakingDistanceExRespT) { + t.BrakingDistance = rcv.BrakingDistance() + t.DistanceType = rcv.DistanceType() +} + +func (rcv *State_AxsBrakingDistanceExResp) UnPack() *State_AxsBrakingDistanceExRespT { + if rcv == nil { return nil } + t := &State_AxsBrakingDistanceExRespT{} + rcv.UnPackTo(t) + return t +} + +type State_AxsBrakingDistanceExResp struct { + _tab flatbuffers.Table +} + +func GetRootAsState_AxsBrakingDistanceExResp(buf []byte, offset flatbuffers.UOffsetT) *State_AxsBrakingDistanceExResp { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_AxsBrakingDistanceExResp{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_AxsBrakingDistanceExResp(buf []byte, offset flatbuffers.UOffsetT) *State_AxsBrakingDistanceExResp { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_AxsBrakingDistanceExResp{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_AxsBrakingDistanceExResp) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_AxsBrakingDistanceExResp) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_AxsBrakingDistanceExResp) BrakingDistance() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsBrakingDistanceExResp) MutateBrakingDistance(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *State_AxsBrakingDistanceExResp) DistanceType() BrakingDistanceTypeResp { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return BrakingDistanceTypeResp(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *State_AxsBrakingDistanceExResp) MutateDistanceType(n BrakingDistanceTypeResp) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func State_AxsBrakingDistanceExRespStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func State_AxsBrakingDistanceExRespAddBrakingDistance(builder *flatbuffers.Builder, brakingDistance float64) { + builder.PrependFloat64Slot(0, brakingDistance, 0.0) +} +func State_AxsBrakingDistanceExRespAddDistanceType(builder *flatbuffers.Builder, distanceType BrakingDistanceTypeResp) { + builder.PrependInt8Slot(1, int8(distanceType), 0) +} +func State_AxsBrakingDistanceExRespEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_AxsIpoValues.go b/pkg/fbs/script/manager/fbtypes/State_AxsIpoValues.go new file mode 100644 index 0000000..46ec476 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_AxsIpoValues.go @@ -0,0 +1,132 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_AxsIpoValuesT struct { + Pos float64 + Vel float64 + Acc float64 + Jrk float64 +} + +func (t *State_AxsIpoValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + State_AxsIpoValuesStart(builder) + State_AxsIpoValuesAddPos(builder, t.Pos) + State_AxsIpoValuesAddVel(builder, t.Vel) + State_AxsIpoValuesAddAcc(builder, t.Acc) + State_AxsIpoValuesAddJrk(builder, t.Jrk) + return State_AxsIpoValuesEnd(builder) +} + +func (rcv *State_AxsIpoValues) UnPackTo(t *State_AxsIpoValuesT) { + t.Pos = rcv.Pos() + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Jrk = rcv.Jrk() +} + +func (rcv *State_AxsIpoValues) UnPack() *State_AxsIpoValuesT { + if rcv == nil { return nil } + t := &State_AxsIpoValuesT{} + rcv.UnPackTo(t) + return t +} + +type State_AxsIpoValues struct { + _tab flatbuffers.Table +} + +func GetRootAsState_AxsIpoValues(buf []byte, offset flatbuffers.UOffsetT) *State_AxsIpoValues { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_AxsIpoValues{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_AxsIpoValues(buf []byte, offset flatbuffers.UOffsetT) *State_AxsIpoValues { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_AxsIpoValues{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_AxsIpoValues) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_AxsIpoValues) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_AxsIpoValues) Pos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsIpoValues) MutatePos(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *State_AxsIpoValues) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsIpoValues) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *State_AxsIpoValues) Acc() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsIpoValues) MutateAcc(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *State_AxsIpoValues) Jrk() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_AxsIpoValues) MutateJrk(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func State_AxsIpoValuesStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func State_AxsIpoValuesAddPos(builder *flatbuffers.Builder, pos float64) { + builder.PrependFloat64Slot(0, pos, 0.0) +} +func State_AxsIpoValuesAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(1, vel, 0.0) +} +func State_AxsIpoValuesAddAcc(builder *flatbuffers.Builder, acc float64) { + builder.PrependFloat64Slot(2, acc, 0.0) +} +func State_AxsIpoValuesAddJrk(builder *flatbuffers.Builder, jrk float64) { + builder.PrependFloat64Slot(3, jrk, 0.0) +} +func State_AxsIpoValuesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_CmdState.go b/pkg/fbs/script/manager/fbtypes/State_CmdState.go new file mode 100644 index 0000000..bb901fc --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_CmdState.go @@ -0,0 +1,93 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_CmdStateT struct { + ObjName string + CmdID uint64 +} + +func (t *State_CmdStateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objNameOffset := builder.CreateString(t.ObjName) + State_CmdStateStart(builder) + State_CmdStateAddObjName(builder, objNameOffset) + State_CmdStateAddCmdID(builder, t.CmdID) + return State_CmdStateEnd(builder) +} + +func (rcv *State_CmdState) UnPackTo(t *State_CmdStateT) { + t.ObjName = string(rcv.ObjName()) + t.CmdID = rcv.CmdID() +} + +func (rcv *State_CmdState) UnPack() *State_CmdStateT { + if rcv == nil { return nil } + t := &State_CmdStateT{} + rcv.UnPackTo(t) + return t +} + +type State_CmdState struct { + _tab flatbuffers.Table +} + +func GetRootAsState_CmdState(buf []byte, offset flatbuffers.UOffsetT) *State_CmdState { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_CmdState{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_CmdState(buf []byte, offset flatbuffers.UOffsetT) *State_CmdState { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_CmdState{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_CmdState) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_CmdState) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_CmdState) ObjName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *State_CmdState) CmdID() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *State_CmdState) MutateCmdID(n uint64) bool { + return rcv._tab.MutateUint64Slot(6, n) +} + +func State_CmdStateStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func State_CmdStateAddObjName(builder *flatbuffers.Builder, objName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objName), 0) +} +func State_CmdStateAddCmdID(builder *flatbuffers.Builder, cmdID uint64) { + builder.PrependUint64Slot(1, cmdID, 0) +} +func State_CmdStateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_KinCoordTransform.go b/pkg/fbs/script/manager/fbtypes/State_KinCoordTransform.go new file mode 100644 index 0000000..4d652ec --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_KinCoordTransform.go @@ -0,0 +1,153 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_KinCoordTransformT struct { + ObjName string + PosIn []float64 + CoordSysIn string + CoordSysOut string +} + +func (t *State_KinCoordTransformT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objNameOffset := builder.CreateString(t.ObjName) + posInOffset := flatbuffers.UOffsetT(0) + if t.PosIn != nil { + posInLength := len(t.PosIn) + State_KinCoordTransformStartPosInVector(builder, posInLength) + for j := posInLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.PosIn[j]) + } + posInOffset = builder.EndVector(posInLength) + } + coordSysInOffset := builder.CreateString(t.CoordSysIn) + coordSysOutOffset := builder.CreateString(t.CoordSysOut) + State_KinCoordTransformStart(builder) + State_KinCoordTransformAddObjName(builder, objNameOffset) + State_KinCoordTransformAddPosIn(builder, posInOffset) + State_KinCoordTransformAddCoordSysIn(builder, coordSysInOffset) + State_KinCoordTransformAddCoordSysOut(builder, coordSysOutOffset) + return State_KinCoordTransformEnd(builder) +} + +func (rcv *State_KinCoordTransform) UnPackTo(t *State_KinCoordTransformT) { + t.ObjName = string(rcv.ObjName()) + posInLength := rcv.PosInLength() + t.PosIn = make([]float64, posInLength) + for j := 0; j < posInLength; j++ { + t.PosIn[j] = rcv.PosIn(j) + } + t.CoordSysIn = string(rcv.CoordSysIn()) + t.CoordSysOut = string(rcv.CoordSysOut()) +} + +func (rcv *State_KinCoordTransform) UnPack() *State_KinCoordTransformT { + if rcv == nil { return nil } + t := &State_KinCoordTransformT{} + rcv.UnPackTo(t) + return t +} + +type State_KinCoordTransform struct { + _tab flatbuffers.Table +} + +func GetRootAsState_KinCoordTransform(buf []byte, offset flatbuffers.UOffsetT) *State_KinCoordTransform { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_KinCoordTransform{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_KinCoordTransform(buf []byte, offset flatbuffers.UOffsetT) *State_KinCoordTransform { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_KinCoordTransform{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_KinCoordTransform) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_KinCoordTransform) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_KinCoordTransform) ObjName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *State_KinCoordTransform) PosIn(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *State_KinCoordTransform) PosInLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *State_KinCoordTransform) MutatePosIn(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *State_KinCoordTransform) CoordSysIn() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *State_KinCoordTransform) CoordSysOut() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func State_KinCoordTransformStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func State_KinCoordTransformAddObjName(builder *flatbuffers.Builder, objName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objName), 0) +} +func State_KinCoordTransformAddPosIn(builder *flatbuffers.Builder, posIn flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(posIn), 0) +} +func State_KinCoordTransformStartPosInVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func State_KinCoordTransformAddCoordSysIn(builder *flatbuffers.Builder, coordSysIn flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(coordSysIn), 0) +} +func State_KinCoordTransformAddCoordSysOut(builder *flatbuffers.Builder, coordSysOut flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(coordSysOut), 0) +} +func State_KinCoordTransformEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_KinGetPos.go b/pkg/fbs/script/manager/fbtypes/State_KinGetPos.go new file mode 100644 index 0000000..1744dcb --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_KinGetPos.go @@ -0,0 +1,90 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_KinGetPosT struct { + ObjName string + CoordSysOut string +} + +func (t *State_KinGetPosT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + objNameOffset := builder.CreateString(t.ObjName) + coordSysOutOffset := builder.CreateString(t.CoordSysOut) + State_KinGetPosStart(builder) + State_KinGetPosAddObjName(builder, objNameOffset) + State_KinGetPosAddCoordSysOut(builder, coordSysOutOffset) + return State_KinGetPosEnd(builder) +} + +func (rcv *State_KinGetPos) UnPackTo(t *State_KinGetPosT) { + t.ObjName = string(rcv.ObjName()) + t.CoordSysOut = string(rcv.CoordSysOut()) +} + +func (rcv *State_KinGetPos) UnPack() *State_KinGetPosT { + if rcv == nil { return nil } + t := &State_KinGetPosT{} + rcv.UnPackTo(t) + return t +} + +type State_KinGetPos struct { + _tab flatbuffers.Table +} + +func GetRootAsState_KinGetPos(buf []byte, offset flatbuffers.UOffsetT) *State_KinGetPos { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_KinGetPos{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_KinGetPos(buf []byte, offset flatbuffers.UOffsetT) *State_KinGetPos { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_KinGetPos{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_KinGetPos) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_KinGetPos) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_KinGetPos) ObjName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *State_KinGetPos) CoordSysOut() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func State_KinGetPosStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func State_KinGetPosAddObjName(builder *flatbuffers.Builder, objName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objName), 0) +} +func State_KinGetPosAddCoordSysOut(builder *flatbuffers.Builder, coordSysOut flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(coordSysOut), 0) +} +func State_KinGetPosEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/State_KinIpoValues.go b/pkg/fbs/script/manager/fbtypes/State_KinIpoValues.go new file mode 100644 index 0000000..2b7b6e2 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/State_KinIpoValues.go @@ -0,0 +1,162 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type State_KinIpoValuesT struct { + Pos []float64 + Vel float64 + Acc float64 + Jrk float64 +} + +func (t *State_KinIpoValuesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + posOffset := flatbuffers.UOffsetT(0) + if t.Pos != nil { + posLength := len(t.Pos) + State_KinIpoValuesStartPosVector(builder, posLength) + for j := posLength - 1; j >= 0; j-- { + builder.PrependFloat64(t.Pos[j]) + } + posOffset = builder.EndVector(posLength) + } + State_KinIpoValuesStart(builder) + State_KinIpoValuesAddPos(builder, posOffset) + State_KinIpoValuesAddVel(builder, t.Vel) + State_KinIpoValuesAddAcc(builder, t.Acc) + State_KinIpoValuesAddJrk(builder, t.Jrk) + return State_KinIpoValuesEnd(builder) +} + +func (rcv *State_KinIpoValues) UnPackTo(t *State_KinIpoValuesT) { + posLength := rcv.PosLength() + t.Pos = make([]float64, posLength) + for j := 0; j < posLength; j++ { + t.Pos[j] = rcv.Pos(j) + } + t.Vel = rcv.Vel() + t.Acc = rcv.Acc() + t.Jrk = rcv.Jrk() +} + +func (rcv *State_KinIpoValues) UnPack() *State_KinIpoValuesT { + if rcv == nil { return nil } + t := &State_KinIpoValuesT{} + rcv.UnPackTo(t) + return t +} + +type State_KinIpoValues struct { + _tab flatbuffers.Table +} + +func GetRootAsState_KinIpoValues(buf []byte, offset flatbuffers.UOffsetT) *State_KinIpoValues { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &State_KinIpoValues{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsState_KinIpoValues(buf []byte, offset flatbuffers.UOffsetT) *State_KinIpoValues { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &State_KinIpoValues{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *State_KinIpoValues) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *State_KinIpoValues) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *State_KinIpoValues) Pos(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *State_KinIpoValues) PosLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *State_KinIpoValues) MutatePos(j int, n float64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateFloat64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *State_KinIpoValues) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_KinIpoValues) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *State_KinIpoValues) Acc() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_KinIpoValues) MutateAcc(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *State_KinIpoValues) Jrk() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *State_KinIpoValues) MutateJrk(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func State_KinIpoValuesStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func State_KinIpoValuesAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pos), 0) +} +func State_KinIpoValuesStartPosVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func State_KinIpoValuesAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(1, vel, 0.0) +} +func State_KinIpoValuesAddAcc(builder *flatbuffers.Builder, acc float64) { + builder.PrependFloat64Slot(2, acc, 0.0) +} +func State_KinIpoValuesAddJrk(builder *flatbuffers.Builder, jrk float64) { + builder.PrependFloat64Slot(3, jrk, 0.0) +} +func State_KinIpoValuesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Task_RunScript.go b/pkg/fbs/script/manager/fbtypes/Task_RunScript.go index 6933315..adc4a7d 100644 --- a/pkg/fbs/script/manager/fbtypes/Task_RunScript.go +++ b/pkg/fbs/script/manager/fbtypes/Task_RunScript.go @@ -6,6 +6,49 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type Task_RunScriptT struct { + Name string + Param []string +} + +func (t *Task_RunScriptT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + paramOffset := flatbuffers.UOffsetT(0) + if t.Param != nil { + paramLength := len(t.Param) + paramOffsets := make([]flatbuffers.UOffsetT, paramLength) + for j := 0; j < paramLength; j++ { + paramOffsets[j] = builder.CreateString(t.Param[j]) + } + Task_RunScriptStartParamVector(builder, paramLength) + for j := paramLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(paramOffsets[j]) + } + paramOffset = builder.EndVector(paramLength) + } + Task_RunScriptStart(builder) + Task_RunScriptAddName(builder, nameOffset) + Task_RunScriptAddParam(builder, paramOffset) + return Task_RunScriptEnd(builder) +} + +func (rcv *Task_RunScript) UnPackTo(t *Task_RunScriptT) { + t.Name = string(rcv.Name()) + paramLength := rcv.ParamLength() + t.Param = make([]string, paramLength) + for j := 0; j < paramLength; j++ { + t.Param[j] = string(rcv.Param(j)) + } +} + +func (rcv *Task_RunScript) UnPack() *Task_RunScriptT { + if rcv == nil { return nil } + t := &Task_RunScriptT{} + rcv.UnPackTo(t) + return t +} + type Task_RunScript struct { _tab flatbuffers.Table } diff --git a/pkg/fbs/script/manager/fbtypes/script_Instance.go b/pkg/fbs/script/manager/fbtypes/script_Instance.go index b3eab94..be07716 100644 --- a/pkg/fbs/script/manager/fbtypes/script_Instance.go +++ b/pkg/fbs/script/manager/fbtypes/script_Instance.go @@ -6,6 +6,33 @@ import ( flatbuffers "github.com/google/flatbuffers/go" ) +type script_InstanceT struct { + Name string + Language string +} + +func (t *script_InstanceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := builder.CreateString(t.Name) + languageOffset := builder.CreateString(t.Language) + script_InstanceStart(builder) + script_InstanceAddName(builder, nameOffset) + script_InstanceAddLanguage(builder, languageOffset) + return script_InstanceEnd(builder) +} + +func (rcv *script_Instance) UnPackTo(t *script_InstanceT) { + t.Name = string(rcv.Name()) + t.Language = string(rcv.Language()) +} + +func (rcv *script_Instance) UnPack() *script_InstanceT { + if rcv == nil { return nil } + t := &script_InstanceT{} + rcv.UnPackTo(t) + return t +} + type script_Instance struct { _tab flatbuffers.Table } From d0e916efc213b7583272590c3f3a19e2b2ed7f26 Mon Sep 17 00:00:00 2001 From: guidfort Date: Tue, 26 Jul 2022 11:44:54 +0000 Subject: [PATCH 3/5] update test sources --- test/datalayer/metadatabuilder_test.go | 111 +++++++++++++++++++++++++ test/datalayer/variant_test.go | 109 ++++++++++++++++++++++++ 2 files changed, 220 insertions(+) create mode 100644 test/datalayer/metadatabuilder_test.go diff --git a/test/datalayer/metadatabuilder_test.go b/test/datalayer/metadatabuilder_test.go new file mode 100644 index 0000000..353a8df --- /dev/null +++ b/test/datalayer/metadatabuilder_test.go @@ -0,0 +1,111 @@ +/** + * MIT License + * + * Copyright (c) 2021-2022 Bosch Rexroth AG + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package datalayer_test + +import ( + "fmt" + "testing" + + "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/datalayer" + fbs "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/fbs/comm/datalayer" + "github.com/stretchr/testify/assert" +) + +func TestMetadataBuilder(t *testing.T) { + v := datalayer.NewMetaDataBuilder(datalayer.AllowedOperationRead|datalayer.AllowedOperationBrowse, "test", "test_url").Build() + defer datalayer.DeleteVariant(v) + assert.NotNil(t, v) + + m := fbs.GetRootAsMetadata(v.GetFlatbuffers(), 0) + assert.NotNil(t, m) + assert.Equal(t, string(m.Description()), "test") + assert.Equal(t, string(m.DescriptionUrl()), "test_url") + op := m.Operations(nil) + assert.NotNil(t, op) + assert.True(t, op.Read()) + assert.True(t, op.Browse()) + assert.False(t, op.Write()) +} +func TestMetadataReferenceBuilder(t *testing.T) { + m := datalayer.NewMetaDataBuilder(datalayer.AllowedOperationRead|datalayer.AllowedOperationWrite|datalayer.AllowedOperationBrowse, "test", "test_url") + + m.AddReference(datalayer.ReferenceTypeWrite, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWrite]) + m.AddReference(datalayer.ReferenceTypeRead, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeRead]) + m.AddReference(datalayer.ReferenceTypeWriteOut, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWriteOut]) + m.AddReference(datalayer.ReferenceTypeReadIn, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeReadIn]) + m.AddReference(datalayer.ReferenceTypeCreate, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeCreate]) + m.AddReference(datalayer.ReferenceTypeWriteIn, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWriteIn]) + m.AddReference(datalayer.ReferenceTypeReadOut, "type_path_to_"+datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeReadOut]) + + v := m.Build() + defer datalayer.DeleteVariant(v) + assert.NotNil(t, v) + d := fbs.GetRootAsMetadata(v.GetFlatbuffers(), 0) + assert.NotNil(t, d) + + lst := []string{ + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeCreate], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeReadIn], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeReadOut], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeRead], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWriteIn], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWriteOut], + datalayer.EnumNamesReferenceType[datalayer.ReferenceTypeWrite], + } + assert.Equal(t, d.ReferencesLength(), len(lst)) + + for i, s := range lst { + r := &fbs.Reference{} + b := d.References(r, i) + assert.True(t, b) + assert.NotNil(t, r) + fmt.Println(i, s, string(r.Type()), string(r.TargetAddress())) + assert.Equal(t, string(r.Type()), s) + assert.Equal(t, string(r.TargetAddress()), "type_path_to_"+s) + } +} + +func TestMetadataExtensionsBuilder(t *testing.T) { + m := datalayer.NewMetaDataBuilder(datalayer.AllowedOperationRead|datalayer.AllowedOperationBrowse, "test", "test_url") + lst := []string{"1key", "2key", "3key", "4key"} + m.AddExtension(lst[2], "value_"+lst[2]) + m.AddExtension(lst[1], "value_"+lst[1]) + m.AddExtension(lst[3], "value_"+lst[3]) + m.AddExtension(lst[0], "value_"+lst[0]) + v := m.Build() + defer datalayer.DeleteVariant(v) + assert.NotNil(t, v) + d := fbs.GetRootAsMetadata(v.GetFlatbuffers(), 0) + assert.NotNil(t, d) + assert.Equal(t, d.ExtensionsLength(), len(lst)) + for i, s := range lst { + e := &fbs.Extension{} + b := d.Extensions(e, i) + assert.True(t, b) + assert.NotNil(t, e) + fmt.Println(i, s, string(e.Key()), string(e.Value())) + assert.Equal(t, string(e.Key()), s) + assert.Equal(t, string(e.Value()), "value_"+s) + } +} diff --git a/test/datalayer/variant_test.go b/test/datalayer/variant_test.go index 45ff425..1638d93 100644 --- a/test/datalayer/variant_test.go +++ b/test/datalayer/variant_test.go @@ -26,6 +26,8 @@ package datalayer_test import ( "runtime" "testing" + "time" + "unsafe" "github.com/boschrexroth/ctrlx-datalayer-golang/pkg/datalayer" a "github.com/stretchr/testify/assert" @@ -169,6 +171,49 @@ func TestString(t *testing.T) { a.Equal(t, datalayer.VariantTypeString, vtest.GetType()) } +// TestTimestamp ... +func TestTimestamp(t *testing.T) { + arr := []uint64{116444736000000000, 130496832000000000} + for _, value := range arr { + a.NotPanics(t, func() { vtest.SetTimestamp(value) }) + v := vtest.GetUint64() + a.Equal(t, value, v) + a.Equal(t, datalayer.VariantTypeTimestamp, vtest.GetType()) + } +} + +func TestTime(t *testing.T) { + m := map[uint64]time.Time{ + 116444736000000000: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), + 130496832000000000: time.Date(2014, 7, 13, 0, 0, 0, 0, time.UTC), + 87790176000000000: time.Date(1879, 3, 14, 0, 0, 0, 0, time.UTC), + 13256352000000000: time.Date(1643, 1, 4, 0, 0, 0, 0, time.UTC), + } + + for key, value := range m { + a.NotPanics(t, func() { vtest.SetTimestamp(key) }) + v := vtest.GetTime() + a.Equal(t, value, v) + a.Equal(t, datalayer.VariantTypeTimestamp, vtest.GetType()) + } +} + +func TestSetTime(t *testing.T) { + m := map[uint64]time.Time{ + 116444736000000000: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), + 130496832000000000: time.Date(2014, 7, 13, 0, 0, 0, 0, time.UTC), + } + + for key, value := range m { + a.NotPanics(t, func() { vtest.SetTime(value) }) + v := vtest.GetTime() + a.Equal(t, value, v) + a.Equal(t, datalayer.VariantTypeTimestamp, vtest.GetType()) + ft := vtest.GetUint64() + a.Equal(t, ft, key) + } +} + // TestArrayBool8 ... func TestArrayBool8(t *testing.T) { arr := []bool{true, false} @@ -334,3 +379,67 @@ func TestCopy(t *testing.T) { a.NotPanics(t, func() { vtest.Copy(val) }) a.Equal(t, datalayer.VariantTypeBool8, val.GetType()) } + +func TestSetArrayTimestamp(t *testing.T) { + arr := []uint64{116444736000000000, 130496832000000000} + a.NotPanics(t, func() { vtest.SetArrayTimestamp(arr) }) + a.Equal(t, datalayer.VariantTypeArrayTimestamp, vtest.GetType()) + vals := vtest.GetArrayUint64() + a.Equal(t, vals, arr) +} + +func TestGetArrayTime(t *testing.T) { + m := map[uint64]time.Time{ + 116444736000000000: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), + 130496832000000000: time.Date(2014, 7, 13, 0, 0, 0, 0, time.UTC), + } + + arr := []uint64{} + times := []time.Time{} + for key, value := range m { + arr = append(arr, key) + times = append(times, value) + } + + a.NotPanics(t, func() { vtest.SetArrayTimestamp(arr) }) + a.Equal(t, datalayer.VariantTypeArrayTimestamp, vtest.GetType()) + vals := vtest.GetArrayTime() + a.Equal(t, vals, times) +} + +func TestSetArrayTime(t *testing.T) { + m := map[uint64]time.Time{ + 116444736000000000: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), + 130496832000000000: time.Date(2014, 7, 13, 0, 0, 0, 0, time.UTC), + } + + arr := []uint64{} + times := []time.Time{} + for key, value := range m { + arr = append(arr, key) + times = append(times, value) + } + + a.NotPanics(t, func() { vtest.SetArrayTime(times) }) + a.Equal(t, datalayer.VariantTypeArrayTimestamp, vtest.GetType()) + vals := vtest.GetArrayTime() + a.Equal(t, vals, times) + va := vtest.GetArrayUint64() + a.Equal(t, va, arr) +} + +func TestNilVariant(t *testing.T) { + v := &datalayer.Variant{} + a.Equal(t, v.GetType(), datalayer.VariantTypeUnknown) + a.Equal(t, v.GetData(), unsafe.Pointer(nil)) + a.Equal(t, v.GetSize(), uint64(0)) + a.Equal(t, v.GetCount(), uint64(0)) + a.Equal(t, v.CheckConvert(datalayer.VariantTypeUnknown), datalayer.ResultNotInitialized) + + d := &datalayer.Variant{} + a.Equal(t, v.Copy(nil), datalayer.ResultNotInitialized) + a.Equal(t, v.Copy(d), datalayer.ResultNotInitialized) + d = datalayer.NewVariant() + a.Equal(t, v.Copy(d), datalayer.ResultNotInitialized) + a.NotPanics(t, func() { datalayer.DeleteVariant(v) }) +} From 3d1c2e50c52c643293a0361b5d4560f2d06ba01d Mon Sep 17 00:00:00 2001 From: guidfort Date: Thu, 28 Jul 2022 11:44:50 +0000 Subject: [PATCH 4/5] switch sdk version 1.16.0 --- Makefile | 2 +- README.md | 2 +- pkg/datalayer/converter.go | 12 ++++++------ 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Makefile b/Makefile index 54c7d5d..9cf3d51 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ GOOS := $(shell go env GOOS) GOARCH := $(shell go env GOARCH) BUILD := build/public/$(GOOS)_$(GOARCH) -DATALAYER_DEB_VERSION := 1.16.0-prerelease +DATALAYER_DEB_VERSION := 1.16.0 DATALAYER_DEB_FILE_VERSION := 1.8.6 .PHONY: all go-dep apt-dep lint vet test test-coverage build clean diff --git a/README.md b/README.md index 1224f1b..af8b952 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ sudo apt-get install libsystemd-dev libsystemd-dev:arm64 libzmq3-dev libzmq3-dev Check the current [ctrlx Data Layer](https://github.com/boschrexroth/ctrlx-automation-sdk/releases) debian package, download and install this, see example. ```bash -wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.16.0-prerelease/ctrlx-datalayer-1.8.6.deb +wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.16.0/ctrlx-datalayer-1.8.6.deb sudo dpkg -i ctrlx-datalayer-1.8.6.deb ``` diff --git a/pkg/datalayer/converter.go b/pkg/datalayer/converter.go index b55a16e..860df39 100755 --- a/pkg/datalayer/converter.go +++ b/pkg/datalayer/converter.go @@ -72,10 +72,10 @@ func (c *Converter) generateJSONComplex(data Variant, ty Variant, indentStep int } // GenerateJsonComplex generates a JSON string out of a Variant with a complex type (flatbuffers) and the metadata of this data. -// Parameter data is a Varaint that contains data of complex data type (flatbuffers). If data is empty (VariantType::UNKNOWN) type is converted to json schema. -// Parameter type is a Variant that contains type of data (Variant with flatbuffers BFBS) +// Parameter data is an array of bytes that contains data of complex data type (flatbuffers). If data is empty (VariantType::UNKNOWN) type is converted to json schema. +// Parameter type is an array of bytes that contains type of data (Variant with flatbuffers BFBS) // Parameter indentStep is a indentation length for json string. -// It returns generated JSON as a Variant (string). +// It returns generated JSON as a string. func (c *Converter) GenerateJsonComplex(data []byte, ty []byte, indentStep int) (Result, []byte) { d := NewVariant() defer DeleteVariant(d) @@ -92,7 +92,7 @@ func (c *Converter) GenerateJsonComplex(data []byte, ty []byte, indentStep int) } // ParseJsonSimple generates a Variant out of a JSON string containing the (simple) data. -// Parameter json is a data of the Variant as a json string. +// Parameter json is an array of bytes as a json string. // It returns a result status of the function, data string which contains the data, error Error object. func (c *Converter) ParseJsonSimple(json []byte) (Result, *Variant, error) { cjson := C.CString(string(json)) @@ -118,8 +118,8 @@ func (c *Converter) parseJSONComplex(json []byte, ty Variant) (Result, *Variant, } // ParseJsonComplex generates a Variant out of a JSON string containing the (complex) data. -// Parameter json is a data of the Variant as a json string. -// Parameter type (ty) is a Variant that contains type of data (Variant with bfbs flatbuffer content). +// Parameter json is an array of bytes containing a json string. +// Parameter type (ty) is an array of bytes that contains type of data (Variant with bfbs flatbuffer content). // It returns a result status of the function, data (array of byte) which contains the data, error Error as error object. func (c *Converter) ParseJsonComplex(json []byte, ty []byte) (Result, []byte, error) { t := NewVariant() From 958c4d296745c827b6d8f28ecfe23fdb586045b7 Mon Sep 17 00:00:00 2001 From: guidfort Date: Thu, 28 Jul 2022 12:43:34 +0000 Subject: [PATCH 5/5] fix github/workflows --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f369b63..9155abc 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -24,8 +24,8 @@ jobs: sudo apt-get update sudo apt-get install -y libsystemd-dev libzmq3-dev sudo apt install pkg-config - wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.12.1/ctrlx-datalayer-1.7.5.deb - sudo apt-get install -y -f ./ctrlx-datalayer-1.7.5.deb + wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/1.16.0/ctrlx-datalayer-1.8.6.deb + sudo apt-get install -y -f ./ctrlx-datalayer-1.8.6.deb - name: Go uses: actions/setup-go@v2