diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index abd65a0..274167e 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 sudo apt install pkg-config - wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/3.2.0/ctrlx-datalayer-2.7.5.deb - sudo apt-get install -y -f ./ctrlx-datalayer-2.7.5.deb + wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/3.4.0/ctrlx-datalayer-2.8.6.deb + sudo apt-get install -y -f ./ctrlx-datalayer-2.8.6.deb - name: Set up Go uses: actions/setup-go@v5 diff --git a/Makefile b/Makefile index 556ba8c..f46569c 100644 --- a/Makefile +++ b/Makefile @@ -8,8 +8,8 @@ GOOS := $(shell go env GOOS) GOARCH := $(shell go env GOARCH) BUILD := build/public/$(GOOS)_$(GOARCH) -SDK_RELEASE_VERSION := 3.2.0 -DATALAYER_DEB_FILE_VERSION := 2.7.5 +SDK_RELEASE_VERSION := 3.4.0 +DATALAYER_DEB_FILE_VERSION := 2.8.6 .PHONY: all go-dep apt-dep lint vet test test-coverage build clean diff --git a/README.md b/README.md index 7cc823a..99fa452 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # ctrlX Data Layer client and provider library for golang This project provides: - + 1. ctrlX Data Layer access via Golang It wraps the original ctrlX Data Layer written in C++. @@ -10,9 +10,9 @@ This project provides: 2. Server-Sent Events(SSE) Client - Server-Sent Events is HTTP/HTTP2 common standard, the SSE server pushes the update to the client, the client receives automatic updates via HTTP connection. + Server-Sent Events is HTTP/HTTP2 common standard, the SSE server pushes the update to the client, the client receives automatic updates via HTTP connection. - ctrlX Data Layer provides a SSE Server, which makes the data on the Data Layer accessible to the web application. + ctrlX Data Layer provides a SSE Server, which makes the data on the Data Layer accessible to the web application. The SSE client library can be used to connect to the SSE Server of the ctrlX Data Layer running on the ctrlX Device. It is possible to subscribe to nodes on the server and the server will automatically send new updates on value changes. @@ -20,15 +20,14 @@ This project provides: 3. Token handling - JSON Web Token is used for authentification in ctrlX Core. + JSON Web Token is used for authentification in ctrlX Core. - The token library can be used to get token from ctrlX Core and later on check if the token is still valid. + The token library can be used to get token from ctrlX Core and later on check if the token is still valid. You can find documentation here [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/token) ## Status - ![Make Test](https://github.com/boschrexroth/ctrlx-datalayer-golang/actions/workflows/main.yml/badge.svg) ## Usage @@ -44,8 +43,8 @@ sudo apt-get install libsystemd-dev libsystemd-dev:arm64 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/3.2.0/ctrlx-datalayer-2.7.5.deb -sudo dpkg -i ctrlx-datalayer-2.7.5.deb +wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/3.4.0/ctrlx-datalayer-2.8.6.deb +sudo dpkg -i ctrlx-datalayer-2.8.6.deb ``` ### Integrate in you project @@ -60,16 +59,16 @@ Copyright © 2022 Bosch Rexroth AG. All rights reserved. -Bosch Rexroth AG -Bgm.-Dr.-Nebel-Str. 2 -97816 Lohr am Main +Bosch Rexroth AG +Bgm.-Dr.-Nebel-Str. 2 +97816 Lohr am Main GERMANY ## Licenses MIT License -Copyright (c) 2021-2022 Bosch Rexroth AG +Copyright (c) 2021-2024 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 diff --git a/pkg/datalayer/nodeHandler.c b/pkg/datalayer/nodeHandler.c index 6516a6a..37f4def 100755 --- a/pkg/datalayer/nodeHandler.c +++ b/pkg/datalayer/nodeHandler.c @@ -68,3 +68,13 @@ void nodeCallbackOnMetadata(void *userdata, char *address, TYPE_CB cb, TYPE_CBDA { nodeCallbackGo(userdata, address, NULL, cb, (uint64_t)cbdata, NODE_ACTION_ON_METADATA); } + +void nodeCallbackSubscription(void *userdata, DLR_SUBSCRIPTION subscription, char *address) +{ + nodeCallbackSubGo(userdata, subscription, address, NODE_ACTION_ON_SUBSCRIPTION); +} + +void nodeCallbackUnsubscription(void *userdata, DLR_SUBSCRIPTION subscription, char *address) +{ + nodeCallbackSubGo(userdata, subscription, address, NODE_ACTION_ON_UNSUBSCRIPTION); +} \ No newline at end of file diff --git a/pkg/datalayer/nodeHandler.go b/pkg/datalayer/nodeHandler.go index cb5c762..e5cfe8e 100755 --- a/pkg/datalayer/nodeHandler.go +++ b/pkg/datalayer/nodeHandler.go @@ -39,6 +39,8 @@ typedef enum NODE_ACTION { NODE_ACTION_ON_READ, NODE_ACTION_ON_WRITE, NODE_ACTION_ON_METADATA, + NODE_ACTION_ON_SUBSCRIPTION, + NODE_ACTION_ON_UNSUBSCRIPTION }NODE_ACTION; extern void callCallbackC(TYPE_CB cb, uint64_t cbdata, DLR_RESULT result, DLR_VARIANT data); @@ -48,7 +50,11 @@ extern void nodeCallbackOnRemove(void* userdata, char* address, TYPE_CB cb, TYPE extern void nodeCallbackOnBrowse(void* userdata, char* address, TYPE_CB cb, TYPE_CBDATA cbdata); extern void nodeCallbackOnRead(void* userdata, char* address, DLR_VARIANT data, TYPE_CB cb, TYPE_CBDATA cbdata); extern void nodeCallbackOnWrite(void* userdata, char* address, DLR_VARIANT data, TYPE_CB cb, TYPE_CBDATA cbdata); -extern void nodeCallbackOnMetadata(void* userdata, char* address, TYPE_CB cb, TYPE_CBDATA cbdata);*/ +extern void nodeCallbackOnMetadata(void* userdata, char* address, TYPE_CB cb, TYPE_CBDATA cbdata); +extern void nodeCallbackSubscription(void *userdata, DLR_SUBSCRIPTION subscription, char *address); +extern void nodeCallbackUnsubscription(void *userdata, DLR_SUBSCRIPTION subscription, char *address); + +*/ import "C" import ( "sync" @@ -60,12 +66,14 @@ type nodeAction C.enum_NODE_ACTION // nodeAction enum definition const ( - nodeActionOnCreate nodeAction = C.NODE_ACTION_ON_CREATE - nodeActionOnRemove nodeAction = C.NODE_ACTION_ON_REMOVE - nodeActionOnBrowse nodeAction = C.NODE_ACTION_ON_BROWSE - nodeActionOnRead nodeAction = C.NODE_ACTION_ON_READ - nodeActionOnWrite nodeAction = C.NODE_ACTION_ON_WRITE - nodeActionOnMetadata nodeAction = C.NODE_ACTION_ON_METADATA + nodeActionOnCreate nodeAction = C.NODE_ACTION_ON_CREATE + nodeActionOnRemove nodeAction = C.NODE_ACTION_ON_REMOVE + nodeActionOnBrowse nodeAction = C.NODE_ACTION_ON_BROWSE + nodeActionOnRead nodeAction = C.NODE_ACTION_ON_READ + nodeActionOnWrite nodeAction = C.NODE_ACTION_ON_WRITE + nodeActionOnMetadata nodeAction = C.NODE_ACTION_ON_METADATA + nodeActionOnSubsciption nodeAction = C.NODE_ACTION_ON_SUBSCRIPTION + nodeActionOnUnsubsciption nodeAction = C.NODE_ACTION_ON_UNSUBSCRIPTION ) // nodeCallbackData type @@ -96,7 +104,22 @@ func nodeCallbackGo(cuserdata unsafe.Pointer, caddress *C.char, cdata C.DLR_VARI } } -// getNodeCallbacksC get struct with all C callbacks +//export nodeCallbackSubGo +func nodeCallbackSubGo(cuserdata unsafe.Pointer, sub C.DLR_SUBSCRIPTION, caddress *C.char, action C.int) { + var i int = *(*int)(cuserdata) + var userdata *nodeUserData = nodeLookup(i) + address := C.GoString(caddress) + switch nodeAction(action) { + case nodeActionOnSubsciption: + userdata.channels.OnSubscribe <- ProviderNodeSubscription{Address: address, Subsciption: &ProviderSubscription{this: sub}} + case nodeActionOnUnsubsciption: + userdata.channels.OnUnsubscribe <- ProviderNodeSubscription{Address: address, Subsciption: &ProviderSubscription{this: sub}} + default: + panic("Unknown action type in callback") + } +} + +// getNodeCallbacksC get struct with subset of the C callbacks func getNodeCallbacksC(userdata unsafe.Pointer) C.DLR_PROVIDER_NODE_CALLBACKS { return C.DLR_PROVIDER_NODE_CALLBACKS{ userData: userdata, @@ -109,6 +132,21 @@ func getNodeCallbacksC(userdata unsafe.Pointer) C.DLR_PROVIDER_NODE_CALLBACKS { } } +// getNodeSubCallbacksC get struct with all C callbacks +func getNodeSubCallbacksC(userdata unsafe.Pointer) C.DLR_PROVIDER_NODE_CALLBACKS { + return C.DLR_PROVIDER_NODE_CALLBACKS{ + userData: userdata, + onCreate: (*[0]byte)(C.nodeCallbackOnCreate), + onRemove: (*[0]byte)(C.nodeCallbackOnRemove), + onBrowse: (*[0]byte)(C.nodeCallbackOnBrowse), + onRead: (*[0]byte)(C.nodeCallbackOnRead), + onWrite: (*[0]byte)(C.nodeCallbackOnWrite), + onMetadata: (*[0]byte)(C.nodeCallbackOnMetadata), + onSubscribe: (*[0]byte)(C.nodeCallbackSubscription), + onUnsubscribe: (*[0]byte)(C.nodeCallbackUnsubscription), + } +} + // getNodeUserdata store Go channels in userdata of C callback func getNodeUserdata(channels ProviderNodeChannels) unsafe.Pointer { userdata := &nodeUserData{channels: channels} diff --git a/pkg/datalayer/notifyitempublish.go b/pkg/datalayer/notifyitempublish.go new file mode 100644 index 0000000..956cd10 --- /dev/null +++ b/pkg/datalayer/notifyitempublish.go @@ -0,0 +1,113 @@ +// MIT License +// +// Copyright (c) 2021-2024 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 ( + "time" + + fbs "github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/fbs/comm/datalayer" + flatbuffers "github.com/google/flatbuffers/go" +) + +// NotifyItemPublish interface for publish subscription items. +type NotifyItemPublish struct { + data *Variant + info *Variant + notifyInfo *fbs.NotifyInfoT +} + +// NewNotifyItemPublish creates a NotifyItemPublish +// Parameter address is the address of the provider node. +func NewNotifyItemPublish(address string) *NotifyItemPublish { + i := &NotifyItemPublish{ + data: NewVariant(), + info: NewVariant(), + notifyInfo: &fbs.NotifyInfoT{ + Node: address, + Timestamp: toFiletime(time.Now()), + NotifyType: fbs.NotifyTypeData, + SequenceNumber: 0, + }, + } + return i +} + +// deleteNotifyItemPublish removes a NotifyItemPublish. +// Parameter n is an instance of the NotifyItemPublish. +func deleteNotifyItemPublish(n *NotifyItemPublish) { + if n == nil { + return + } + DeleteVariant(n.data) + DeleteVariant(n.info) +} + +// DeleteNotifyItemsPublish removes a lit of NotifyItemPublish. +// Parameter s is list of the NotifyItemPublish. +func DeleteNotifyItemsPublish(l []*NotifyItemPublish) { + for _, n := range l { + deleteNotifyItemPublish(n) + } +} + +// GetData gets the data of the notify item. +// It returns the variant. +func (i *NotifyItemPublish) GetData() *Variant { + return i.data +} + +// GetInfo gets the info of the notify item. +// containing notify_info.fbs (address, timestamp, type, ...). +// It returns the variant +func (i *NotifyItemPublish) GetInfo() *Variant { + builder := flatbuffers.NewBuilder(4096) + niPack := i.notifyInfo.Pack(builder) + builder.Finish(niPack) + i.info.SetFlatbuffers(builder.FinishedBytes()) + return i.info +} + +// SetNotifyType sets the NotifyType of the notify_info.fbs. +func (i *NotifyItemPublish) SetNotifyType(n fbs.NotifyType) { + i.notifyInfo.NotifyType = n +} + +// SetTimestamp sets a time.Time value since January 1, 1970 UTC of the notify_info.fbs. +func (i *NotifyItemPublish) SetTimestamp(t time.Time) { + i.notifyInfo.Timestamp = toFiletime(t) +} + +// SetEventType sets eventtype of the notify_info.fbs. +func (i *NotifyItemPublish) SetEventType(e string) { + i.notifyInfo.EventType = e +} + +// SetSequenceNumber sets sequence number of the notify_info.fbs. +func (i *NotifyItemPublish) SetSequenceNumber(n uint64) { + i.notifyInfo.SequenceNumber = n +} + +// SetSequenceNumber sets source name of the notify_info.fbs. +func (i *NotifyItemPublish) SetSourceName(s string) { + i.notifyInfo.SourceName = s +} diff --git a/pkg/datalayer/provider.go b/pkg/datalayer/provider.go index bac6964..f4dd7c7 100755 --- a/pkg/datalayer/provider.go +++ b/pkg/datalayer/provider.go @@ -129,3 +129,47 @@ func (p *Provider) GetToken() *Variant { ptr := C.DLR_providerGetToken(p.this) return &Variant{this: ptr} } + +// GetRegisteredType get the variant of a registered type +// Parameter address is address of the type to get type (no wildcards allowed). +// It returns the status of function call and variant to stored type (Result, Variant). +func (p *Provider) GetRegisteredType(address string) (Result, *Variant) { + caddress := C.CString(address) + defer C.free(unsafe.Pointer(caddress)) + data := NewVariant() + r := Result(C.DLR_providerGetRegisteredType(p.this, caddress, data.this)) + return r, data +} + +// GetRegisteredNodePaths return the current registered node paths. +// It returns the status of function call and list of registered node paths. +func (p *Provider) GetRegisteredNodePaths() (Result, []string) { + data := NewVariant() + defer DeleteVariant(data) + r := Result(C.DLR_providerGetRegisteredNodePaths(p.this, data.this)) + if r != ResultOk { + return r, []string{} + } + return r, data.GetArrayString() +} + +// GetRejectedNodePaths return the current rejected node paths. +// It returns the status of function call and list of rejected node paths. +func (p *Provider) GetRejectedNodePaths() (Result, []string) { + data := NewVariant() + defer DeleteVariant(data) + r := Result(C.DLR_providerGetRejectedNodePaths(p.this, data.this)) + if r != ResultOk { + return r, []string{} + } + return r, data.GetArrayString() +} + +// PublishEvent publishes an event +// Parameter data is the payload data of the event. Has to match the type, that is given in the notifyInfo. +// Parameter eventtype contains additional info about the event with type event_info.fbs. +// It returns the status of function call. +func (p *Provider) PublishEvent(data, eventtype *Variant) Result { + r := Result(C.DLR_providerPublishEvent(p.this, data.this, eventtype.this)) + return r +} diff --git a/pkg/datalayer/providerNode.go b/pkg/datalayer/providerNode.go index 662fd26..3320a82 100755 --- a/pkg/datalayer/providerNode.go +++ b/pkg/datalayer/providerNode.go @@ -48,15 +48,23 @@ type ProviderNodeEventData struct { Callback ProviderNodeCallback } +// ProviderNodeSubscription event +type ProviderNodeSubscription struct { + Address string + Subsciption *ProviderSubscription +} + // ProviderNodeChannels sets the struct. type ProviderNodeChannels struct { - OnCreate chan ProviderNodeEventData - OnRemove chan ProviderNodeEvent - OnBrowse chan ProviderNodeEvent - OnRead chan ProviderNodeEventData - OnWrite chan ProviderNodeEventData - OnMetadata chan ProviderNodeEvent - Done chan bool + OnCreate chan ProviderNodeEventData + OnRemove chan ProviderNodeEvent + OnBrowse chan ProviderNodeEvent + OnRead chan ProviderNodeEventData + OnWrite chan ProviderNodeEventData + OnMetadata chan ProviderNodeEvent + OnSubscribe chan ProviderNodeSubscription + OnUnsubscribe chan ProviderNodeSubscription + Done chan bool } // ProviderNode interface for providing data to the system. @@ -75,13 +83,15 @@ func (n *ProviderNode) Channels() *ProviderNodeChannels { // NewProviderNode initializes the provider node. func NewProviderNode() *ProviderNode { channels := ProviderNodeChannels{ - OnCreate: make(chan ProviderNodeEventData, providerNodeChannelSize), - OnRemove: make(chan ProviderNodeEvent, providerNodeChannelSize), - OnBrowse: make(chan ProviderNodeEvent, providerNodeChannelSize), - OnRead: make(chan ProviderNodeEventData, providerNodeChannelSize), - OnWrite: make(chan ProviderNodeEventData, providerNodeChannelSize), - OnMetadata: make(chan ProviderNodeEvent, providerNodeChannelSize), - Done: make(chan bool), + OnCreate: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnRemove: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnBrowse: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnRead: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnWrite: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnMetadata: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnSubscribe: nil, + OnUnsubscribe: nil, + Done: make(chan bool), } userdata := getNodeUserdata(channels) ptr := C.DLR_providerNodeCreate(getNodeCallbacksC(userdata)) @@ -92,6 +102,28 @@ func NewProviderNode() *ProviderNode { } } +// NewProviderNodeSub initializes the provider node and support the OnSubscribe and OnUnsubscribe interface. +func NewProviderNodeSub() *ProviderNode { + channels := ProviderNodeChannels{ + OnCreate: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnRemove: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnBrowse: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnRead: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnWrite: make(chan ProviderNodeEventData, providerNodeChannelSize), + OnMetadata: make(chan ProviderNodeEvent, providerNodeChannelSize), + OnSubscribe: make(chan ProviderNodeSubscription, providerNodeChannelSize), + OnUnsubscribe: make(chan ProviderNodeSubscription, providerNodeChannelSize), + Done: make(chan bool), + } + userdata := getNodeUserdata(channels) + ptr := C.DLR_providerNodeCreate(getNodeSubCallbacksC(userdata)) + return &ProviderNode{ + this: ptr, + userdata: userdata, + channels: channels, + } +} + // DeleteProviderNode destructs the provider node. func DeleteProviderNode(n *ProviderNode) { if n == nil { @@ -109,5 +141,11 @@ func DeleteProviderNode(n *ProviderNode) { close(n.channels.OnBrowse) close(n.channels.OnRead) close(n.channels.OnMetadata) + if n.channels.OnSubscribe != nil { + close(n.channels.OnSubscribe) + } + if n.channels.OnUnsubscribe != nil { + close(n.channels.OnUnsubscribe) + } n.this = nil } diff --git a/pkg/datalayer/providerSubscription.c b/pkg/datalayer/providerSubscription.c new file mode 100755 index 0000000..6d1a7fa --- /dev/null +++ b/pkg/datalayer/providerSubscription.c @@ -0,0 +1,81 @@ +/** + * MIT License + * + * Copyright (c) 2021-2024 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. + */ +#include "_cgo_export.h" + +#include +#include +#include + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Wrapper of a list of DLR_NOTIFY_ITEM +typedef struct VEC_NOTIFY_ITEM +{ + size_t count; //! count of requests + DLR_NOTIFY_ITEM* items; //! array of DLR_NOTIFY_ITEM +} VEC_NOTIFY_ITEM; + +// CreateProviderSubscriptionsNotifyItems create a wrapper of a list of DLR_NOTIFY_ITEM +unsigned long long CreateProviderSubscriptionsNotifyItems(size_t size) +{ + VEC_NOTIFY_ITEM *p = malloc(sizeof(VEC_NOTIFY_ITEM)); + p->items = malloc(sizeof(DLR_NOTIFY_ITEM) * size); + p->count = size; + return (unsigned long long)p; +} + +// DeleteProviderSubscriptionsNotifyItems remove wrapper +void DeleteProviderSubscriptionsNotifyItems(unsigned long long p) +{ + VEC_NOTIFY_ITEM *ptr = (VEC_NOTIFY_ITEM *)p; + free(ptr->items); + free(ptr); +} + +// SetProviderSubscriptionsNotifyItem set the DLR_NOTIFY_ITEM +void SetProviderSubscriptionsNotifyItem(unsigned long long p, uint32_t index, DLR_VARIANT data, DLR_VARIANT info) +{ + VEC_NOTIFY_ITEM *ptr = (VEC_NOTIFY_ITEM *)p; + if (index >= ptr->count) + { + return; + } + ptr->items[index].data = data; + ptr->items[index].info = info; +} + +// GetProviderSubscriptionsNotifyItems gets the list of DLR_NOTIFY_ITEM +DLR_NOTIFY_ITEM* GetProviderSubscriptionsNotifyItems(unsigned long long p) +{ + VEC_NOTIFY_ITEM *ptr = (VEC_NOTIFY_ITEM *)p; + return ptr->items; +} + +#ifdef __cplusplus +} +#endif diff --git a/pkg/datalayer/providerSubscription.go b/pkg/datalayer/providerSubscription.go new file mode 100644 index 0000000..a2ccfad --- /dev/null +++ b/pkg/datalayer/providerSubscription.go @@ -0,0 +1,85 @@ +// MIT License +// +// Copyright (c) 2021-2024 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 + +//#include +//#include +//#include +//extern unsigned long long CreateProviderSubscriptionsNotifyItems(size_t size); +//extern void DeleteProviderSubscriptionsNotifyItems(unsigned long long p); +//extern void SetProviderSubscriptionsNotifyItem(unsigned long long p, uint32_t index, DLR_VARIANT data, DLR_VARIANT info); +//extern DLR_NOTIFY_ITEM* GetProviderSubscriptionsNotifyItems(unsigned long long p); +import "C" +import ( + "time" + + fbs "github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/fbs/comm/datalayer" +) + +// ProviderSubscription interface to manage subscription. +type ProviderSubscription struct { + this C.DLR_SUBSCRIPTION +} + +// GetUniqueId unambiguous identification of the subscription +func (p *ProviderSubscription) GetUniqueId() uint64 { + return uint64(uintptr(p.this)) +} + +// GetTimestamp is a wrapper function for C.DLR_SubscriptionGetTimestamp +func (p *ProviderSubscription) GetTimestamp() time.Time { + time := C.DLR_SubscriptionGetTimestamp(p.this) + return getTime(int64(time)) +} + +// GetNodes gets the list of address nodes of a subscription +func (p *ProviderSubscription) GetNodes() []string { + n := NewVariant() + defer DeleteVariant(n) + C.DLR_SubscriptionGetNodes(p.this, n.this) + return n.GetArrayString() +} + +// GetProps gets the properties of a subscription +func (p *ProviderSubscription) GetProps() *fbs.SubscriptionProperties { + v := C.DLR_SubscriptionGetProps(p.this) + vf := &Variant{this: v} + props := fbs.GetRootAsSubscriptionProperties(vf.GetFlatbuffers(), 0) + return props +} + +// Publish publishes new data for this subscription +// Parameter status of notification. On failure subscription is canceled for all items. +// Parameter items list of the notification items. +func (p *ProviderSubscription) Publish(status Result, items []*NotifyItemPublish) Result { + if len(items) == 0 { + return ResultOk + } + handle := C.CreateProviderSubscriptionsNotifyItems(C.size_t(len(items))) + for i, n := range items { + C.SetProviderSubscriptionsNotifyItem(handle, C.uint32_t(i), n.GetData().this, n.GetInfo().this) + } + r := Result(C.DLR_SubscriptionPublish(p.this, C.DLR_RESULT(status), C.GetProviderSubscriptionsNotifyItems(handle), C.size_t(len(items)))) + C.DeleteProviderSubscriptionsNotifyItems(handle) + return r +} diff --git a/pkg/datalayer/variant.go b/pkg/datalayer/variant.go index 93315b3..5f3fc7a 100755 --- a/pkg/datalayer/variant.go +++ b/pkg/datalayer/variant.go @@ -442,9 +442,7 @@ func (v *Variant) GetTime() time.Time { // 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)) + v.SetTimestamp(toFiletime(df)) } // see. https://stackoverflow.com/questions/57901280/calculate-time-time-from-timestamp-starting-from-1601-01-01-in-go @@ -463,6 +461,13 @@ func getTime(input int64) time.Time { return t } +// toFiletime converts a time.Time value since January 1, 1970 UTC to Filetime +func toFiletime(df time.Time) uint64 { + ns := df.UTC().UnixNano() + ft := convertUnixTime2FileTime(ns) + return uint64(ft) +} + // 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 { diff --git a/pkg/fbs/comm/datalayer/Bar.go b/pkg/fbs/comm/datalayer/Bar.go new file mode 100644 index 0000000..ec6250e --- /dev/null +++ b/pkg/fbs/comm/datalayer/Bar.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Diagnosis of nvram +type BarT struct { + Test *FooT `json:"test"` +} + +func (t *BarT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + BarStart(builder) + testOffset := t.Test.Pack(builder) + BarAddTest(builder, testOffset) + return BarEnd(builder) +} + +func (rcv *Bar) UnPackTo(t *BarT) { + t.Test = rcv.Test(nil).UnPack() +} + +func (rcv *Bar) UnPack() *BarT { + if rcv == nil { return nil } + t := &BarT{} + rcv.UnPackTo(t) + return t +} + +type Bar struct { + _tab flatbuffers.Table +} + +func GetRootAsBar(buf []byte, offset flatbuffers.UOffsetT) *Bar { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Bar{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBar(buf []byte, offset flatbuffers.UOffsetT) *Bar { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Bar{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Bar) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Bar) Table() flatbuffers.Table { + return rcv._tab +} + +/// List of corrupted memory areas in nvram +func (rcv *Bar) Test(obj *Foo) *Foo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(Foo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// List of corrupted memory areas in nvram +func BarStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func BarAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) { + builder.PrependStructSlot(0, flatbuffers.UOffsetT(test), 0) +} +func BarEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/Foo.go b/pkg/fbs/comm/datalayer/Foo.go new file mode 100644 index 0000000..7636929 --- /dev/null +++ b/pkg/fbs/comm/datalayer/Foo.go @@ -0,0 +1,72 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FooT struct { + A float32 `json:"a"` + B float32 `json:"b"` + C float32 `json:"c"` +} + +func (t *FooT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + return CreateFoo(builder, t.A, t.B, t.C) +} +func (rcv *Foo) UnPackTo(t *FooT) { + t.A = rcv.A() + t.B = rcv.B() + t.C = rcv.C() +} + +func (rcv *Foo) UnPack() *FooT { + if rcv == nil { return nil } + t := &FooT{} + rcv.UnPackTo(t) + return t +} + +type Foo struct { + _tab flatbuffers.Struct +} + +func (rcv *Foo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Foo) Table() flatbuffers.Table { + return rcv._tab.Table +} + +func (rcv *Foo) A() float32 { + return rcv._tab.GetFloat32(rcv._tab.Pos + flatbuffers.UOffsetT(0)) +} +func (rcv *Foo) MutateA(n float32) bool { + return rcv._tab.MutateFloat32(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) +} + +func (rcv *Foo) B() float32 { + return rcv._tab.GetFloat32(rcv._tab.Pos + flatbuffers.UOffsetT(4)) +} +func (rcv *Foo) MutateB(n float32) bool { + return rcv._tab.MutateFloat32(rcv._tab.Pos+flatbuffers.UOffsetT(4), n) +} + +func (rcv *Foo) C() float32 { + return rcv._tab.GetFloat32(rcv._tab.Pos + flatbuffers.UOffsetT(8)) +} +func (rcv *Foo) MutateC(n float32) bool { + return rcv._tab.MutateFloat32(rcv._tab.Pos+flatbuffers.UOffsetT(8), n) +} + +func CreateFoo(builder *flatbuffers.Builder, a float32, b float32, c float32) flatbuffers.UOffsetT { + builder.Prep(4, 12) + builder.PrependFloat32(c) + builder.PrependFloat32(b) + builder.PrependFloat32(a) + return builder.Offset() +} diff --git a/pkg/fbs/comm/datalayer/LosslessInterval.go b/pkg/fbs/comm/datalayer/LosslessInterval.go new file mode 100644 index 0000000..07b9c3f --- /dev/null +++ b/pkg/fbs/comm/datalayer/LosslessInterval.go @@ -0,0 +1,100 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LosslessIntervalT struct { + SamplingInterval uint64 `json:"samplingInterval"` + Tolerance uint64 `json:"tolerance"` +} + +func (t *LosslessIntervalT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + LosslessIntervalStart(builder) + LosslessIntervalAddSamplingInterval(builder, t.SamplingInterval) + LosslessIntervalAddTolerance(builder, t.Tolerance) + return LosslessIntervalEnd(builder) +} + +func (rcv *LosslessInterval) UnPackTo(t *LosslessIntervalT) { + t.SamplingInterval = rcv.SamplingInterval() + t.Tolerance = rcv.Tolerance() +} + +func (rcv *LosslessInterval) UnPack() *LosslessIntervalT { + if rcv == nil { return nil } + t := &LosslessIntervalT{} + rcv.UnPackTo(t) + return t +} + +type LosslessInterval struct { + _tab flatbuffers.Table +} + +func GetRootAsLosslessInterval(buf []byte, offset flatbuffers.UOffsetT) *LosslessInterval { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LosslessInterval{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLosslessInterval(buf []byte, offset flatbuffers.UOffsetT) *LosslessInterval { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LosslessInterval{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LosslessInterval) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LosslessInterval) Table() flatbuffers.Table { + return rcv._tab +} + +/// Time in µs to wait for new data +func (rcv *LosslessInterval) SamplingInterval() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// Time in µs to wait for new data +func (rcv *LosslessInterval) MutateSamplingInterval(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +/// Time in µs as tolerance for samplingInterval +func (rcv *LosslessInterval) Tolerance() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// Time in µs as tolerance for samplingInterval +func (rcv *LosslessInterval) MutateTolerance(n uint64) bool { + return rcv._tab.MutateUint64Slot(6, n) +} + +func LosslessIntervalStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func LosslessIntervalAddSamplingInterval(builder *flatbuffers.Builder, samplingInterval uint64) { + builder.PrependUint64Slot(0, samplingInterval, 0) +} +func LosslessIntervalAddTolerance(builder *flatbuffers.Builder, tolerance uint64) { + builder.PrependUint64Slot(1, tolerance, 0) +} +func LosslessIntervalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/daq/Array.go b/pkg/fbs/comm/datalayer/daq/Array.go new file mode 100644 index 0000000..81a9146 --- /dev/null +++ b/pkg/fbs/comm/datalayer/daq/Array.go @@ -0,0 +1,178 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package daq + +import ( + "strconv" + flatbuffers "github.com/google/flatbuffers/go" + + comm__datalayer "github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/fbs/comm/datalayer" +) + +/// union of all array types +type Array byte + +const ( + ArrayNONE Array = 0 + ArrayArrayOfBool8 Array = 1 + ArrayArrayOfFloat32 Array = 2 + ArrayArrayOfFloat64 Array = 3 + ArrayArrayOfDouble Array = 4 + ArrayArrayOfInt8 Array = 5 + ArrayArrayOfInt16 Array = 6 + ArrayArrayOfInt32 Array = 7 + ArrayArrayOfInt64 Array = 8 + ArrayArrayOfUInt8 Array = 9 + ArrayArrayOfUInt16 Array = 10 + ArrayArrayOfUInt32 Array = 11 + ArrayArrayOfUInt64 Array = 12 + ArrayArrayOfTimestamp Array = 13 + ArrayArrayOfString Array = 14 +) + +var EnumNamesArray = map[Array]string{ + ArrayNONE: "NONE", + ArrayArrayOfBool8: "ArrayOfBool8", + ArrayArrayOfFloat32: "ArrayOfFloat32", + ArrayArrayOfFloat64: "ArrayOfFloat64", + ArrayArrayOfDouble: "ArrayOfDouble", + ArrayArrayOfInt8: "ArrayOfInt8", + ArrayArrayOfInt16: "ArrayOfInt16", + ArrayArrayOfInt32: "ArrayOfInt32", + ArrayArrayOfInt64: "ArrayOfInt64", + ArrayArrayOfUInt8: "ArrayOfUInt8", + ArrayArrayOfUInt16: "ArrayOfUInt16", + ArrayArrayOfUInt32: "ArrayOfUInt32", + ArrayArrayOfUInt64: "ArrayOfUInt64", + ArrayArrayOfTimestamp: "ArrayOfTimestamp", + ArrayArrayOfString: "ArrayOfString", +} + +var EnumValuesArray = map[string]Array{ + "NONE": ArrayNONE, + "ArrayOfBool8": ArrayArrayOfBool8, + "ArrayOfFloat32": ArrayArrayOfFloat32, + "ArrayOfFloat64": ArrayArrayOfFloat64, + "ArrayOfDouble": ArrayArrayOfDouble, + "ArrayOfInt8": ArrayArrayOfInt8, + "ArrayOfInt16": ArrayArrayOfInt16, + "ArrayOfInt32": ArrayArrayOfInt32, + "ArrayOfInt64": ArrayArrayOfInt64, + "ArrayOfUInt8": ArrayArrayOfUInt8, + "ArrayOfUInt16": ArrayArrayOfUInt16, + "ArrayOfUInt32": ArrayArrayOfUInt32, + "ArrayOfUInt64": ArrayArrayOfUInt64, + "ArrayOfTimestamp": ArrayArrayOfTimestamp, + "ArrayOfString": ArrayArrayOfString, +} + +func (v Array) String() string { + if s, ok := EnumNamesArray[v]; ok { + return s + } + return "Array(" + strconv.FormatInt(int64(v), 10) + ")" +} + +type ArrayT struct { + Type Array + Value interface{} +} + +func (t *ArrayT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case ArrayArrayOfBool8: + return t.Value.(*comm__datalayer.ArrayOfBool8T).Pack(builder) + case ArrayArrayOfFloat32: + return t.Value.(*comm__datalayer.ArrayOfFloat32T).Pack(builder) + case ArrayArrayOfFloat64: + return t.Value.(*comm__datalayer.ArrayOfFloat64T).Pack(builder) + case ArrayArrayOfDouble: + return t.Value.(*comm__datalayer.ArrayOfDoubleT).Pack(builder) + case ArrayArrayOfInt8: + return t.Value.(*comm__datalayer.ArrayOfInt8T).Pack(builder) + case ArrayArrayOfInt16: + return t.Value.(*comm__datalayer.ArrayOfInt16T).Pack(builder) + case ArrayArrayOfInt32: + return t.Value.(*comm__datalayer.ArrayOfInt32T).Pack(builder) + case ArrayArrayOfInt64: + return t.Value.(*comm__datalayer.ArrayOfInt64T).Pack(builder) + case ArrayArrayOfUInt8: + return t.Value.(*comm__datalayer.ArrayOfUInt8T).Pack(builder) + case ArrayArrayOfUInt16: + return t.Value.(*comm__datalayer.ArrayOfUInt16T).Pack(builder) + case ArrayArrayOfUInt32: + return t.Value.(*comm__datalayer.ArrayOfUInt32T).Pack(builder) + case ArrayArrayOfUInt64: + return t.Value.(*comm__datalayer.ArrayOfUInt64T).Pack(builder) + case ArrayArrayOfTimestamp: + return t.Value.(*comm__datalayer.ArrayOfTimestampT).Pack(builder) + case ArrayArrayOfString: + return t.Value.(*comm__datalayer.ArrayOfStringT).Pack(builder) + } + return 0 +} + +func (rcv Array) UnPack(table flatbuffers.Table) *ArrayT { + switch rcv { + case ArrayArrayOfBool8: + var x comm__datalayer.ArrayOfBool8 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfBool8, Value: x.UnPack() } + case ArrayArrayOfFloat32: + var x comm__datalayer.ArrayOfFloat32 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfFloat32, Value: x.UnPack() } + case ArrayArrayOfFloat64: + var x comm__datalayer.ArrayOfFloat64 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfFloat64, Value: x.UnPack() } + case ArrayArrayOfDouble: + var x comm__datalayer.ArrayOfDouble + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfDouble, Value: x.UnPack() } + case ArrayArrayOfInt8: + var x comm__datalayer.ArrayOfInt8 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfInt8, Value: x.UnPack() } + case ArrayArrayOfInt16: + var x comm__datalayer.ArrayOfInt16 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfInt16, Value: x.UnPack() } + case ArrayArrayOfInt32: + var x comm__datalayer.ArrayOfInt32 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfInt32, Value: x.UnPack() } + case ArrayArrayOfInt64: + var x comm__datalayer.ArrayOfInt64 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfInt64, Value: x.UnPack() } + case ArrayArrayOfUInt8: + var x comm__datalayer.ArrayOfUInt8 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfUInt8, Value: x.UnPack() } + case ArrayArrayOfUInt16: + var x comm__datalayer.ArrayOfUInt16 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfUInt16, Value: x.UnPack() } + case ArrayArrayOfUInt32: + var x comm__datalayer.ArrayOfUInt32 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfUInt32, Value: x.UnPack() } + case ArrayArrayOfUInt64: + var x comm__datalayer.ArrayOfUInt64 + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfUInt64, Value: x.UnPack() } + case ArrayArrayOfTimestamp: + var x comm__datalayer.ArrayOfTimestamp + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfTimestamp, Value: x.UnPack() } + case ArrayArrayOfString: + var x comm__datalayer.ArrayOfString + x.Init(table.Bytes, table.Pos) + return &ArrayT{ Type: ArrayArrayOfString, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/comm/datalayer/daq/DaqContainer.go b/pkg/fbs/comm/datalayer/daq/DaqContainer.go new file mode 100644 index 0000000..eb19d9b --- /dev/null +++ b/pkg/fbs/comm/datalayer/daq/DaqContainer.go @@ -0,0 +1,258 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package daq + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// DAQ container containing equidistant and non-equidistant daq data +type DaqContainerT struct { + Name string `json:"name"` + Tags []*TagT `json:"tags"` + Equidistant []*EquidistantT `json:"equidistant"` + NonEquidistant []*NonEquidistantT `json:"nonEquidistant"` +} + +func (t *DaqContainerT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + tagsOffset := flatbuffers.UOffsetT(0) + if t.Tags != nil { + tagsLength := len(t.Tags) + tagsOffsets := make([]flatbuffers.UOffsetT, tagsLength) + for j := 0; j < tagsLength; j++ { + tagsOffsets[j] = t.Tags[j].Pack(builder) + } + DaqContainerStartTagsVector(builder, tagsLength) + for j := tagsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(tagsOffsets[j]) + } + tagsOffset = builder.EndVector(tagsLength) + } + equidistantOffset := flatbuffers.UOffsetT(0) + if t.Equidistant != nil { + equidistantLength := len(t.Equidistant) + equidistantOffsets := make([]flatbuffers.UOffsetT, equidistantLength) + for j := 0; j < equidistantLength; j++ { + equidistantOffsets[j] = t.Equidistant[j].Pack(builder) + } + DaqContainerStartEquidistantVector(builder, equidistantLength) + for j := equidistantLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(equidistantOffsets[j]) + } + equidistantOffset = builder.EndVector(equidistantLength) + } + nonEquidistantOffset := flatbuffers.UOffsetT(0) + if t.NonEquidistant != nil { + nonEquidistantLength := len(t.NonEquidistant) + nonEquidistantOffsets := make([]flatbuffers.UOffsetT, nonEquidistantLength) + for j := 0; j < nonEquidistantLength; j++ { + nonEquidistantOffsets[j] = t.NonEquidistant[j].Pack(builder) + } + DaqContainerStartNonEquidistantVector(builder, nonEquidistantLength) + for j := nonEquidistantLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(nonEquidistantOffsets[j]) + } + nonEquidistantOffset = builder.EndVector(nonEquidistantLength) + } + DaqContainerStart(builder) + DaqContainerAddName(builder, nameOffset) + DaqContainerAddTags(builder, tagsOffset) + DaqContainerAddEquidistant(builder, equidistantOffset) + DaqContainerAddNonEquidistant(builder, nonEquidistantOffset) + return DaqContainerEnd(builder) +} + +func (rcv *DaqContainer) UnPackTo(t *DaqContainerT) { + t.Name = string(rcv.Name()) + tagsLength := rcv.TagsLength() + t.Tags = make([]*TagT, tagsLength) + for j := 0; j < tagsLength; j++ { + x := Tag{} + rcv.Tags(&x, j) + t.Tags[j] = x.UnPack() + } + equidistantLength := rcv.EquidistantLength() + t.Equidistant = make([]*EquidistantT, equidistantLength) + for j := 0; j < equidistantLength; j++ { + x := Equidistant{} + rcv.Equidistant(&x, j) + t.Equidistant[j] = x.UnPack() + } + nonEquidistantLength := rcv.NonEquidistantLength() + t.NonEquidistant = make([]*NonEquidistantT, nonEquidistantLength) + for j := 0; j < nonEquidistantLength; j++ { + x := NonEquidistant{} + rcv.NonEquidistant(&x, j) + t.NonEquidistant[j] = x.UnPack() + } +} + +func (rcv *DaqContainer) UnPack() *DaqContainerT { + if rcv == nil { return nil } + t := &DaqContainerT{} + rcv.UnPackTo(t) + return t +} + +type DaqContainer struct { + _tab flatbuffers.Table +} + +func GetRootAsDaqContainer(buf []byte, offset flatbuffers.UOffsetT) *DaqContainer { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DaqContainer{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDaqContainer(buf []byte, offset flatbuffers.UOffsetT) *DaqContainer { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DaqContainer{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DaqContainer) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DaqContainer) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the DAQ container +func (rcv *DaqContainer) 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 DAQ container +/// array of tags for meta data +func (rcv *DaqContainer) Tags(obj *Tag, 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 *DaqContainer) TagsByKey(obj *Tag, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *DaqContainer) TagsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of tags for meta data +/// array of equidistant data +func (rcv *DaqContainer) Equidistant(obj *Equidistant, 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 *DaqContainer) EquidistantByKey(obj *Equidistant, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *DaqContainer) EquidistantLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of equidistant data +/// array of non-equidistant data +func (rcv *DaqContainer) NonEquidistant(obj *NonEquidistant, 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 *DaqContainer) NonEquidistantByKey(obj *NonEquidistant, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *DaqContainer) NonEquidistantLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of non-equidistant data +func DaqContainerStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func DaqContainerAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func DaqContainerAddTags(builder *flatbuffers.Builder, tags flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(tags), 0) +} +func DaqContainerStartTagsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func DaqContainerAddEquidistant(builder *flatbuffers.Builder, equidistant flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(equidistant), 0) +} +func DaqContainerStartEquidistantVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func DaqContainerAddNonEquidistant(builder *flatbuffers.Builder, nonEquidistant flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(nonEquidistant), 0) +} +func DaqContainerStartNonEquidistantVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func DaqContainerEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/daq/Equidistant.go b/pkg/fbs/comm/datalayer/daq/Equidistant.go new file mode 100644 index 0000000..42fa430 --- /dev/null +++ b/pkg/fbs/comm/datalayer/daq/Equidistant.go @@ -0,0 +1,253 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package daq + +import ( + "bytes" + flatbuffers "github.com/google/flatbuffers/go" +) + +/// equidistant DAQ data +type EquidistantT struct { + Name string `json:"name"` + Tags []*TagT `json:"tags"` + TimestampNs uint64 `json:"timestampNs"` + IntervalNs uint64 `json:"intervalNs"` + Array *ArrayT `json:"array"` +} + +func (t *EquidistantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + tagsOffset := flatbuffers.UOffsetT(0) + if t.Tags != nil { + tagsLength := len(t.Tags) + tagsOffsets := make([]flatbuffers.UOffsetT, tagsLength) + for j := 0; j < tagsLength; j++ { + tagsOffsets[j] = t.Tags[j].Pack(builder) + } + EquidistantStartTagsVector(builder, tagsLength) + for j := tagsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(tagsOffsets[j]) + } + tagsOffset = builder.EndVector(tagsLength) + } + arrayOffset := t.Array.Pack(builder) + + EquidistantStart(builder) + EquidistantAddName(builder, nameOffset) + EquidistantAddTags(builder, tagsOffset) + EquidistantAddTimestampNs(builder, t.TimestampNs) + EquidistantAddIntervalNs(builder, t.IntervalNs) + if t.Array != nil { + EquidistantAddArrayType(builder, t.Array.Type) + } + EquidistantAddArray(builder, arrayOffset) + return EquidistantEnd(builder) +} + +func (rcv *Equidistant) UnPackTo(t *EquidistantT) { + t.Name = string(rcv.Name()) + tagsLength := rcv.TagsLength() + t.Tags = make([]*TagT, tagsLength) + for j := 0; j < tagsLength; j++ { + x := Tag{} + rcv.Tags(&x, j) + t.Tags[j] = x.UnPack() + } + t.TimestampNs = rcv.TimestampNs() + t.IntervalNs = rcv.IntervalNs() + arrayTable := flatbuffers.Table{} + if rcv.Array(&arrayTable) { + t.Array = rcv.ArrayType().UnPack(arrayTable) + } +} + +func (rcv *Equidistant) UnPack() *EquidistantT { + if rcv == nil { return nil } + t := &EquidistantT{} + rcv.UnPackTo(t) + return t +} + +type Equidistant struct { + _tab flatbuffers.Table +} + +func GetRootAsEquidistant(buf []byte, offset flatbuffers.UOffsetT) *Equidistant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Equidistant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsEquidistant(buf []byte, offset flatbuffers.UOffsetT) *Equidistant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Equidistant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Equidistant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Equidistant) Table() flatbuffers.Table { + return rcv._tab +} + +/// unique name of the equidistant data +func (rcv *Equidistant) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unique name of the equidistant data +func EquidistantKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { + obj1 := &Equidistant{} + obj2 := &Equidistant{} + obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + return string(obj1.Name()) < string(obj2.Name()) +} + +func (rcv *Equidistant) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { + span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + start := flatbuffers.UOffsetT(0) + bKey := []byte(key) + for span != 0 { + middle := span / 2 + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + obj := &Equidistant{} + obj.Init(buf, tableOffset) + comp := bytes.Compare(obj.Name(), bKey) + if comp > 0 { + span = middle + } else if comp < 0 { + middle += 1 + start += middle + span -= middle + } else { + rcv.Init(buf, tableOffset) + return true + } + } + return false +} + +/// array of tags for meta data +func (rcv *Equidistant) Tags(obj *Tag, 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 *Equidistant) TagsByKey(obj *Tag, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *Equidistant) TagsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of tags for meta data +/// unix epoch time (since 1.1.1970) for the 1st value in array in [ns] +func (rcv *Equidistant) TimestampNs() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// unix epoch time (since 1.1.1970) for the 1st value in array in [ns] +func (rcv *Equidistant) MutateTimestampNs(n uint64) bool { + return rcv._tab.MutateUint64Slot(8, n) +} + +/// sampling interval in [ns] +func (rcv *Equidistant) IntervalNs() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// sampling interval in [ns] +func (rcv *Equidistant) MutateIntervalNs(n uint64) bool { + return rcv._tab.MutateUint64Slot(10, n) +} + +func (rcv *Equidistant) ArrayType() Array { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return Array(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Equidistant) MutateArrayType(n Array) bool { + return rcv._tab.MutateByteSlot(12, byte(n)) +} + +/// array of equidistant sampled values starting at timestamp [ns] with interval [ns] +func (rcv *Equidistant) Array(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +/// array of equidistant sampled values starting at timestamp [ns] with interval [ns] +func EquidistantStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func EquidistantAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func EquidistantAddTags(builder *flatbuffers.Builder, tags flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(tags), 0) +} +func EquidistantStartTagsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func EquidistantAddTimestampNs(builder *flatbuffers.Builder, timestampNs uint64) { + builder.PrependUint64Slot(2, timestampNs, 0) +} +func EquidistantAddIntervalNs(builder *flatbuffers.Builder, intervalNs uint64) { + builder.PrependUint64Slot(3, intervalNs, 0) +} +func EquidistantAddArrayType(builder *flatbuffers.Builder, arrayType Array) { + builder.PrependByteSlot(4, byte(arrayType), 0) +} +func EquidistantAddArray(builder *flatbuffers.Builder, array flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(array), 0) +} +func EquidistantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/daq/NonEquidistant.go b/pkg/fbs/comm/datalayer/daq/NonEquidistant.go new file mode 100644 index 0000000..1e2ce3d --- /dev/null +++ b/pkg/fbs/comm/datalayer/daq/NonEquidistant.go @@ -0,0 +1,263 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package daq + +import ( + "bytes" + flatbuffers "github.com/google/flatbuffers/go" +) + +/// non-equidistant DAQ data +type NonEquidistantT struct { + Name string `json:"name"` + Tags []*TagT `json:"tags"` + TimestampsNs []uint64 `json:"timestampsNs"` + Array *ArrayT `json:"array"` +} + +func (t *NonEquidistantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + tagsOffset := flatbuffers.UOffsetT(0) + if t.Tags != nil { + tagsLength := len(t.Tags) + tagsOffsets := make([]flatbuffers.UOffsetT, tagsLength) + for j := 0; j < tagsLength; j++ { + tagsOffsets[j] = t.Tags[j].Pack(builder) + } + NonEquidistantStartTagsVector(builder, tagsLength) + for j := tagsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(tagsOffsets[j]) + } + tagsOffset = builder.EndVector(tagsLength) + } + timestampsNsOffset := flatbuffers.UOffsetT(0) + if t.TimestampsNs != nil { + timestampsNsLength := len(t.TimestampsNs) + NonEquidistantStartTimestampsNsVector(builder, timestampsNsLength) + for j := timestampsNsLength - 1; j >= 0; j-- { + builder.PrependUint64(t.TimestampsNs[j]) + } + timestampsNsOffset = builder.EndVector(timestampsNsLength) + } + arrayOffset := t.Array.Pack(builder) + + NonEquidistantStart(builder) + NonEquidistantAddName(builder, nameOffset) + NonEquidistantAddTags(builder, tagsOffset) + NonEquidistantAddTimestampsNs(builder, timestampsNsOffset) + if t.Array != nil { + NonEquidistantAddArrayType(builder, t.Array.Type) + } + NonEquidistantAddArray(builder, arrayOffset) + return NonEquidistantEnd(builder) +} + +func (rcv *NonEquidistant) UnPackTo(t *NonEquidistantT) { + t.Name = string(rcv.Name()) + tagsLength := rcv.TagsLength() + t.Tags = make([]*TagT, tagsLength) + for j := 0; j < tagsLength; j++ { + x := Tag{} + rcv.Tags(&x, j) + t.Tags[j] = x.UnPack() + } + timestampsNsLength := rcv.TimestampsNsLength() + t.TimestampsNs = make([]uint64, timestampsNsLength) + for j := 0; j < timestampsNsLength; j++ { + t.TimestampsNs[j] = rcv.TimestampsNs(j) + } + arrayTable := flatbuffers.Table{} + if rcv.Array(&arrayTable) { + t.Array = rcv.ArrayType().UnPack(arrayTable) + } +} + +func (rcv *NonEquidistant) UnPack() *NonEquidistantT { + if rcv == nil { return nil } + t := &NonEquidistantT{} + rcv.UnPackTo(t) + return t +} + +type NonEquidistant struct { + _tab flatbuffers.Table +} + +func GetRootAsNonEquidistant(buf []byte, offset flatbuffers.UOffsetT) *NonEquidistant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &NonEquidistant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsNonEquidistant(buf []byte, offset flatbuffers.UOffsetT) *NonEquidistant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &NonEquidistant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *NonEquidistant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *NonEquidistant) Table() flatbuffers.Table { + return rcv._tab +} + +/// unique name of the non-equidistant data +func (rcv *NonEquidistant) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unique name of the non-equidistant data +func NonEquidistantKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { + obj1 := &NonEquidistant{} + obj2 := &NonEquidistant{} + obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + return string(obj1.Name()) < string(obj2.Name()) +} + +func (rcv *NonEquidistant) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { + span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + start := flatbuffers.UOffsetT(0) + bKey := []byte(key) + for span != 0 { + middle := span / 2 + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + obj := &NonEquidistant{} + obj.Init(buf, tableOffset) + comp := bytes.Compare(obj.Name(), bKey) + if comp > 0 { + span = middle + } else if comp < 0 { + middle += 1 + start += middle + span -= middle + } else { + rcv.Init(buf, tableOffset) + return true + } + } + return false +} + +/// array of tags for meta data +func (rcv *NonEquidistant) Tags(obj *Tag, 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 *NonEquidistant) TagsByKey(obj *Tag, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *NonEquidistant) TagsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of tags for meta data +/// array of unix epoch time (since 1.1.1970) in [ns] +func (rcv *NonEquidistant) TimestampsNs(j int) uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *NonEquidistant) TimestampsNsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// array of unix epoch time (since 1.1.1970) in [ns] +func (rcv *NonEquidistant) MutateTimestampsNs(j int, n uint64) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) + } + return false +} + +func (rcv *NonEquidistant) ArrayType() Array { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return Array(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *NonEquidistant) MutateArrayType(n Array) bool { + return rcv._tab.MutateByteSlot(10, byte(n)) +} + +/// array of sampled values at the corresponding timestamps +func (rcv *NonEquidistant) Array(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +/// array of sampled values at the corresponding timestamps +func NonEquidistantStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func NonEquidistantAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func NonEquidistantAddTags(builder *flatbuffers.Builder, tags flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(tags), 0) +} +func NonEquidistantStartTagsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func NonEquidistantAddTimestampsNs(builder *flatbuffers.Builder, timestampsNs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(timestampsNs), 0) +} +func NonEquidistantStartTimestampsNsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func NonEquidistantAddArrayType(builder *flatbuffers.Builder, arrayType Array) { + builder.PrependByteSlot(3, byte(arrayType), 0) +} +func NonEquidistantAddArray(builder *flatbuffers.Builder, array flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(array), 0) +} +func NonEquidistantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/daq/Tag.go b/pkg/fbs/comm/datalayer/daq/Tag.go new file mode 100644 index 0000000..fae4053 --- /dev/null +++ b/pkg/fbs/comm/datalayer/daq/Tag.go @@ -0,0 +1,134 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package daq + +import ( + "bytes" + flatbuffers "github.com/google/flatbuffers/go" +) + +/// tag as key-value-pair for meta data +type TagT struct { + Key string `json:"key"` + Value string `json:"value"` +} + +func (t *TagT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + keyOffset := flatbuffers.UOffsetT(0) + if t.Key != "" { + keyOffset = builder.CreateString(t.Key) + } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != "" { + valueOffset = builder.CreateString(t.Value) + } + TagStart(builder) + TagAddKey(builder, keyOffset) + TagAddValue(builder, valueOffset) + return TagEnd(builder) +} + +func (rcv *Tag) UnPackTo(t *TagT) { + t.Key = string(rcv.Key()) + t.Value = string(rcv.Value()) +} + +func (rcv *Tag) UnPack() *TagT { + if rcv == nil { return nil } + t := &TagT{} + rcv.UnPackTo(t) + return t +} + +type Tag struct { + _tab flatbuffers.Table +} + +func GetRootAsTag(buf []byte, offset flatbuffers.UOffsetT) *Tag { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Tag{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTag(buf []byte, offset flatbuffers.UOffsetT) *Tag { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Tag{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Tag) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Tag) Table() flatbuffers.Table { + return rcv._tab +} + +/// unique key of the tag +func (rcv *Tag) Key() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unique key of the tag +func TagKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { + obj1 := &Tag{} + obj2 := &Tag{} + obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + return string(obj1.Key()) < string(obj2.Key()) +} + +func (rcv *Tag) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { + span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + start := flatbuffers.UOffsetT(0) + bKey := []byte(key) + for span != 0 { + middle := span / 2 + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + obj := &Tag{} + obj.Init(buf, tableOffset) + comp := bytes.Compare(obj.Key(), bKey) + if comp > 0 { + span = middle + } else if comp < 0 { + middle += 1 + start += middle + span -= middle + } else { + rcv.Init(buf, tableOffset) + return true + } + } + return false +} + +/// value of the tag +func (rcv *Tag) Value() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// value of the tag +func TagStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func TagAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(key), 0) +} +func TagAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(value), 0) +} +func TagEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/drive/device/ExportParFile.go b/pkg/fbs/comm/drive/device/ExportParFile.go new file mode 100644 index 0000000..965c309 --- /dev/null +++ b/pkg/fbs/comm/drive/device/ExportParFile.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package device + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ExportParFileT struct { + FileName string `json:"fileName"` + BackupType ParametersType `json:"backupType"` +} + +func (t *ExportParFileT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + fileNameOffset := flatbuffers.UOffsetT(0) + if t.FileName != "" { + fileNameOffset = builder.CreateString(t.FileName) + } + ExportParFileStart(builder) + ExportParFileAddFileName(builder, fileNameOffset) + ExportParFileAddBackupType(builder, t.BackupType) + return ExportParFileEnd(builder) +} + +func (rcv *ExportParFile) UnPackTo(t *ExportParFileT) { + t.FileName = string(rcv.FileName()) + t.BackupType = rcv.BackupType() +} + +func (rcv *ExportParFile) UnPack() *ExportParFileT { + if rcv == nil { return nil } + t := &ExportParFileT{} + rcv.UnPackTo(t) + return t +} + +type ExportParFile struct { + _tab flatbuffers.Table +} + +func GetRootAsExportParFile(buf []byte, offset flatbuffers.UOffsetT) *ExportParFile { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ExportParFile{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsExportParFile(buf []byte, offset flatbuffers.UOffsetT) *ExportParFile { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ExportParFile{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ExportParFile) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ExportParFile) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ExportParFile) FileName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *ExportParFile) BackupType() ParametersType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return ParametersType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ExportParFile) MutateBackupType(n ParametersType) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func ExportParFileStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func ExportParFileAddFileName(builder *flatbuffers.Builder, fileName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(fileName), 0) +} +func ExportParFileAddBackupType(builder *flatbuffers.Builder, backupType ParametersType) { + builder.PrependInt8Slot(1, int8(backupType), 0) +} +func ExportParFileEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/drive/device/ImportParFile.go b/pkg/fbs/comm/drive/device/ImportParFile.go new file mode 100644 index 0000000..2ccce90 --- /dev/null +++ b/pkg/fbs/comm/drive/device/ImportParFile.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package device + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ImportParFileT struct { + FileName string `json:"fileName"` + SetIndex int8 `json:"setIndex"` +} + +func (t *ImportParFileT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + fileNameOffset := flatbuffers.UOffsetT(0) + if t.FileName != "" { + fileNameOffset = builder.CreateString(t.FileName) + } + ImportParFileStart(builder) + ImportParFileAddFileName(builder, fileNameOffset) + ImportParFileAddSetIndex(builder, t.SetIndex) + return ImportParFileEnd(builder) +} + +func (rcv *ImportParFile) UnPackTo(t *ImportParFileT) { + t.FileName = string(rcv.FileName()) + t.SetIndex = rcv.SetIndex() +} + +func (rcv *ImportParFile) UnPack() *ImportParFileT { + if rcv == nil { return nil } + t := &ImportParFileT{} + rcv.UnPackTo(t) + return t +} + +type ImportParFile struct { + _tab flatbuffers.Table +} + +func GetRootAsImportParFile(buf []byte, offset flatbuffers.UOffsetT) *ImportParFile { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ImportParFile{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsImportParFile(buf []byte, offset flatbuffers.UOffsetT) *ImportParFile { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ImportParFile{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ImportParFile) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ImportParFile) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ImportParFile) FileName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *ImportParFile) SetIndex() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ImportParFile) MutateSetIndex(n int8) bool { + return rcv._tab.MutateInt8Slot(6, n) +} + +func ImportParFileStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func ImportParFileAddFileName(builder *flatbuffers.Builder, fileName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(fileName), 0) +} +func ImportParFileAddSetIndex(builder *flatbuffers.Builder, setIndex int8) { + builder.PrependInt8Slot(1, setIndex, 0) +} +func ImportParFileEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/drive/device/ParametersType.go b/pkg/fbs/comm/drive/device/ParametersType.go new file mode 100644 index 0000000..d9b200e --- /dev/null +++ b/pkg/fbs/comm/drive/device/ParametersType.go @@ -0,0 +1,29 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package device + +import "strconv" + +type ParametersType int8 + +const ( + ParametersTypeAll ParametersType = 0 + ParametersTypeBackup ParametersType = 1 +) + +var EnumNamesParametersType = map[ParametersType]string{ + ParametersTypeAll: "All", + ParametersTypeBackup: "Backup", +} + +var EnumValuesParametersType = map[string]ParametersType{ + "All": ParametersTypeAll, + "Backup": ParametersTypeBackup, +} + +func (v ParametersType) String() string { + if s, ok := EnumNamesParametersType[v]; ok { + return s + } + return "ParametersType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfo.go new file mode 100644 index 0000000..efbe547 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfo.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node delivers master sync unit configuration information. +type MsuConfigInfoT struct { + Request *MsuConfigInfoRequestT `json:"request"` + Response *MsuConfigInfoResponseT `json:"response"` +} + +func (t *MsuConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MsuConfigInfoStart(builder) + MsuConfigInfoAddRequest(builder, requestOffset) + MsuConfigInfoAddResponse(builder, responseOffset) + return MsuConfigInfoEnd(builder) +} + +func (rcv *MsuConfigInfo) UnPackTo(t *MsuConfigInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MsuConfigInfo) UnPack() *MsuConfigInfoT { + if rcv == nil { return nil } + t := &MsuConfigInfoT{} + rcv.UnPackTo(t) + return t +} + +type MsuConfigInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuConfigInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuConfigInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuConfigInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuConfigInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MsuConfigInfo) Request(obj *MsuConfigInfoRequest) *MsuConfigInfoRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuConfigInfoRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MsuConfigInfo) Response(obj *MsuConfigInfoResponse) *MsuConfigInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuConfigInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MsuConfigInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuConfigInfoAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func MsuConfigInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func MsuConfigInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoRequest.go new file mode 100644 index 0000000..0acdc59 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoRequest.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master syc unit configuration request +type MsuConfigInfoRequestT struct { + Id uint16 `json:"id"` +} + +func (t *MsuConfigInfoRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MsuConfigInfoRequestStart(builder) + MsuConfigInfoRequestAddId(builder, t.Id) + return MsuConfigInfoRequestEnd(builder) +} + +func (rcv *MsuConfigInfoRequest) UnPackTo(t *MsuConfigInfoRequestT) { + t.Id = rcv.Id() +} + +func (rcv *MsuConfigInfoRequest) UnPack() *MsuConfigInfoRequestT { + if rcv == nil { return nil } + t := &MsuConfigInfoRequestT{} + rcv.UnPackTo(t) + return t +} + +type MsuConfigInfoRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuConfigInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuConfigInfoRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuConfigInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuConfigInfoRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuConfigInfoRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuConfigInfoRequest) Table() flatbuffers.Table { + return rcv._tab +} + +///Msu Id +func (rcv *MsuConfigInfoRequest) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Msu Id +func (rcv *MsuConfigInfoRequest) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func MsuConfigInfoRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuConfigInfoRequestAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuConfigInfoRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoResponse.go new file mode 100644 index 0000000..fb64759 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuConfigInfoResponse.go @@ -0,0 +1,225 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master syc unit configuration response +type MsuConfigInfoResponseT struct { + Id uint16 `json:"id"` + MsuName string `json:"msuName"` + ProcessDataIn *EthercatMemoryInfoT `json:"processDataIn"` + ProcessDataOut *EthercatMemoryInfoT `json:"processDataOut"` + WkcStateDiagOffsIn uint16 `json:"wkcStateDiagOffsIn"` + WkcStateDiagOffsOut uint16 `json:"wkcStateDiagOffsOut"` + WkcValidOffsetIn uint32 `json:"wkcValidOffsetIn"` + WkcValidOffsetOut uint32 `json:"wkcValidOffsetOut"` +} + +func (t *MsuConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + msuNameOffset := flatbuffers.UOffsetT(0) + if t.MsuName != "" { + msuNameOffset = builder.CreateString(t.MsuName) + } + MsuConfigInfoResponseStart(builder) + MsuConfigInfoResponseAddId(builder, t.Id) + MsuConfigInfoResponseAddMsuName(builder, msuNameOffset) + processDataInOffset := t.ProcessDataIn.Pack(builder) + MsuConfigInfoResponseAddProcessDataIn(builder, processDataInOffset) + processDataOutOffset := t.ProcessDataOut.Pack(builder) + MsuConfigInfoResponseAddProcessDataOut(builder, processDataOutOffset) + MsuConfigInfoResponseAddWkcStateDiagOffsIn(builder, t.WkcStateDiagOffsIn) + MsuConfigInfoResponseAddWkcStateDiagOffsOut(builder, t.WkcStateDiagOffsOut) + MsuConfigInfoResponseAddWkcValidOffsetIn(builder, t.WkcValidOffsetIn) + MsuConfigInfoResponseAddWkcValidOffsetOut(builder, t.WkcValidOffsetOut) + return MsuConfigInfoResponseEnd(builder) +} + +func (rcv *MsuConfigInfoResponse) UnPackTo(t *MsuConfigInfoResponseT) { + t.Id = rcv.Id() + t.MsuName = string(rcv.MsuName()) + t.ProcessDataIn = rcv.ProcessDataIn(nil).UnPack() + t.ProcessDataOut = rcv.ProcessDataOut(nil).UnPack() + t.WkcStateDiagOffsIn = rcv.WkcStateDiagOffsIn() + t.WkcStateDiagOffsOut = rcv.WkcStateDiagOffsOut() + t.WkcValidOffsetIn = rcv.WkcValidOffsetIn() + t.WkcValidOffsetOut = rcv.WkcValidOffsetOut() +} + +func (rcv *MsuConfigInfoResponse) UnPack() *MsuConfigInfoResponseT { + if rcv == nil { return nil } + t := &MsuConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type MsuConfigInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuConfigInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuConfigInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuConfigInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuConfigInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Msu Id +func (rcv *MsuConfigInfoResponse) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Msu Id +func (rcv *MsuConfigInfoResponse) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +///configured Msu name +func (rcv *MsuConfigInfoResponse) MsuName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///configured Msu name +///Memory information of input process data. +func (rcv *MsuConfigInfoResponse) ProcessDataIn(obj *EthercatMemoryInfo) *EthercatMemoryInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(EthercatMemoryInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Memory information of input process data. +///Memory information of output process data. +func (rcv *MsuConfigInfoResponse) ProcessDataOut(obj *EthercatMemoryInfo) *EthercatMemoryInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(EthercatMemoryInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Memory information of output process data. +///(internal - do not use) +func (rcv *MsuConfigInfoResponse) WkcStateDiagOffsIn() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///(internal - do not use) +func (rcv *MsuConfigInfoResponse) MutateWkcStateDiagOffsIn(n uint16) bool { + return rcv._tab.MutateUint16Slot(12, n) +} + +///(internal - do not use) +func (rcv *MsuConfigInfoResponse) WkcStateDiagOffsOut() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///(internal - do not use) +func (rcv *MsuConfigInfoResponse) MutateWkcStateDiagOffsOut(n uint16) bool { + return rcv._tab.MutateUint16Slot(14, n) +} + +///Wkc valid offset for inputs in data layer rt input image. +func (rcv *MsuConfigInfoResponse) WkcValidOffsetIn() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Wkc valid offset for inputs in data layer rt input image. +func (rcv *MsuConfigInfoResponse) MutateWkcValidOffsetIn(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +///Wkc valid offset for outputs in data layer rt input image. +func (rcv *MsuConfigInfoResponse) WkcValidOffsetOut() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Wkc valid offset for outputs in data layer rt input image. +func (rcv *MsuConfigInfoResponse) MutateWkcValidOffsetOut(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + +func MsuConfigInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(8) +} +func MsuConfigInfoResponseAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuConfigInfoResponseAddMsuName(builder *flatbuffers.Builder, msuName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(msuName), 0) +} +func MsuConfigInfoResponseAddProcessDataIn(builder *flatbuffers.Builder, processDataIn flatbuffers.UOffsetT) { + builder.PrependStructSlot(2, flatbuffers.UOffsetT(processDataIn), 0) +} +func MsuConfigInfoResponseAddProcessDataOut(builder *flatbuffers.Builder, processDataOut flatbuffers.UOffsetT) { + builder.PrependStructSlot(3, flatbuffers.UOffsetT(processDataOut), 0) +} +func MsuConfigInfoResponseAddWkcStateDiagOffsIn(builder *flatbuffers.Builder, wkcStateDiagOffsIn uint16) { + builder.PrependUint16Slot(4, wkcStateDiagOffsIn, 0) +} +func MsuConfigInfoResponseAddWkcStateDiagOffsOut(builder *flatbuffers.Builder, wkcStateDiagOffsOut uint16) { + builder.PrependUint16Slot(5, wkcStateDiagOffsOut, 0) +} +func MsuConfigInfoResponseAddWkcValidOffsetIn(builder *flatbuffers.Builder, wkcValidOffsetIn uint32) { + builder.PrependUint32Slot(6, wkcValidOffsetIn, 0) +} +func MsuConfigInfoResponseAddWkcValidOffsetOut(builder *flatbuffers.Builder, wkcValidOffsetOut uint32) { + builder.PrependUint32Slot(7, wkcValidOffsetOut, 0) +} +func MsuConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuIdList.go b/pkg/fbs/comm/ethercat/master/fbs/MsuIdList.go new file mode 100644 index 0000000..b0dd0c0 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuIdList.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node delivers id numbers of master sync units. +type MsuIdListT struct { + Response *MsuIdListResponseT `json:"response"` +} + +func (t *MsuIdListT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + MsuIdListStart(builder) + MsuIdListAddResponse(builder, responseOffset) + return MsuIdListEnd(builder) +} + +func (rcv *MsuIdList) UnPackTo(t *MsuIdListT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MsuIdList) UnPack() *MsuIdListT { + if rcv == nil { return nil } + t := &MsuIdListT{} + rcv.UnPackTo(t) + return t +} + +type MsuIdList struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuIdList(buf []byte, offset flatbuffers.UOffsetT) *MsuIdList { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuIdList{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuIdList(buf []byte, offset flatbuffers.UOffsetT) *MsuIdList { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuIdList{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuIdList) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuIdList) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MsuIdList) Response(obj *MsuIdListResponse) *MsuIdListResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuIdListResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MsuIdListStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuIdListAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func MsuIdListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuIdListResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MsuIdListResponse.go new file mode 100644 index 0000000..a3453a4 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuIdListResponse.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master sync unit id list response. +type MsuIdListResponseT struct { + IdList []uint16 `json:"idList"` +} + +func (t *MsuIdListResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + idListOffset := flatbuffers.UOffsetT(0) + if t.IdList != nil { + idListLength := len(t.IdList) + MsuIdListResponseStartIdListVector(builder, idListLength) + for j := idListLength - 1; j >= 0; j-- { + builder.PrependUint16(t.IdList[j]) + } + idListOffset = builder.EndVector(idListLength) + } + MsuIdListResponseStart(builder) + MsuIdListResponseAddIdList(builder, idListOffset) + return MsuIdListResponseEnd(builder) +} + +func (rcv *MsuIdListResponse) UnPackTo(t *MsuIdListResponseT) { + idListLength := rcv.IdListLength() + t.IdList = make([]uint16, idListLength) + for j := 0; j < idListLength; j++ { + t.IdList[j] = rcv.IdList(j) + } +} + +func (rcv *MsuIdListResponse) UnPack() *MsuIdListResponseT { + if rcv == nil { return nil } + t := &MsuIdListResponseT{} + rcv.UnPackTo(t) + return t +} + +type MsuIdListResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuIdListResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuIdListResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuIdListResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuIdListResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuIdListResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuIdListResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuIdListResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuIdListResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Master sync unit id numbers. +func (rcv *MsuIdListResponse) IdList(j int) uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2)) + } + return 0 +} + +func (rcv *MsuIdListResponse) IdListLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +///Master sync unit id numbers. +func (rcv *MsuIdListResponse) MutateIdList(j int, n uint16) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n) + } + return false +} + +func MsuIdListResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuIdListResponseAddIdList(builder *flatbuffers.Builder, idList flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(idList), 0) +} +func MsuIdListResponseStartIdListVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(2, numElems, 2) +} +func MsuIdListResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuIdToName.go b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToName.go new file mode 100644 index 0000000..b37ac0c --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToName.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Thsi node converts master sync unit id to name. +type MsuIdToNameT struct { + Request *MsuIdToNameRequestT `json:"request"` + Response *MsuIdToNameResponseT `json:"response"` +} + +func (t *MsuIdToNameT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MsuIdToNameStart(builder) + MsuIdToNameAddRequest(builder, requestOffset) + MsuIdToNameAddResponse(builder, responseOffset) + return MsuIdToNameEnd(builder) +} + +func (rcv *MsuIdToName) UnPackTo(t *MsuIdToNameT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MsuIdToName) UnPack() *MsuIdToNameT { + if rcv == nil { return nil } + t := &MsuIdToNameT{} + rcv.UnPackTo(t) + return t +} + +type MsuIdToName struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuIdToName(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToName { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuIdToName{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuIdToName(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToName { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuIdToName{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuIdToName) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuIdToName) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MsuIdToName) Request(obj *MsuIdToNameRequest) *MsuIdToNameRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuIdToNameRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MsuIdToName) Response(obj *MsuIdToNameResponse) *MsuIdToNameResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuIdToNameResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MsuIdToNameStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuIdToNameAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func MsuIdToNameAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func MsuIdToNameEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameRequest.go new file mode 100644 index 0000000..41b9700 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameRequest.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master sync unit id to name request. +type MsuIdToNameRequestT struct { + Id uint16 `json:"id"` +} + +func (t *MsuIdToNameRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MsuIdToNameRequestStart(builder) + MsuIdToNameRequestAddId(builder, t.Id) + return MsuIdToNameRequestEnd(builder) +} + +func (rcv *MsuIdToNameRequest) UnPackTo(t *MsuIdToNameRequestT) { + t.Id = rcv.Id() +} + +func (rcv *MsuIdToNameRequest) UnPack() *MsuIdToNameRequestT { + if rcv == nil { return nil } + t := &MsuIdToNameRequestT{} + rcv.UnPackTo(t) + return t +} + +type MsuIdToNameRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuIdToNameRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToNameRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuIdToNameRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuIdToNameRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToNameRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuIdToNameRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuIdToNameRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuIdToNameRequest) Table() flatbuffers.Table { + return rcv._tab +} + +///Master sync unit id. +func (rcv *MsuIdToNameRequest) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Master sync unit id. +func (rcv *MsuIdToNameRequest) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func MsuIdToNameRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuIdToNameRequestAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuIdToNameRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameResponse.go new file mode 100644 index 0000000..d71cba9 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuIdToNameResponse.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master sync unit id to name response. +type MsuIdToNameResponseT struct { + Id uint16 `json:"id"` + Name string `json:"name"` +} + +func (t *MsuIdToNameResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + MsuIdToNameResponseStart(builder) + MsuIdToNameResponseAddId(builder, t.Id) + MsuIdToNameResponseAddName(builder, nameOffset) + return MsuIdToNameResponseEnd(builder) +} + +func (rcv *MsuIdToNameResponse) UnPackTo(t *MsuIdToNameResponseT) { + t.Id = rcv.Id() + t.Name = string(rcv.Name()) +} + +func (rcv *MsuIdToNameResponse) UnPack() *MsuIdToNameResponseT { + if rcv == nil { return nil } + t := &MsuIdToNameResponseT{} + rcv.UnPackTo(t) + return t +} + +type MsuIdToNameResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuIdToNameResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToNameResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuIdToNameResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuIdToNameResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuIdToNameResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuIdToNameResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuIdToNameResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuIdToNameResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Master sync unit id. +func (rcv *MsuIdToNameResponse) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Master sync unit id. +func (rcv *MsuIdToNameResponse) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +///Master sync unit name. +func (rcv *MsuIdToNameResponse) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///Master sync unit name. +func MsuIdToNameResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuIdToNameResponseAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuIdToNameResponseAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0) +} +func MsuIdToNameResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuNameToId.go b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToId.go new file mode 100644 index 0000000..bb0c48f --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToId.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node converts master sync unit name to id. +type MsuNameToIdT struct { + Request *MsuNameToIdRequestT `json:"request"` + Response *MsuNameToIdResponseT `json:"response"` +} + +func (t *MsuNameToIdT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MsuNameToIdStart(builder) + MsuNameToIdAddRequest(builder, requestOffset) + MsuNameToIdAddResponse(builder, responseOffset) + return MsuNameToIdEnd(builder) +} + +func (rcv *MsuNameToId) UnPackTo(t *MsuNameToIdT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MsuNameToId) UnPack() *MsuNameToIdT { + if rcv == nil { return nil } + t := &MsuNameToIdT{} + rcv.UnPackTo(t) + return t +} + +type MsuNameToId struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuNameToId(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToId { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuNameToId{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuNameToId(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToId { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuNameToId{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuNameToId) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuNameToId) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MsuNameToId) Request(obj *MsuNameToIdRequest) *MsuNameToIdRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuNameToIdRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MsuNameToId) Response(obj *MsuNameToIdResponse) *MsuNameToIdResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuNameToIdResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MsuNameToIdStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuNameToIdAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func MsuNameToIdAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func MsuNameToIdEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdRequest.go new file mode 100644 index 0000000..85d80fc --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdRequest.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master sync unit name to id request. +type MsuNameToIdRequestT struct { + Name string `json:"name"` +} + +func (t *MsuNameToIdRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + MsuNameToIdRequestStart(builder) + MsuNameToIdRequestAddName(builder, nameOffset) + return MsuNameToIdRequestEnd(builder) +} + +func (rcv *MsuNameToIdRequest) UnPackTo(t *MsuNameToIdRequestT) { + t.Name = string(rcv.Name()) +} + +func (rcv *MsuNameToIdRequest) UnPack() *MsuNameToIdRequestT { + if rcv == nil { return nil } + t := &MsuNameToIdRequestT{} + rcv.UnPackTo(t) + return t +} + +type MsuNameToIdRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuNameToIdRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToIdRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuNameToIdRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuNameToIdRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToIdRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuNameToIdRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuNameToIdRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuNameToIdRequest) Table() flatbuffers.Table { + return rcv._tab +} + +///Master sync unit name. +func (rcv *MsuNameToIdRequest) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///Master sync unit name. +func MsuNameToIdRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuNameToIdRequestAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func MsuNameToIdRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdResponse.go new file mode 100644 index 0000000..6c99efb --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuNameToIdResponse.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master sync unit name to id response. +type MsuNameToIdResponseT struct { + Id uint16 `json:"id"` + Name string `json:"name"` +} + +func (t *MsuNameToIdResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + MsuNameToIdResponseStart(builder) + MsuNameToIdResponseAddId(builder, t.Id) + MsuNameToIdResponseAddName(builder, nameOffset) + return MsuNameToIdResponseEnd(builder) +} + +func (rcv *MsuNameToIdResponse) UnPackTo(t *MsuNameToIdResponseT) { + t.Id = rcv.Id() + t.Name = string(rcv.Name()) +} + +func (rcv *MsuNameToIdResponse) UnPack() *MsuNameToIdResponseT { + if rcv == nil { return nil } + t := &MsuNameToIdResponseT{} + rcv.UnPackTo(t) + return t +} + +type MsuNameToIdResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuNameToIdResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToIdResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuNameToIdResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuNameToIdResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuNameToIdResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuNameToIdResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuNameToIdResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuNameToIdResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Master sync unit id. +func (rcv *MsuNameToIdResponse) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Master sync unit id. +func (rcv *MsuNameToIdResponse) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +///Master sync unit name. +func (rcv *MsuNameToIdResponse) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///Master sync unit name. +func MsuNameToIdResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuNameToIdResponseAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuNameToIdResponseAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0) +} +func MsuNameToIdResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfo.go b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfo.go new file mode 100644 index 0000000..95a29de --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfo.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node delivers master sync unit online information. +type MsuOnlineInfoT struct { + Request *MsuOnlineInfoRequestT `json:"request"` + Response *MsuOnlineInfoResponseT `json:"response"` +} + +func (t *MsuOnlineInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + MsuOnlineInfoStart(builder) + MsuOnlineInfoAddRequest(builder, requestOffset) + MsuOnlineInfoAddResponse(builder, responseOffset) + return MsuOnlineInfoEnd(builder) +} + +func (rcv *MsuOnlineInfo) UnPackTo(t *MsuOnlineInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *MsuOnlineInfo) UnPack() *MsuOnlineInfoT { + if rcv == nil { return nil } + t := &MsuOnlineInfoT{} + rcv.UnPackTo(t) + return t +} + +type MsuOnlineInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuOnlineInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuOnlineInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuOnlineInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuOnlineInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *MsuOnlineInfo) Request(obj *MsuOnlineInfoRequest) *MsuOnlineInfoRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuOnlineInfoRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *MsuOnlineInfo) Response(obj *MsuOnlineInfoResponse) *MsuOnlineInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(MsuOnlineInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func MsuOnlineInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsuOnlineInfoAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func MsuOnlineInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func MsuOnlineInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoRequest.go b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoRequest.go new file mode 100644 index 0000000..a6e24c6 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoRequest.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master syc unit online request +type MsuOnlineInfoRequestT struct { + Id uint16 `json:"id"` +} + +func (t *MsuOnlineInfoRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MsuOnlineInfoRequestStart(builder) + MsuOnlineInfoRequestAddId(builder, t.Id) + return MsuOnlineInfoRequestEnd(builder) +} + +func (rcv *MsuOnlineInfoRequest) UnPackTo(t *MsuOnlineInfoRequestT) { + t.Id = rcv.Id() +} + +func (rcv *MsuOnlineInfoRequest) UnPack() *MsuOnlineInfoRequestT { + if rcv == nil { return nil } + t := &MsuOnlineInfoRequestT{} + rcv.UnPackTo(t) + return t +} + +type MsuOnlineInfoRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuOnlineInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuOnlineInfoRequest{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuOnlineInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfoRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuOnlineInfoRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuOnlineInfoRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuOnlineInfoRequest) Table() flatbuffers.Table { + return rcv._tab +} + +///Msu Id +func (rcv *MsuOnlineInfoRequest) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Msu Id +func (rcv *MsuOnlineInfoRequest) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func MsuOnlineInfoRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func MsuOnlineInfoRequestAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuOnlineInfoRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoResponse.go new file mode 100644 index 0000000..d5a45b1 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/MsuOnlineInfoResponse.go @@ -0,0 +1,245 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Master syc unit online response +type MsuOnlineInfoResponseT struct { + Id uint16 `json:"id"` + ProcessDataIn *EthercatMemoryInfoT `json:"processDataIn"` + ProcessDataOut *EthercatMemoryInfoT `json:"processDataOut"` + WkcStateDiagOffsIn uint16 `json:"wkcStateDiagOffsIn"` + WkcStateDiagOffsOut uint16 `json:"wkcStateDiagOffsOut"` + WkcValidOffsetIn uint32 `json:"wkcValidOffsetIn"` + WkcValidOffsetOut uint32 `json:"wkcValidOffsetOut"` + WkcValidIn bool `json:"wkcValidIn"` + WkcValidOut bool `json:"wkcValidOut"` +} + +func (t *MsuOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + MsuOnlineInfoResponseStart(builder) + MsuOnlineInfoResponseAddId(builder, t.Id) + processDataInOffset := t.ProcessDataIn.Pack(builder) + MsuOnlineInfoResponseAddProcessDataIn(builder, processDataInOffset) + processDataOutOffset := t.ProcessDataOut.Pack(builder) + MsuOnlineInfoResponseAddProcessDataOut(builder, processDataOutOffset) + MsuOnlineInfoResponseAddWkcStateDiagOffsIn(builder, t.WkcStateDiagOffsIn) + MsuOnlineInfoResponseAddWkcStateDiagOffsOut(builder, t.WkcStateDiagOffsOut) + MsuOnlineInfoResponseAddWkcValidOffsetIn(builder, t.WkcValidOffsetIn) + MsuOnlineInfoResponseAddWkcValidOffsetOut(builder, t.WkcValidOffsetOut) + MsuOnlineInfoResponseAddWkcValidIn(builder, t.WkcValidIn) + MsuOnlineInfoResponseAddWkcValidOut(builder, t.WkcValidOut) + return MsuOnlineInfoResponseEnd(builder) +} + +func (rcv *MsuOnlineInfoResponse) UnPackTo(t *MsuOnlineInfoResponseT) { + t.Id = rcv.Id() + t.ProcessDataIn = rcv.ProcessDataIn(nil).UnPack() + t.ProcessDataOut = rcv.ProcessDataOut(nil).UnPack() + t.WkcStateDiagOffsIn = rcv.WkcStateDiagOffsIn() + t.WkcStateDiagOffsOut = rcv.WkcStateDiagOffsOut() + t.WkcValidOffsetIn = rcv.WkcValidOffsetIn() + t.WkcValidOffsetOut = rcv.WkcValidOffsetOut() + t.WkcValidIn = rcv.WkcValidIn() + t.WkcValidOut = rcv.WkcValidOut() +} + +func (rcv *MsuOnlineInfoResponse) UnPack() *MsuOnlineInfoResponseT { + if rcv == nil { return nil } + t := &MsuOnlineInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type MsuOnlineInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsMsuOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &MsuOnlineInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsMsuOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *MsuOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &MsuOnlineInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *MsuOnlineInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *MsuOnlineInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Msu Id +func (rcv *MsuOnlineInfoResponse) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///Msu Id +func (rcv *MsuOnlineInfoResponse) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +///Memory information of input process data. +func (rcv *MsuOnlineInfoResponse) ProcessDataIn(obj *EthercatMemoryInfo) *EthercatMemoryInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(EthercatMemoryInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Memory information of input process data. +///Memory information of output process data. +func (rcv *MsuOnlineInfoResponse) ProcessDataOut(obj *EthercatMemoryInfo) *EthercatMemoryInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := o + rcv._tab.Pos + if obj == nil { + obj = new(EthercatMemoryInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Memory information of output process data. +///(internal - do not use) +func (rcv *MsuOnlineInfoResponse) WkcStateDiagOffsIn() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///(internal - do not use) +func (rcv *MsuOnlineInfoResponse) MutateWkcStateDiagOffsIn(n uint16) bool { + return rcv._tab.MutateUint16Slot(10, n) +} + +///(internal - do not use) +func (rcv *MsuOnlineInfoResponse) WkcStateDiagOffsOut() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +///(internal - do not use) +func (rcv *MsuOnlineInfoResponse) MutateWkcStateDiagOffsOut(n uint16) bool { + return rcv._tab.MutateUint16Slot(12, n) +} + +///Wkc valid offset for inputs in data layer rt input image. +func (rcv *MsuOnlineInfoResponse) WkcValidOffsetIn() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Wkc valid offset for inputs in data layer rt input image. +func (rcv *MsuOnlineInfoResponse) MutateWkcValidOffsetIn(n uint32) bool { + return rcv._tab.MutateUint32Slot(14, n) +} + +///Wkc valid offset for outputs in data layer rt input image. +func (rcv *MsuOnlineInfoResponse) WkcValidOffsetOut() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Wkc valid offset for outputs in data layer rt input image. +func (rcv *MsuOnlineInfoResponse) MutateWkcValidOffsetOut(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +/// Indication if input process data are valid. +func (rcv *MsuOnlineInfoResponse) WkcValidIn() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indication if input process data are valid. +func (rcv *MsuOnlineInfoResponse) MutateWkcValidIn(n bool) bool { + return rcv._tab.MutateBoolSlot(18, n) +} + +/// Indication if output process data are valid. +func (rcv *MsuOnlineInfoResponse) WkcValidOut() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indication if output process data are valid. +func (rcv *MsuOnlineInfoResponse) MutateWkcValidOut(n bool) bool { + return rcv._tab.MutateBoolSlot(20, n) +} + +func MsuOnlineInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(9) +} +func MsuOnlineInfoResponseAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(0, id, 0) +} +func MsuOnlineInfoResponseAddProcessDataIn(builder *flatbuffers.Builder, processDataIn flatbuffers.UOffsetT) { + builder.PrependStructSlot(1, flatbuffers.UOffsetT(processDataIn), 0) +} +func MsuOnlineInfoResponseAddProcessDataOut(builder *flatbuffers.Builder, processDataOut flatbuffers.UOffsetT) { + builder.PrependStructSlot(2, flatbuffers.UOffsetT(processDataOut), 0) +} +func MsuOnlineInfoResponseAddWkcStateDiagOffsIn(builder *flatbuffers.Builder, wkcStateDiagOffsIn uint16) { + builder.PrependUint16Slot(3, wkcStateDiagOffsIn, 0) +} +func MsuOnlineInfoResponseAddWkcStateDiagOffsOut(builder *flatbuffers.Builder, wkcStateDiagOffsOut uint16) { + builder.PrependUint16Slot(4, wkcStateDiagOffsOut, 0) +} +func MsuOnlineInfoResponseAddWkcValidOffsetIn(builder *flatbuffers.Builder, wkcValidOffsetIn uint32) { + builder.PrependUint32Slot(5, wkcValidOffsetIn, 0) +} +func MsuOnlineInfoResponseAddWkcValidOffsetOut(builder *flatbuffers.Builder, wkcValidOffsetOut uint32) { + builder.PrependUint32Slot(6, wkcValidOffsetOut, 0) +} +func MsuOnlineInfoResponseAddWkcValidIn(builder *flatbuffers.Builder, wkcValidIn bool) { + builder.PrependBoolSlot(7, wkcValidIn, false) +} +func MsuOnlineInfoResponseAddWkcValidOut(builder *flatbuffers.Builder, wkcValidOut bool) { + builder.PrependBoolSlot(8, wkcValidOut, false) +} +func MsuOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TaskConfiguration.go b/pkg/fbs/comm/ethercat/master/fbs/TaskConfiguration.go new file mode 100644 index 0000000..9eceac8 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TaskConfiguration.go @@ -0,0 +1,210 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TaskConfigurationT struct { + Task string `json:"task"` + CoreIndex string `json:"coreIndex"` + Priority string `json:"priority"` + BeforeSyncPoints []string `json:"beforeSyncPoints"` + AfterSyncPoints []string `json:"afterSyncPoints"` +} + +func (t *TaskConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskOffset := flatbuffers.UOffsetT(0) + if t.Task != "" { + taskOffset = builder.CreateString(t.Task) + } + coreIndexOffset := flatbuffers.UOffsetT(0) + if t.CoreIndex != "" { + coreIndexOffset = builder.CreateString(t.CoreIndex) + } + priorityOffset := flatbuffers.UOffsetT(0) + if t.Priority != "" { + priorityOffset = builder.CreateString(t.Priority) + } + beforeSyncPointsOffset := flatbuffers.UOffsetT(0) + if t.BeforeSyncPoints != nil { + beforeSyncPointsLength := len(t.BeforeSyncPoints) + beforeSyncPointsOffsets := make([]flatbuffers.UOffsetT, beforeSyncPointsLength) + for j := 0; j < beforeSyncPointsLength; j++ { + beforeSyncPointsOffsets[j] = builder.CreateString(t.BeforeSyncPoints[j]) + } + TaskConfigurationStartBeforeSyncPointsVector(builder, beforeSyncPointsLength) + for j := beforeSyncPointsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(beforeSyncPointsOffsets[j]) + } + beforeSyncPointsOffset = builder.EndVector(beforeSyncPointsLength) + } + afterSyncPointsOffset := flatbuffers.UOffsetT(0) + if t.AfterSyncPoints != nil { + afterSyncPointsLength := len(t.AfterSyncPoints) + afterSyncPointsOffsets := make([]flatbuffers.UOffsetT, afterSyncPointsLength) + for j := 0; j < afterSyncPointsLength; j++ { + afterSyncPointsOffsets[j] = builder.CreateString(t.AfterSyncPoints[j]) + } + TaskConfigurationStartAfterSyncPointsVector(builder, afterSyncPointsLength) + for j := afterSyncPointsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(afterSyncPointsOffsets[j]) + } + afterSyncPointsOffset = builder.EndVector(afterSyncPointsLength) + } + TaskConfigurationStart(builder) + TaskConfigurationAddTask(builder, taskOffset) + TaskConfigurationAddCoreIndex(builder, coreIndexOffset) + TaskConfigurationAddPriority(builder, priorityOffset) + TaskConfigurationAddBeforeSyncPoints(builder, beforeSyncPointsOffset) + TaskConfigurationAddAfterSyncPoints(builder, afterSyncPointsOffset) + return TaskConfigurationEnd(builder) +} + +func (rcv *TaskConfiguration) UnPackTo(t *TaskConfigurationT) { + t.Task = string(rcv.Task()) + t.CoreIndex = string(rcv.CoreIndex()) + t.Priority = string(rcv.Priority()) + beforeSyncPointsLength := rcv.BeforeSyncPointsLength() + t.BeforeSyncPoints = make([]string, beforeSyncPointsLength) + for j := 0; j < beforeSyncPointsLength; j++ { + t.BeforeSyncPoints[j] = string(rcv.BeforeSyncPoints(j)) + } + afterSyncPointsLength := rcv.AfterSyncPointsLength() + t.AfterSyncPoints = make([]string, afterSyncPointsLength) + for j := 0; j < afterSyncPointsLength; j++ { + t.AfterSyncPoints[j] = string(rcv.AfterSyncPoints(j)) + } +} + +func (rcv *TaskConfiguration) UnPack() *TaskConfigurationT { + if rcv == nil { return nil } + t := &TaskConfigurationT{} + rcv.UnPackTo(t) + return t +} + +type TaskConfiguration struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskConfiguration(buf []byte, offset flatbuffers.UOffsetT) *TaskConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskConfiguration{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskConfiguration(buf []byte, offset flatbuffers.UOffsetT) *TaskConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskConfiguration{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskConfiguration) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskConfiguration) Table() flatbuffers.Table { + return rcv._tab +} + +/// Default task context for the callable +func (rcv *TaskConfiguration) Task() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default task context for the callable +/// Default CoreIndex of the task +func (rcv *TaskConfiguration) CoreIndex() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default CoreIndex of the task +/// Default priority of the task e.g. high, mid, low +func (rcv *TaskConfiguration) Priority() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default priority of the task e.g. high, mid, low +/// User defined synchronization points, execute callable in order before these points, any alphanumeric character +func (rcv *TaskConfiguration) BeforeSyncPoints(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 *TaskConfiguration) BeforeSyncPointsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// User defined synchronization points, execute callable in order before these points, any alphanumeric character +/// User defined synchronization points, execute callable in order after these points +func (rcv *TaskConfiguration) AfterSyncPoints(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 *TaskConfiguration) AfterSyncPointsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// User defined synchronization points, execute callable in order after these points +func TaskConfigurationStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func TaskConfigurationAddTask(builder *flatbuffers.Builder, task flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(task), 0) +} +func TaskConfigurationAddCoreIndex(builder *flatbuffers.Builder, coreIndex flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(coreIndex), 0) +} +func TaskConfigurationAddPriority(builder *flatbuffers.Builder, priority flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(priority), 0) +} +func TaskConfigurationAddBeforeSyncPoints(builder *flatbuffers.Builder, beforeSyncPoints flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(beforeSyncPoints), 0) +} +func TaskConfigurationStartBeforeSyncPointsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TaskConfigurationAddAfterSyncPoints(builder *flatbuffers.Builder, afterSyncPoints flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(afterSyncPoints), 0) +} +func TaskConfigurationStartAfterSyncPointsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TaskConfigurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultConfig.go b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultConfig.go new file mode 100644 index 0000000..1f987bb --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultConfig.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Request a new EtherCAT-Master instance +type TaskDefaultConfigT struct { + DefaultTaskConfig *TaskConfigurationT `json:"defaultTaskConfig"` +} + +func (t *TaskDefaultConfigT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + defaultTaskConfigOffset := t.DefaultTaskConfig.Pack(builder) + TaskDefaultConfigStart(builder) + TaskDefaultConfigAddDefaultTaskConfig(builder, defaultTaskConfigOffset) + return TaskDefaultConfigEnd(builder) +} + +func (rcv *TaskDefaultConfig) UnPackTo(t *TaskDefaultConfigT) { + t.DefaultTaskConfig = rcv.DefaultTaskConfig(nil).UnPack() +} + +func (rcv *TaskDefaultConfig) UnPack() *TaskDefaultConfigT { + if rcv == nil { return nil } + t := &TaskDefaultConfigT{} + rcv.UnPackTo(t) + return t +} + +type TaskDefaultConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskDefaultConfig(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskDefaultConfig{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskDefaultConfig(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskDefaultConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskDefaultConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskDefaultConfig) Table() flatbuffers.Table { + return rcv._tab +} + +///Default task configuration for EtherCAT callable +func (rcv *TaskDefaultConfig) DefaultTaskConfig(obj *TaskConfiguration) *TaskConfiguration { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskConfiguration) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Default task configuration for EtherCAT callable +func TaskDefaultConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TaskDefaultConfigAddDefaultTaskConfig(builder *flatbuffers.Builder, defaultTaskConfig flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(defaultTaskConfig), 0) +} +func TaskDefaultConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfo.go b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfo.go new file mode 100644 index 0000000..326103b --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfo.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node show the configured default task configuration +type TaskDefaultInfoT struct { + Response *TaskDefaultInfoResponseT `json:"response"` +} + +func (t *TaskDefaultInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + responseOffset := t.Response.Pack(builder) + TaskDefaultInfoStart(builder) + TaskDefaultInfoAddResponse(builder, responseOffset) + return TaskDefaultInfoEnd(builder) +} + +func (rcv *TaskDefaultInfo) UnPackTo(t *TaskDefaultInfoT) { + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *TaskDefaultInfo) UnPack() *TaskDefaultInfoT { + if rcv == nil { return nil } + t := &TaskDefaultInfoT{} + rcv.UnPackTo(t) + return t +} + +type TaskDefaultInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskDefaultInfo(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskDefaultInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskDefaultInfo(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskDefaultInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskDefaultInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskDefaultInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TaskDefaultInfo) Response(obj *TaskDefaultInfoResponse) *TaskDefaultInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskDefaultInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func TaskDefaultInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TaskDefaultInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(response), 0) +} +func TaskDefaultInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfoResponse.go new file mode 100644 index 0000000..37c8f1b --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TaskDefaultInfoResponse.go @@ -0,0 +1,210 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TaskDefaultInfoResponseT struct { + Task string `json:"task"` + CoreIndex string `json:"coreIndex"` + Priority string `json:"priority"` + BeforeSyncPoints []string `json:"beforeSyncPoints"` + AfterSyncPoints []string `json:"afterSyncPoints"` +} + +func (t *TaskDefaultInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskOffset := flatbuffers.UOffsetT(0) + if t.Task != "" { + taskOffset = builder.CreateString(t.Task) + } + coreIndexOffset := flatbuffers.UOffsetT(0) + if t.CoreIndex != "" { + coreIndexOffset = builder.CreateString(t.CoreIndex) + } + priorityOffset := flatbuffers.UOffsetT(0) + if t.Priority != "" { + priorityOffset = builder.CreateString(t.Priority) + } + beforeSyncPointsOffset := flatbuffers.UOffsetT(0) + if t.BeforeSyncPoints != nil { + beforeSyncPointsLength := len(t.BeforeSyncPoints) + beforeSyncPointsOffsets := make([]flatbuffers.UOffsetT, beforeSyncPointsLength) + for j := 0; j < beforeSyncPointsLength; j++ { + beforeSyncPointsOffsets[j] = builder.CreateString(t.BeforeSyncPoints[j]) + } + TaskDefaultInfoResponseStartBeforeSyncPointsVector(builder, beforeSyncPointsLength) + for j := beforeSyncPointsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(beforeSyncPointsOffsets[j]) + } + beforeSyncPointsOffset = builder.EndVector(beforeSyncPointsLength) + } + afterSyncPointsOffset := flatbuffers.UOffsetT(0) + if t.AfterSyncPoints != nil { + afterSyncPointsLength := len(t.AfterSyncPoints) + afterSyncPointsOffsets := make([]flatbuffers.UOffsetT, afterSyncPointsLength) + for j := 0; j < afterSyncPointsLength; j++ { + afterSyncPointsOffsets[j] = builder.CreateString(t.AfterSyncPoints[j]) + } + TaskDefaultInfoResponseStartAfterSyncPointsVector(builder, afterSyncPointsLength) + for j := afterSyncPointsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(afterSyncPointsOffsets[j]) + } + afterSyncPointsOffset = builder.EndVector(afterSyncPointsLength) + } + TaskDefaultInfoResponseStart(builder) + TaskDefaultInfoResponseAddTask(builder, taskOffset) + TaskDefaultInfoResponseAddCoreIndex(builder, coreIndexOffset) + TaskDefaultInfoResponseAddPriority(builder, priorityOffset) + TaskDefaultInfoResponseAddBeforeSyncPoints(builder, beforeSyncPointsOffset) + TaskDefaultInfoResponseAddAfterSyncPoints(builder, afterSyncPointsOffset) + return TaskDefaultInfoResponseEnd(builder) +} + +func (rcv *TaskDefaultInfoResponse) UnPackTo(t *TaskDefaultInfoResponseT) { + t.Task = string(rcv.Task()) + t.CoreIndex = string(rcv.CoreIndex()) + t.Priority = string(rcv.Priority()) + beforeSyncPointsLength := rcv.BeforeSyncPointsLength() + t.BeforeSyncPoints = make([]string, beforeSyncPointsLength) + for j := 0; j < beforeSyncPointsLength; j++ { + t.BeforeSyncPoints[j] = string(rcv.BeforeSyncPoints(j)) + } + afterSyncPointsLength := rcv.AfterSyncPointsLength() + t.AfterSyncPoints = make([]string, afterSyncPointsLength) + for j := 0; j < afterSyncPointsLength; j++ { + t.AfterSyncPoints[j] = string(rcv.AfterSyncPoints(j)) + } +} + +func (rcv *TaskDefaultInfoResponse) UnPack() *TaskDefaultInfoResponseT { + if rcv == nil { return nil } + t := &TaskDefaultInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type TaskDefaultInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskDefaultInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskDefaultInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskDefaultInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *TaskDefaultInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskDefaultInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskDefaultInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskDefaultInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +/// Default task context for the callable +func (rcv *TaskDefaultInfoResponse) Task() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default task context for the callable +/// Default CoreIndex of the task +func (rcv *TaskDefaultInfoResponse) CoreIndex() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default CoreIndex of the task +/// Default priority of the task e.g. high, mid, low +func (rcv *TaskDefaultInfoResponse) Priority() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Default priority of the task e.g. high, mid, low +/// User defined synchronization points, execute callable in order before these points, any alphanumeric character +func (rcv *TaskDefaultInfoResponse) BeforeSyncPoints(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 *TaskDefaultInfoResponse) BeforeSyncPointsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// User defined synchronization points, execute callable in order before these points, any alphanumeric character +/// User defined synchronization points, execute callable in order after these points +func (rcv *TaskDefaultInfoResponse) AfterSyncPoints(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 *TaskDefaultInfoResponse) AfterSyncPointsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// User defined synchronization points, execute callable in order after these points +func TaskDefaultInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func TaskDefaultInfoResponseAddTask(builder *flatbuffers.Builder, task flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(task), 0) +} +func TaskDefaultInfoResponseAddCoreIndex(builder *flatbuffers.Builder, coreIndex flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(coreIndex), 0) +} +func TaskDefaultInfoResponseAddPriority(builder *flatbuffers.Builder, priority flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(priority), 0) +} +func TaskDefaultInfoResponseAddBeforeSyncPoints(builder *flatbuffers.Builder, beforeSyncPoints flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(beforeSyncPoints), 0) +} +func TaskDefaultInfoResponseStartBeforeSyncPointsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TaskDefaultInfoResponseAddAfterSyncPoints(builder *flatbuffers.Builder, afterSyncPoints flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(afterSyncPoints), 0) +} +func TaskDefaultInfoResponseStartAfterSyncPointsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TaskDefaultInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/ArrayOfByteString.go b/pkg/fbs/comm/opcua/builtin/ArrayOfByteString.go new file mode 100644 index 0000000..049f201 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/ArrayOfByteString.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfByteStringT struct { + Array []*ByteStringT `json:"array"` +} + +func (t *ArrayOfByteStringT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + arrayOffset := flatbuffers.UOffsetT(0) + if t.Array != nil { + arrayLength := len(t.Array) + arrayOffsets := make([]flatbuffers.UOffsetT, arrayLength) + for j := 0; j < arrayLength; j++ { + arrayOffsets[j] = t.Array[j].Pack(builder) + } + ArrayOfByteStringStartArrayVector(builder, arrayLength) + for j := arrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(arrayOffsets[j]) + } + arrayOffset = builder.EndVector(arrayLength) + } + ArrayOfByteStringStart(builder) + ArrayOfByteStringAddArray(builder, arrayOffset) + return ArrayOfByteStringEnd(builder) +} + +func (rcv *ArrayOfByteString) UnPackTo(t *ArrayOfByteStringT) { + arrayLength := rcv.ArrayLength() + t.Array = make([]*ByteStringT, arrayLength) + for j := 0; j < arrayLength; j++ { + x := ByteString{} + rcv.Array(&x, j) + t.Array[j] = x.UnPack() + } +} + +func (rcv *ArrayOfByteString) UnPack() *ArrayOfByteStringT { + if rcv == nil { return nil } + t := &ArrayOfByteStringT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfByteString struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfByteString(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfByteString { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfByteString{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfByteString(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfByteString { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfByteString{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfByteString) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfByteString) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfByteString) Array(obj *ByteString, 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 *ArrayOfByteString) ArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfByteStringStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfByteStringAddArray(builder *flatbuffers.Builder, array flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(array), 0) +} +func ArrayOfByteStringStartArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfByteStringEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/ArrayOfGuid.go b/pkg/fbs/comm/opcua/builtin/ArrayOfGuid.go new file mode 100644 index 0000000..2dd18f5 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/ArrayOfGuid.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfGuidT struct { + Array []*GuidT `json:"array"` +} + +func (t *ArrayOfGuidT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + arrayOffset := flatbuffers.UOffsetT(0) + if t.Array != nil { + arrayLength := len(t.Array) + arrayOffsets := make([]flatbuffers.UOffsetT, arrayLength) + for j := 0; j < arrayLength; j++ { + arrayOffsets[j] = t.Array[j].Pack(builder) + } + ArrayOfGuidStartArrayVector(builder, arrayLength) + for j := arrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(arrayOffsets[j]) + } + arrayOffset = builder.EndVector(arrayLength) + } + ArrayOfGuidStart(builder) + ArrayOfGuidAddArray(builder, arrayOffset) + return ArrayOfGuidEnd(builder) +} + +func (rcv *ArrayOfGuid) UnPackTo(t *ArrayOfGuidT) { + arrayLength := rcv.ArrayLength() + t.Array = make([]*GuidT, arrayLength) + for j := 0; j < arrayLength; j++ { + x := Guid{} + rcv.Array(&x, j) + t.Array[j] = x.UnPack() + } +} + +func (rcv *ArrayOfGuid) UnPack() *ArrayOfGuidT { + if rcv == nil { return nil } + t := &ArrayOfGuidT{} + rcv.UnPackTo(t) + return t +} + +type ArrayOfGuid struct { + _tab flatbuffers.Table +} + +func GetRootAsArrayOfGuid(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfGuid { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ArrayOfGuid{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsArrayOfGuid(buf []byte, offset flatbuffers.UOffsetT) *ArrayOfGuid { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ArrayOfGuid{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ArrayOfGuid) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ArrayOfGuid) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ArrayOfGuid) Array(obj *Guid, 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 *ArrayOfGuid) ArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ArrayOfGuidStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ArrayOfGuidAddArray(builder *flatbuffers.Builder, array flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(array), 0) +} +func ArrayOfGuidStartArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ArrayOfGuidEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/BooleanVariant.go b/pkg/fbs/comm/opcua/builtin/BooleanVariant.go new file mode 100644 index 0000000..8d276f6 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/BooleanVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BooleanVariantT struct { + Value bool `json:"value"` +} + +func (t *BooleanVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + BooleanVariantStart(builder) + BooleanVariantAddValue(builder, t.Value) + return BooleanVariantEnd(builder) +} + +func (rcv *BooleanVariant) UnPackTo(t *BooleanVariantT) { + t.Value = rcv.Value() +} + +func (rcv *BooleanVariant) UnPack() *BooleanVariantT { + if rcv == nil { return nil } + t := &BooleanVariantT{} + rcv.UnPackTo(t) + return t +} + +type BooleanVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsBooleanVariant(buf []byte, offset flatbuffers.UOffsetT) *BooleanVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BooleanVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBooleanVariant(buf []byte, offset flatbuffers.UOffsetT) *BooleanVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BooleanVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *BooleanVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BooleanVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BooleanVariant) Value() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *BooleanVariant) MutateValue(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func BooleanVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func BooleanVariantAddValue(builder *flatbuffers.Builder, value bool) { + builder.PrependBoolSlot(0, value, false) +} +func BooleanVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/ByteStringVariant.go b/pkg/fbs/comm/opcua/builtin/ByteStringVariant.go new file mode 100644 index 0000000..6def001 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/ByteStringVariant.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ByteStringVariantT struct { + Value *ByteStringT `json:"value"` +} + +func (t *ByteStringVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := t.Value.Pack(builder) + ByteStringVariantStart(builder) + ByteStringVariantAddValue(builder, valueOffset) + return ByteStringVariantEnd(builder) +} + +func (rcv *ByteStringVariant) UnPackTo(t *ByteStringVariantT) { + t.Value = rcv.Value(nil).UnPack() +} + +func (rcv *ByteStringVariant) UnPack() *ByteStringVariantT { + if rcv == nil { return nil } + t := &ByteStringVariantT{} + rcv.UnPackTo(t) + return t +} + +type ByteStringVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsByteStringVariant(buf []byte, offset flatbuffers.UOffsetT) *ByteStringVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ByteStringVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsByteStringVariant(buf []byte, offset flatbuffers.UOffsetT) *ByteStringVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ByteStringVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ByteStringVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ByteStringVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ByteStringVariant) Value(obj *ByteString) *ByteString { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(ByteString) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func ByteStringVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ByteStringVariantAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(value), 0) +} +func ByteStringVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/ByteVariant.go b/pkg/fbs/comm/opcua/builtin/ByteVariant.go new file mode 100644 index 0000000..ef566a7 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/ByteVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ByteVariantT struct { + Value byte `json:"value"` +} + +func (t *ByteVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ByteVariantStart(builder) + ByteVariantAddValue(builder, t.Value) + return ByteVariantEnd(builder) +} + +func (rcv *ByteVariant) UnPackTo(t *ByteVariantT) { + t.Value = rcv.Value() +} + +func (rcv *ByteVariant) UnPack() *ByteVariantT { + if rcv == nil { return nil } + t := &ByteVariantT{} + rcv.UnPackTo(t) + return t +} + +type ByteVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsByteVariant(buf []byte, offset flatbuffers.UOffsetT) *ByteVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ByteVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsByteVariant(buf []byte, offset flatbuffers.UOffsetT) *ByteVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ByteVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ByteVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ByteVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ByteVariant) Value() byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetByte(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ByteVariant) MutateValue(n byte) bool { + return rcv._tab.MutateByteSlot(4, n) +} + +func ByteVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ByteVariantAddValue(builder *flatbuffers.Builder, value byte) { + builder.PrependByteSlot(0, value, 0) +} +func ByteVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/DateTimeVariant.go b/pkg/fbs/comm/opcua/builtin/DateTimeVariant.go new file mode 100644 index 0000000..82b6fa1 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/DateTimeVariant.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DateTimeVariantT struct { + Value *DateTimeT `json:"value"` +} + +func (t *DateTimeVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := t.Value.Pack(builder) + DateTimeVariantStart(builder) + DateTimeVariantAddValue(builder, valueOffset) + return DateTimeVariantEnd(builder) +} + +func (rcv *DateTimeVariant) UnPackTo(t *DateTimeVariantT) { + t.Value = rcv.Value(nil).UnPack() +} + +func (rcv *DateTimeVariant) UnPack() *DateTimeVariantT { + if rcv == nil { return nil } + t := &DateTimeVariantT{} + rcv.UnPackTo(t) + return t +} + +type DateTimeVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsDateTimeVariant(buf []byte, offset flatbuffers.UOffsetT) *DateTimeVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DateTimeVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDateTimeVariant(buf []byte, offset flatbuffers.UOffsetT) *DateTimeVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DateTimeVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DateTimeVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DateTimeVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DateTimeVariant) Value(obj *DateTime) *DateTime { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DateTime) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func DateTimeVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func DateTimeVariantAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(value), 0) +} +func DateTimeVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/DoubleVariant.go b/pkg/fbs/comm/opcua/builtin/DoubleVariant.go new file mode 100644 index 0000000..1e4dc19 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/DoubleVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DoubleVariantT struct { + Value float64 `json:"value"` +} + +func (t *DoubleVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DoubleVariantStart(builder) + DoubleVariantAddValue(builder, t.Value) + return DoubleVariantEnd(builder) +} + +func (rcv *DoubleVariant) UnPackTo(t *DoubleVariantT) { + t.Value = rcv.Value() +} + +func (rcv *DoubleVariant) UnPack() *DoubleVariantT { + if rcv == nil { return nil } + t := &DoubleVariantT{} + rcv.UnPackTo(t) + return t +} + +type DoubleVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsDoubleVariant(buf []byte, offset flatbuffers.UOffsetT) *DoubleVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DoubleVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDoubleVariant(buf []byte, offset flatbuffers.UOffsetT) *DoubleVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DoubleVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DoubleVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DoubleVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DoubleVariant) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *DoubleVariant) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func DoubleVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func DoubleVariantAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(0, value, 0.0) +} +func DoubleVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/FloatVariant.go b/pkg/fbs/comm/opcua/builtin/FloatVariant.go new file mode 100644 index 0000000..fbfc48b --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/FloatVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type FloatVariantT struct { + Value float32 `json:"value"` +} + +func (t *FloatVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + FloatVariantStart(builder) + FloatVariantAddValue(builder, t.Value) + return FloatVariantEnd(builder) +} + +func (rcv *FloatVariant) UnPackTo(t *FloatVariantT) { + t.Value = rcv.Value() +} + +func (rcv *FloatVariant) UnPack() *FloatVariantT { + if rcv == nil { return nil } + t := &FloatVariantT{} + rcv.UnPackTo(t) + return t +} + +type FloatVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsFloatVariant(buf []byte, offset flatbuffers.UOffsetT) *FloatVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &FloatVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsFloatVariant(buf []byte, offset flatbuffers.UOffsetT) *FloatVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &FloatVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *FloatVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *FloatVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *FloatVariant) Value() float32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat32(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *FloatVariant) MutateValue(n float32) bool { + return rcv._tab.MutateFloat32Slot(4, n) +} + +func FloatVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func FloatVariantAddValue(builder *flatbuffers.Builder, value float32) { + builder.PrependFloat32Slot(0, value, 0.0) +} +func FloatVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/GuidVariant.go b/pkg/fbs/comm/opcua/builtin/GuidVariant.go new file mode 100644 index 0000000..8a82f40 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/GuidVariant.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type GuidVariantT struct { + Value *GuidT `json:"value"` +} + +func (t *GuidVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := t.Value.Pack(builder) + GuidVariantStart(builder) + GuidVariantAddValue(builder, valueOffset) + return GuidVariantEnd(builder) +} + +func (rcv *GuidVariant) UnPackTo(t *GuidVariantT) { + t.Value = rcv.Value(nil).UnPack() +} + +func (rcv *GuidVariant) UnPack() *GuidVariantT { + if rcv == nil { return nil } + t := &GuidVariantT{} + rcv.UnPackTo(t) + return t +} + +type GuidVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsGuidVariant(buf []byte, offset flatbuffers.UOffsetT) *GuidVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &GuidVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsGuidVariant(buf []byte, offset flatbuffers.UOffsetT) *GuidVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &GuidVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *GuidVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *GuidVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *GuidVariant) Value(obj *Guid) *Guid { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Guid) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func GuidVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func GuidVariantAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(value), 0) +} +func GuidVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/Int16Variant.go b/pkg/fbs/comm/opcua/builtin/Int16Variant.go new file mode 100644 index 0000000..0a5dec0 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/Int16Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Int16VariantT struct { + Value int16 `json:"value"` +} + +func (t *Int16VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int16VariantStart(builder) + Int16VariantAddValue(builder, t.Value) + return Int16VariantEnd(builder) +} + +func (rcv *Int16Variant) UnPackTo(t *Int16VariantT) { + t.Value = rcv.Value() +} + +func (rcv *Int16Variant) UnPack() *Int16VariantT { + if rcv == nil { return nil } + t := &Int16VariantT{} + rcv.UnPackTo(t) + return t +} + +type Int16Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsInt16Variant(buf []byte, offset flatbuffers.UOffsetT) *Int16Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Int16Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsInt16Variant(buf []byte, offset flatbuffers.UOffsetT) *Int16Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Int16Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Int16Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Int16Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Int16Variant) Value() int16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Int16Variant) MutateValue(n int16) bool { + return rcv._tab.MutateInt16Slot(4, n) +} + +func Int16VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func Int16VariantAddValue(builder *flatbuffers.Builder, value int16) { + builder.PrependInt16Slot(0, value, 0) +} +func Int16VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/Int32Variant.go b/pkg/fbs/comm/opcua/builtin/Int32Variant.go new file mode 100644 index 0000000..090cae2 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/Int32Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Int32VariantT struct { + Value int32 `json:"value"` +} + +func (t *Int32VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int32VariantStart(builder) + Int32VariantAddValue(builder, t.Value) + return Int32VariantEnd(builder) +} + +func (rcv *Int32Variant) UnPackTo(t *Int32VariantT) { + t.Value = rcv.Value() +} + +func (rcv *Int32Variant) UnPack() *Int32VariantT { + if rcv == nil { return nil } + t := &Int32VariantT{} + rcv.UnPackTo(t) + return t +} + +type Int32Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsInt32Variant(buf []byte, offset flatbuffers.UOffsetT) *Int32Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Int32Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsInt32Variant(buf []byte, offset flatbuffers.UOffsetT) *Int32Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Int32Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Int32Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Int32Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Int32Variant) Value() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Int32Variant) MutateValue(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +func Int32VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func Int32VariantAddValue(builder *flatbuffers.Builder, value int32) { + builder.PrependInt32Slot(0, value, 0) +} +func Int32VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/Int64Variant.go b/pkg/fbs/comm/opcua/builtin/Int64Variant.go new file mode 100644 index 0000000..5098e84 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/Int64Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Int64VariantT struct { + Value int64 `json:"value"` +} + +func (t *Int64VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Int64VariantStart(builder) + Int64VariantAddValue(builder, t.Value) + return Int64VariantEnd(builder) +} + +func (rcv *Int64Variant) UnPackTo(t *Int64VariantT) { + t.Value = rcv.Value() +} + +func (rcv *Int64Variant) UnPack() *Int64VariantT { + if rcv == nil { return nil } + t := &Int64VariantT{} + rcv.UnPackTo(t) + return t +} + +type Int64Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsInt64Variant(buf []byte, offset flatbuffers.UOffsetT) *Int64Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Int64Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsInt64Variant(buf []byte, offset flatbuffers.UOffsetT) *Int64Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Int64Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Int64Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Int64Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Int64Variant) Value() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Int64Variant) MutateValue(n int64) bool { + return rcv._tab.MutateInt64Slot(4, n) +} + +func Int64VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func Int64VariantAddValue(builder *flatbuffers.Builder, value int64) { + builder.PrependInt64Slot(0, value, 0) +} +func Int64VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/SByteVariant.go b/pkg/fbs/comm/opcua/builtin/SByteVariant.go new file mode 100644 index 0000000..8cd95dd --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/SByteVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SByteVariantT struct { + Value int8 `json:"value"` +} + +func (t *SByteVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + SByteVariantStart(builder) + SByteVariantAddValue(builder, t.Value) + return SByteVariantEnd(builder) +} + +func (rcv *SByteVariant) UnPackTo(t *SByteVariantT) { + t.Value = rcv.Value() +} + +func (rcv *SByteVariant) UnPack() *SByteVariantT { + if rcv == nil { return nil } + t := &SByteVariantT{} + rcv.UnPackTo(t) + return t +} + +type SByteVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsSByteVariant(buf []byte, offset flatbuffers.UOffsetT) *SByteVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SByteVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsSByteVariant(buf []byte, offset flatbuffers.UOffsetT) *SByteVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SByteVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *SByteVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SByteVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SByteVariant) Value() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SByteVariant) MutateValue(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func SByteVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func SByteVariantAddValue(builder *flatbuffers.Builder, value int8) { + builder.PrependInt8Slot(0, value, 0) +} +func SByteVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/StringVariant.go b/pkg/fbs/comm/opcua/builtin/StringVariant.go new file mode 100644 index 0000000..a8ab744 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/StringVariant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type StringVariantT struct { + Value string `json:"value"` +} + +func (t *StringVariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := flatbuffers.UOffsetT(0) + if t.Value != "" { + valueOffset = builder.CreateString(t.Value) + } + StringVariantStart(builder) + StringVariantAddValue(builder, valueOffset) + return StringVariantEnd(builder) +} + +func (rcv *StringVariant) UnPackTo(t *StringVariantT) { + t.Value = string(rcv.Value()) +} + +func (rcv *StringVariant) UnPack() *StringVariantT { + if rcv == nil { return nil } + t := &StringVariantT{} + rcv.UnPackTo(t) + return t +} + +type StringVariant struct { + _tab flatbuffers.Table +} + +func GetRootAsStringVariant(buf []byte, offset flatbuffers.UOffsetT) *StringVariant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StringVariant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStringVariant(buf []byte, offset flatbuffers.UOffsetT) *StringVariant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StringVariant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StringVariant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StringVariant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *StringVariant) Value() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func StringVariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func StringVariantAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(value), 0) +} +func StringVariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/UInt16Variant.go b/pkg/fbs/comm/opcua/builtin/UInt16Variant.go new file mode 100644 index 0000000..d4a2e14 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/UInt16Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type UInt16VariantT struct { + Value uint16 `json:"value"` +} + +func (t *UInt16VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt16VariantStart(builder) + UInt16VariantAddValue(builder, t.Value) + return UInt16VariantEnd(builder) +} + +func (rcv *UInt16Variant) UnPackTo(t *UInt16VariantT) { + t.Value = rcv.Value() +} + +func (rcv *UInt16Variant) UnPack() *UInt16VariantT { + if rcv == nil { return nil } + t := &UInt16VariantT{} + rcv.UnPackTo(t) + return t +} + +type UInt16Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsUInt16Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt16Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &UInt16Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsUInt16Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt16Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &UInt16Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *UInt16Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *UInt16Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *UInt16Variant) Value() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *UInt16Variant) MutateValue(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func UInt16VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func UInt16VariantAddValue(builder *flatbuffers.Builder, value uint16) { + builder.PrependUint16Slot(0, value, 0) +} +func UInt16VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/UInt32Variant.go b/pkg/fbs/comm/opcua/builtin/UInt32Variant.go new file mode 100644 index 0000000..56da577 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/UInt32Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type UInt32VariantT struct { + Value uint32 `json:"value"` +} + +func (t *UInt32VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt32VariantStart(builder) + UInt32VariantAddValue(builder, t.Value) + return UInt32VariantEnd(builder) +} + +func (rcv *UInt32Variant) UnPackTo(t *UInt32VariantT) { + t.Value = rcv.Value() +} + +func (rcv *UInt32Variant) UnPack() *UInt32VariantT { + if rcv == nil { return nil } + t := &UInt32VariantT{} + rcv.UnPackTo(t) + return t +} + +type UInt32Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsUInt32Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt32Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &UInt32Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsUInt32Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt32Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &UInt32Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *UInt32Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *UInt32Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *UInt32Variant) Value() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *UInt32Variant) MutateValue(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func UInt32VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func UInt32VariantAddValue(builder *flatbuffers.Builder, value uint32) { + builder.PrependUint32Slot(0, value, 0) +} +func UInt32VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/UInt64Variant.go b/pkg/fbs/comm/opcua/builtin/UInt64Variant.go new file mode 100644 index 0000000..f9cf9fa --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/UInt64Variant.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type UInt64VariantT struct { + Value uint64 `json:"value"` +} + +func (t *UInt64VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + UInt64VariantStart(builder) + UInt64VariantAddValue(builder, t.Value) + return UInt64VariantEnd(builder) +} + +func (rcv *UInt64Variant) UnPackTo(t *UInt64VariantT) { + t.Value = rcv.Value() +} + +func (rcv *UInt64Variant) UnPack() *UInt64VariantT { + if rcv == nil { return nil } + t := &UInt64VariantT{} + rcv.UnPackTo(t) + return t +} + +type UInt64Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsUInt64Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt64Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &UInt64Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsUInt64Variant(buf []byte, offset flatbuffers.UOffsetT) *UInt64Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &UInt64Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *UInt64Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *UInt64Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *UInt64Variant) Value() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *UInt64Variant) MutateValue(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func UInt64VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func UInt64VariantAddValue(builder *flatbuffers.Builder, value uint64) { + builder.PrependUint64Slot(0, value, 0) +} +func UInt64VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/Variant.go b/pkg/fbs/comm/opcua/builtin/Variant.go new file mode 100644 index 0000000..3f5b500 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/Variant.go @@ -0,0 +1,98 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type VariantT struct { + Value *VariantUnionT `json:"value"` +} + +func (t *VariantT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + valueOffset := t.Value.Pack(builder) + + VariantStart(builder) + if t.Value != nil { + VariantAddValueType(builder, t.Value.Type) + } + VariantAddValue(builder, valueOffset) + return VariantEnd(builder) +} + +func (rcv *Variant) UnPackTo(t *VariantT) { + valueTable := flatbuffers.Table{} + if rcv.Value(&valueTable) { + t.Value = rcv.ValueType().UnPack(valueTable) + } +} + +func (rcv *Variant) UnPack() *VariantT { + if rcv == nil { return nil } + t := &VariantT{} + rcv.UnPackTo(t) + return t +} + +type Variant struct { + _tab flatbuffers.Table +} + +func GetRootAsVariant(buf []byte, offset flatbuffers.UOffsetT) *Variant { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Variant{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsVariant(buf []byte, offset flatbuffers.UOffsetT) *Variant { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Variant{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Variant) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Variant) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Variant) ValueType() VariantUnion { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return VariantUnion(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Variant) MutateValueType(n VariantUnion) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *Variant) Value(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func VariantStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func VariantAddValueType(builder *flatbuffers.Builder, valueType VariantUnion) { + builder.PrependByteSlot(0, byte(valueType), 0) +} +func VariantAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(value), 0) +} +func VariantEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/builtin/VariantUnion.go b/pkg/fbs/comm/opcua/builtin/VariantUnion.go new file mode 100644 index 0000000..5a46fc9 --- /dev/null +++ b/pkg/fbs/comm/opcua/builtin/VariantUnion.go @@ -0,0 +1,184 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package builtin + +import ( + "strconv" + flatbuffers "github.com/google/flatbuffers/go" +) + +type VariantUnion byte + +const ( + VariantUnionNONE VariantUnion = 0 + VariantUnionBooleanVariant VariantUnion = 1 + VariantUnionSByteVariant VariantUnion = 2 + VariantUnionByteVariant VariantUnion = 3 + VariantUnionInt16Variant VariantUnion = 4 + VariantUnionUInt16Variant VariantUnion = 5 + VariantUnionInt32Variant VariantUnion = 6 + VariantUnionUInt32Variant VariantUnion = 7 + VariantUnionInt64Variant VariantUnion = 8 + VariantUnionUInt64Variant VariantUnion = 9 + VariantUnionFloatVariant VariantUnion = 10 + VariantUnionDoubleVariant VariantUnion = 11 + VariantUnionStringVariant VariantUnion = 12 + VariantUnionDateTimeVariant VariantUnion = 13 + VariantUnionGuidVariant VariantUnion = 14 + VariantUnionByteStringVariant VariantUnion = 15 +) + +var EnumNamesVariantUnion = map[VariantUnion]string{ + VariantUnionNONE: "NONE", + VariantUnionBooleanVariant: "BooleanVariant", + VariantUnionSByteVariant: "SByteVariant", + VariantUnionByteVariant: "ByteVariant", + VariantUnionInt16Variant: "Int16Variant", + VariantUnionUInt16Variant: "UInt16Variant", + VariantUnionInt32Variant: "Int32Variant", + VariantUnionUInt32Variant: "UInt32Variant", + VariantUnionInt64Variant: "Int64Variant", + VariantUnionUInt64Variant: "UInt64Variant", + VariantUnionFloatVariant: "FloatVariant", + VariantUnionDoubleVariant: "DoubleVariant", + VariantUnionStringVariant: "StringVariant", + VariantUnionDateTimeVariant: "DateTimeVariant", + VariantUnionGuidVariant: "GuidVariant", + VariantUnionByteStringVariant: "ByteStringVariant", +} + +var EnumValuesVariantUnion = map[string]VariantUnion{ + "NONE": VariantUnionNONE, + "BooleanVariant": VariantUnionBooleanVariant, + "SByteVariant": VariantUnionSByteVariant, + "ByteVariant": VariantUnionByteVariant, + "Int16Variant": VariantUnionInt16Variant, + "UInt16Variant": VariantUnionUInt16Variant, + "Int32Variant": VariantUnionInt32Variant, + "UInt32Variant": VariantUnionUInt32Variant, + "Int64Variant": VariantUnionInt64Variant, + "UInt64Variant": VariantUnionUInt64Variant, + "FloatVariant": VariantUnionFloatVariant, + "DoubleVariant": VariantUnionDoubleVariant, + "StringVariant": VariantUnionStringVariant, + "DateTimeVariant": VariantUnionDateTimeVariant, + "GuidVariant": VariantUnionGuidVariant, + "ByteStringVariant": VariantUnionByteStringVariant, +} + +func (v VariantUnion) String() string { + if s, ok := EnumNamesVariantUnion[v]; ok { + return s + } + return "VariantUnion(" + strconv.FormatInt(int64(v), 10) + ")" +} + +type VariantUnionT struct { + Type VariantUnion + Value interface{} +} + +func (t *VariantUnionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { + return 0 + } + switch t.Type { + case VariantUnionBooleanVariant: + return t.Value.(*BooleanVariantT).Pack(builder) + case VariantUnionSByteVariant: + return t.Value.(*SByteVariantT).Pack(builder) + case VariantUnionByteVariant: + return t.Value.(*ByteVariantT).Pack(builder) + case VariantUnionInt16Variant: + return t.Value.(*Int16VariantT).Pack(builder) + case VariantUnionUInt16Variant: + return t.Value.(*UInt16VariantT).Pack(builder) + case VariantUnionInt32Variant: + return t.Value.(*Int32VariantT).Pack(builder) + case VariantUnionUInt32Variant: + return t.Value.(*UInt32VariantT).Pack(builder) + case VariantUnionInt64Variant: + return t.Value.(*Int64VariantT).Pack(builder) + case VariantUnionUInt64Variant: + return t.Value.(*UInt64VariantT).Pack(builder) + case VariantUnionFloatVariant: + return t.Value.(*FloatVariantT).Pack(builder) + case VariantUnionDoubleVariant: + return t.Value.(*DoubleVariantT).Pack(builder) + case VariantUnionStringVariant: + return t.Value.(*StringVariantT).Pack(builder) + case VariantUnionDateTimeVariant: + return t.Value.(*DateTimeVariantT).Pack(builder) + case VariantUnionGuidVariant: + return t.Value.(*GuidVariantT).Pack(builder) + case VariantUnionByteStringVariant: + return t.Value.(*ByteStringVariantT).Pack(builder) + } + return 0 +} + +func (rcv VariantUnion) UnPack(table flatbuffers.Table) *VariantUnionT { + switch rcv { + case VariantUnionBooleanVariant: + var x BooleanVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionBooleanVariant, Value: x.UnPack() } + case VariantUnionSByteVariant: + var x SByteVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionSByteVariant, Value: x.UnPack() } + case VariantUnionByteVariant: + var x ByteVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionByteVariant, Value: x.UnPack() } + case VariantUnionInt16Variant: + var x Int16Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionInt16Variant, Value: x.UnPack() } + case VariantUnionUInt16Variant: + var x UInt16Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionUInt16Variant, Value: x.UnPack() } + case VariantUnionInt32Variant: + var x Int32Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionInt32Variant, Value: x.UnPack() } + case VariantUnionUInt32Variant: + var x UInt32Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionUInt32Variant, Value: x.UnPack() } + case VariantUnionInt64Variant: + var x Int64Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionInt64Variant, Value: x.UnPack() } + case VariantUnionUInt64Variant: + var x UInt64Variant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionUInt64Variant, Value: x.UnPack() } + case VariantUnionFloatVariant: + var x FloatVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionFloatVariant, Value: x.UnPack() } + case VariantUnionDoubleVariant: + var x DoubleVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionDoubleVariant, Value: x.UnPack() } + case VariantUnionStringVariant: + var x StringVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionStringVariant, Value: x.UnPack() } + case VariantUnionDateTimeVariant: + var x DateTimeVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionDateTimeVariant, Value: x.UnPack() } + case VariantUnionGuidVariant: + var x GuidVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionGuidVariant, Value: x.UnPack() } + case VariantUnionByteStringVariant: + var x ByteStringVariant + x.Init(table.Bytes, table.Pos) + return &VariantUnionT{ Type: VariantUnionByteStringVariant, Value: x.UnPack() } + } + return nil +} diff --git a/pkg/fbs/comm/opcua/common/ArrayOfObjectPoolDiagType.go b/pkg/fbs/comm/opcua/common/ArrayOfObjectPoolDiagType.go new file mode 100644 index 0000000..ddff59d --- /dev/null +++ b/pkg/fbs/comm/opcua/common/ArrayOfObjectPoolDiagType.go @@ -0,0 +1,108 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package common + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ArrayOfObjectPoolDiagTypeT struct { + ObjectPoolDiagArray []*ObjectPoolDiagTypeT `json:"objectPoolDiagArray"` +} + +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/common/HeapDiagType.go b/pkg/fbs/comm/opcua/common/HeapDiagType.go new file mode 100644 index 0000000..343c3af --- /dev/null +++ b/pkg/fbs/comm/opcua/common/HeapDiagType.go @@ -0,0 +1,114 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package common + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type HeapDiagTypeT struct { + UsedMemory uint32 `json:"usedMemory"` + MaxUsedMemory uint32 `json:"maxUsedMemory"` + TotalMemory uint32 `json:"totalMemory"` +} + +func (t *HeapDiagTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + HeapDiagTypeStart(builder) + HeapDiagTypeAddUsedMemory(builder, t.UsedMemory) + HeapDiagTypeAddMaxUsedMemory(builder, t.MaxUsedMemory) + HeapDiagTypeAddTotalMemory(builder, t.TotalMemory) + return HeapDiagTypeEnd(builder) +} + +func (rcv *HeapDiagType) UnPackTo(t *HeapDiagTypeT) { + t.UsedMemory = rcv.UsedMemory() + t.MaxUsedMemory = rcv.MaxUsedMemory() + t.TotalMemory = rcv.TotalMemory() +} + +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 (rcv *HeapDiagType) TotalMemory() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *HeapDiagType) MutateTotalMemory(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func HeapDiagTypeStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +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 HeapDiagTypeAddTotalMemory(builder *flatbuffers.Builder, totalMemory uint32) { + builder.PrependUint32Slot(2, totalMemory, 0) +} +func HeapDiagTypeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/common/ObjectPoolDiagType.go b/pkg/fbs/comm/opcua/common/ObjectPoolDiagType.go new file mode 100644 index 0000000..3439ed5 --- /dev/null +++ b/pkg/fbs/comm/opcua/common/ObjectPoolDiagType.go @@ -0,0 +1,132 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package common + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ObjectPoolDiagTypeT struct { + Name string `json:"name"` + UsedObjects uint32 `json:"usedObjects"` + MaxUsedObjects uint32 `json:"maxUsedObjects"` + NumObjects uint32 `json:"numObjects"` +} + +func (t *ObjectPoolDiagTypeT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + 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/enumeration/ApplicationType.go b/pkg/fbs/comm/opcua/enumeration/ApplicationType.go new file mode 100644 index 0000000..a856ccf --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/ApplicationType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type ApplicationType int32 + +const ( + ApplicationTypeServer ApplicationType = 0 + ApplicationTypeClient ApplicationType = 1 + ApplicationTypeClientAndServer ApplicationType = 2 + ApplicationTypeDiscoveryServer ApplicationType = 3 +) + +var EnumNamesApplicationType = map[ApplicationType]string{ + ApplicationTypeServer: "Server", + ApplicationTypeClient: "Client", + ApplicationTypeClientAndServer: "ClientAndServer", + ApplicationTypeDiscoveryServer: "DiscoveryServer", +} + +var EnumValuesApplicationType = map[string]ApplicationType{ + "Server": ApplicationTypeServer, + "Client": ApplicationTypeClient, + "ClientAndServer": ApplicationTypeClientAndServer, + "DiscoveryServer": ApplicationTypeDiscoveryServer, +} + +func (v ApplicationType) String() string { + if s, ok := EnumNamesApplicationType[v]; ok { + return s + } + return "ApplicationType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/BrokerTransportQualityOfService.go b/pkg/fbs/comm/opcua/enumeration/BrokerTransportQualityOfService.go new file mode 100644 index 0000000..36027fd --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/BrokerTransportQualityOfService.go @@ -0,0 +1,38 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type BrokerTransportQualityOfService int32 + +const ( + BrokerTransportQualityOfServiceNotSpecified BrokerTransportQualityOfService = 0 + BrokerTransportQualityOfServiceBestEffort BrokerTransportQualityOfService = 1 + BrokerTransportQualityOfServiceAtLeastOnce BrokerTransportQualityOfService = 2 + BrokerTransportQualityOfServiceAtMostOnce BrokerTransportQualityOfService = 3 + BrokerTransportQualityOfServiceExactlyOnce BrokerTransportQualityOfService = 4 +) + +var EnumNamesBrokerTransportQualityOfService = map[BrokerTransportQualityOfService]string{ + BrokerTransportQualityOfServiceNotSpecified: "NotSpecified", + BrokerTransportQualityOfServiceBestEffort: "BestEffort", + BrokerTransportQualityOfServiceAtLeastOnce: "AtLeastOnce", + BrokerTransportQualityOfServiceAtMostOnce: "AtMostOnce", + BrokerTransportQualityOfServiceExactlyOnce: "ExactlyOnce", +} + +var EnumValuesBrokerTransportQualityOfService = map[string]BrokerTransportQualityOfService{ + "NotSpecified": BrokerTransportQualityOfServiceNotSpecified, + "BestEffort": BrokerTransportQualityOfServiceBestEffort, + "AtLeastOnce": BrokerTransportQualityOfServiceAtLeastOnce, + "AtMostOnce": BrokerTransportQualityOfServiceAtMostOnce, + "ExactlyOnce": BrokerTransportQualityOfServiceExactlyOnce, +} + +func (v BrokerTransportQualityOfService) String() string { + if s, ok := EnumNamesBrokerTransportQualityOfService[v]; ok { + return s + } + return "BrokerTransportQualityOfService(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/DataSetFieldContentMask.go b/pkg/fbs/comm/opcua/enumeration/DataSetFieldContentMask.go new file mode 100644 index 0000000..8b7d988 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/DataSetFieldContentMask.go @@ -0,0 +1,41 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type DataSetFieldContentMask uint32 + +const ( + DataSetFieldContentMaskStatusCode DataSetFieldContentMask = 1 + DataSetFieldContentMaskSourceTimestamp DataSetFieldContentMask = 2 + DataSetFieldContentMaskServerTimestamp DataSetFieldContentMask = 4 + DataSetFieldContentMaskSourcePicoSeconds DataSetFieldContentMask = 8 + DataSetFieldContentMaskServerPicoSeconds DataSetFieldContentMask = 16 + DataSetFieldContentMaskRawData DataSetFieldContentMask = 32 +) + +var EnumNamesDataSetFieldContentMask = map[DataSetFieldContentMask]string{ + DataSetFieldContentMaskStatusCode: "StatusCode", + DataSetFieldContentMaskSourceTimestamp: "SourceTimestamp", + DataSetFieldContentMaskServerTimestamp: "ServerTimestamp", + DataSetFieldContentMaskSourcePicoSeconds: "SourcePicoSeconds", + DataSetFieldContentMaskServerPicoSeconds: "ServerPicoSeconds", + DataSetFieldContentMaskRawData: "RawData", +} + +var EnumValuesDataSetFieldContentMask = map[string]DataSetFieldContentMask{ + "StatusCode": DataSetFieldContentMaskStatusCode, + "SourceTimestamp": DataSetFieldContentMaskSourceTimestamp, + "ServerTimestamp": DataSetFieldContentMaskServerTimestamp, + "SourcePicoSeconds": DataSetFieldContentMaskSourcePicoSeconds, + "ServerPicoSeconds": DataSetFieldContentMaskServerPicoSeconds, + "RawData": DataSetFieldContentMaskRawData, +} + +func (v DataSetFieldContentMask) String() string { + if s, ok := EnumNamesDataSetFieldContentMask[v]; ok { + return s + } + return "DataSetFieldContentMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/DataSetFieldFlags.go b/pkg/fbs/comm/opcua/enumeration/DataSetFieldFlags.go new file mode 100644 index 0000000..05c12a7 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/DataSetFieldFlags.go @@ -0,0 +1,26 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type DataSetFieldFlags uint16 + +const ( + DataSetFieldFlagsPromotedField DataSetFieldFlags = 1 +) + +var EnumNamesDataSetFieldFlags = map[DataSetFieldFlags]string{ + DataSetFieldFlagsPromotedField: "PromotedField", +} + +var EnumValuesDataSetFieldFlags = map[string]DataSetFieldFlags{ + "PromotedField": DataSetFieldFlagsPromotedField, +} + +func (v DataSetFieldFlags) String() string { + if s, ok := EnumNamesDataSetFieldFlags[v]; ok { + return s + } + return "DataSetFieldFlags(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/DataSetOrderingType.go b/pkg/fbs/comm/opcua/enumeration/DataSetOrderingType.go new file mode 100644 index 0000000..75cd8bb --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/DataSetOrderingType.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type DataSetOrderingType int32 + +const ( + DataSetOrderingTypeUndefined DataSetOrderingType = 0 + DataSetOrderingTypeAscendingWriterId DataSetOrderingType = 1 + DataSetOrderingTypeAscendingWriterIdSingle DataSetOrderingType = 2 +) + +var EnumNamesDataSetOrderingType = map[DataSetOrderingType]string{ + DataSetOrderingTypeUndefined: "Undefined", + DataSetOrderingTypeAscendingWriterId: "AscendingWriterId", + DataSetOrderingTypeAscendingWriterIdSingle: "AscendingWriterIdSingle", +} + +var EnumValuesDataSetOrderingType = map[string]DataSetOrderingType{ + "Undefined": DataSetOrderingTypeUndefined, + "AscendingWriterId": DataSetOrderingTypeAscendingWriterId, + "AscendingWriterIdSingle": DataSetOrderingTypeAscendingWriterIdSingle, +} + +func (v DataSetOrderingType) String() string { + if s, ok := EnumNamesDataSetOrderingType[v]; ok { + return s + } + return "DataSetOrderingType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/JsonDataSetMessageContentMask.go b/pkg/fbs/comm/opcua/enumeration/JsonDataSetMessageContentMask.go new file mode 100644 index 0000000..54f0350 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/JsonDataSetMessageContentMask.go @@ -0,0 +1,56 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type JsonDataSetMessageContentMask uint32 + +const ( + JsonDataSetMessageContentMaskDataSetWriterId JsonDataSetMessageContentMask = 1 + JsonDataSetMessageContentMaskMetaDataVersion JsonDataSetMessageContentMask = 2 + JsonDataSetMessageContentMaskSequenceNumber JsonDataSetMessageContentMask = 4 + JsonDataSetMessageContentMaskTimestamp JsonDataSetMessageContentMask = 8 + JsonDataSetMessageContentMaskStatus JsonDataSetMessageContentMask = 16 + JsonDataSetMessageContentMaskMessageType JsonDataSetMessageContentMask = 32 + JsonDataSetMessageContentMaskDataSetWriterName JsonDataSetMessageContentMask = 64 + JsonDataSetMessageContentMaskReversibleFieldEncoding JsonDataSetMessageContentMask = 128 + JsonDataSetMessageContentMaskPublisherId JsonDataSetMessageContentMask = 256 + JsonDataSetMessageContentMaskWriterGroupName JsonDataSetMessageContentMask = 512 + JsonDataSetMessageContentMaskMinorVersion JsonDataSetMessageContentMask = 1024 +) + +var EnumNamesJsonDataSetMessageContentMask = map[JsonDataSetMessageContentMask]string{ + JsonDataSetMessageContentMaskDataSetWriterId: "DataSetWriterId", + JsonDataSetMessageContentMaskMetaDataVersion: "MetaDataVersion", + JsonDataSetMessageContentMaskSequenceNumber: "SequenceNumber", + JsonDataSetMessageContentMaskTimestamp: "Timestamp", + JsonDataSetMessageContentMaskStatus: "Status", + JsonDataSetMessageContentMaskMessageType: "MessageType", + JsonDataSetMessageContentMaskDataSetWriterName: "DataSetWriterName", + JsonDataSetMessageContentMaskReversibleFieldEncoding: "ReversibleFieldEncoding", + JsonDataSetMessageContentMaskPublisherId: "PublisherId", + JsonDataSetMessageContentMaskWriterGroupName: "WriterGroupName", + JsonDataSetMessageContentMaskMinorVersion: "MinorVersion", +} + +var EnumValuesJsonDataSetMessageContentMask = map[string]JsonDataSetMessageContentMask{ + "DataSetWriterId": JsonDataSetMessageContentMaskDataSetWriterId, + "MetaDataVersion": JsonDataSetMessageContentMaskMetaDataVersion, + "SequenceNumber": JsonDataSetMessageContentMaskSequenceNumber, + "Timestamp": JsonDataSetMessageContentMaskTimestamp, + "Status": JsonDataSetMessageContentMaskStatus, + "MessageType": JsonDataSetMessageContentMaskMessageType, + "DataSetWriterName": JsonDataSetMessageContentMaskDataSetWriterName, + "ReversibleFieldEncoding": JsonDataSetMessageContentMaskReversibleFieldEncoding, + "PublisherId": JsonDataSetMessageContentMaskPublisherId, + "WriterGroupName": JsonDataSetMessageContentMaskWriterGroupName, + "MinorVersion": JsonDataSetMessageContentMaskMinorVersion, +} + +func (v JsonDataSetMessageContentMask) String() string { + if s, ok := EnumNamesJsonDataSetMessageContentMask[v]; ok { + return s + } + return "JsonDataSetMessageContentMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/JsonNetworkMessageContentMask.go b/pkg/fbs/comm/opcua/enumeration/JsonNetworkMessageContentMask.go new file mode 100644 index 0000000..51ffc48 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/JsonNetworkMessageContentMask.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type JsonNetworkMessageContentMask uint32 + +const ( + JsonNetworkMessageContentMaskNetworkMessageHeader JsonNetworkMessageContentMask = 1 + JsonNetworkMessageContentMaskDataSetMessageHeader JsonNetworkMessageContentMask = 2 + JsonNetworkMessageContentMaskSingleDataSetMessage JsonNetworkMessageContentMask = 4 + JsonNetworkMessageContentMaskPublisherId JsonNetworkMessageContentMask = 8 + JsonNetworkMessageContentMaskDataSetClassId JsonNetworkMessageContentMask = 16 + JsonNetworkMessageContentMaskReplyTo JsonNetworkMessageContentMask = 32 + JsonNetworkMessageContentMaskWriterGroupName JsonNetworkMessageContentMask = 64 +) + +var EnumNamesJsonNetworkMessageContentMask = map[JsonNetworkMessageContentMask]string{ + JsonNetworkMessageContentMaskNetworkMessageHeader: "NetworkMessageHeader", + JsonNetworkMessageContentMaskDataSetMessageHeader: "DataSetMessageHeader", + JsonNetworkMessageContentMaskSingleDataSetMessage: "SingleDataSetMessage", + JsonNetworkMessageContentMaskPublisherId: "PublisherId", + JsonNetworkMessageContentMaskDataSetClassId: "DataSetClassId", + JsonNetworkMessageContentMaskReplyTo: "ReplyTo", + JsonNetworkMessageContentMaskWriterGroupName: "WriterGroupName", +} + +var EnumValuesJsonNetworkMessageContentMask = map[string]JsonNetworkMessageContentMask{ + "NetworkMessageHeader": JsonNetworkMessageContentMaskNetworkMessageHeader, + "DataSetMessageHeader": JsonNetworkMessageContentMaskDataSetMessageHeader, + "SingleDataSetMessage": JsonNetworkMessageContentMaskSingleDataSetMessage, + "PublisherId": JsonNetworkMessageContentMaskPublisherId, + "DataSetClassId": JsonNetworkMessageContentMaskDataSetClassId, + "ReplyTo": JsonNetworkMessageContentMaskReplyTo, + "WriterGroupName": JsonNetworkMessageContentMaskWriterGroupName, +} + +func (v JsonNetworkMessageContentMask) String() string { + if s, ok := EnumNamesJsonNetworkMessageContentMask[v]; ok { + return s + } + return "JsonNetworkMessageContentMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/MessageSecurityMode.go b/pkg/fbs/comm/opcua/enumeration/MessageSecurityMode.go new file mode 100644 index 0000000..f06a4ac --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/MessageSecurityMode.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type MessageSecurityMode int32 + +const ( + MessageSecurityModeInvalid MessageSecurityMode = 0 + MessageSecurityModeNone MessageSecurityMode = 1 + MessageSecurityModeSign MessageSecurityMode = 2 + MessageSecurityModeSignAndEncrypt MessageSecurityMode = 3 +) + +var EnumNamesMessageSecurityMode = map[MessageSecurityMode]string{ + MessageSecurityModeInvalid: "Invalid", + MessageSecurityModeNone: "None", + MessageSecurityModeSign: "Sign", + MessageSecurityModeSignAndEncrypt: "SignAndEncrypt", +} + +var EnumValuesMessageSecurityMode = map[string]MessageSecurityMode{ + "Invalid": MessageSecurityModeInvalid, + "None": MessageSecurityModeNone, + "Sign": MessageSecurityModeSign, + "SignAndEncrypt": MessageSecurityModeSignAndEncrypt, +} + +func (v MessageSecurityMode) String() string { + if s, ok := EnumNamesMessageSecurityMode[v]; ok { + return s + } + return "MessageSecurityMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/OverrideValueHandling.go b/pkg/fbs/comm/opcua/enumeration/OverrideValueHandling.go new file mode 100644 index 0000000..21e0de9 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/OverrideValueHandling.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type OverrideValueHandling int32 + +const ( + OverrideValueHandlingDisabled OverrideValueHandling = 0 + OverrideValueHandlingLastUsableValue OverrideValueHandling = 1 + OverrideValueHandlingOverrideValue OverrideValueHandling = 2 +) + +var EnumNamesOverrideValueHandling = map[OverrideValueHandling]string{ + OverrideValueHandlingDisabled: "Disabled", + OverrideValueHandlingLastUsableValue: "LastUsableValue", + OverrideValueHandlingOverrideValue: "OverrideValue", +} + +var EnumValuesOverrideValueHandling = map[string]OverrideValueHandling{ + "Disabled": OverrideValueHandlingDisabled, + "LastUsableValue": OverrideValueHandlingLastUsableValue, + "OverrideValue": OverrideValueHandlingOverrideValue, +} + +func (v OverrideValueHandling) String() string { + if s, ok := EnumNamesOverrideValueHandling[v]; ok { + return s + } + return "OverrideValueHandling(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/PermissionType.go b/pkg/fbs/comm/opcua/enumeration/PermissionType.go new file mode 100644 index 0000000..9fa8d67 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/PermissionType.go @@ -0,0 +1,74 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type PermissionType uint32 + +const ( + PermissionTypeBrowse PermissionType = 1 + PermissionTypeReadRolePermissions PermissionType = 2 + PermissionTypeWriteAttribute PermissionType = 4 + PermissionTypeWriteRolePermissions PermissionType = 8 + PermissionTypeWriteHistorizing PermissionType = 16 + PermissionTypeRead PermissionType = 32 + PermissionTypeWrite PermissionType = 64 + PermissionTypeReadHistory PermissionType = 128 + PermissionTypeInsertHistory PermissionType = 256 + PermissionTypeModifyHistory PermissionType = 512 + PermissionTypeDeleteHistory PermissionType = 1024 + PermissionTypeReceiveEvents PermissionType = 2048 + PermissionTypeCall PermissionType = 4096 + PermissionTypeAddReference PermissionType = 8192 + PermissionTypeRemoveReference PermissionType = 16384 + PermissionTypeDeleteNode PermissionType = 32768 + PermissionTypeAddNode PermissionType = 65536 +) + +var EnumNamesPermissionType = map[PermissionType]string{ + PermissionTypeBrowse: "Browse", + PermissionTypeReadRolePermissions: "ReadRolePermissions", + PermissionTypeWriteAttribute: "WriteAttribute", + PermissionTypeWriteRolePermissions: "WriteRolePermissions", + PermissionTypeWriteHistorizing: "WriteHistorizing", + PermissionTypeRead: "Read", + PermissionTypeWrite: "Write", + PermissionTypeReadHistory: "ReadHistory", + PermissionTypeInsertHistory: "InsertHistory", + PermissionTypeModifyHistory: "ModifyHistory", + PermissionTypeDeleteHistory: "DeleteHistory", + PermissionTypeReceiveEvents: "ReceiveEvents", + PermissionTypeCall: "Call", + PermissionTypeAddReference: "AddReference", + PermissionTypeRemoveReference: "RemoveReference", + PermissionTypeDeleteNode: "DeleteNode", + PermissionTypeAddNode: "AddNode", +} + +var EnumValuesPermissionType = map[string]PermissionType{ + "Browse": PermissionTypeBrowse, + "ReadRolePermissions": PermissionTypeReadRolePermissions, + "WriteAttribute": PermissionTypeWriteAttribute, + "WriteRolePermissions": PermissionTypeWriteRolePermissions, + "WriteHistorizing": PermissionTypeWriteHistorizing, + "Read": PermissionTypeRead, + "Write": PermissionTypeWrite, + "ReadHistory": PermissionTypeReadHistory, + "InsertHistory": PermissionTypeInsertHistory, + "ModifyHistory": PermissionTypeModifyHistory, + "DeleteHistory": PermissionTypeDeleteHistory, + "ReceiveEvents": PermissionTypeReceiveEvents, + "Call": PermissionTypeCall, + "AddReference": PermissionTypeAddReference, + "RemoveReference": PermissionTypeRemoveReference, + "DeleteNode": PermissionTypeDeleteNode, + "AddNode": PermissionTypeAddNode, +} + +func (v PermissionType) String() string { + if s, ok := EnumNamesPermissionType[v]; ok { + return s + } + return "PermissionType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/PubSubConfigurationRefMask.go b/pkg/fbs/comm/opcua/enumeration/PubSubConfigurationRefMask.go new file mode 100644 index 0000000..c8a631f --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/PubSubConfigurationRefMask.go @@ -0,0 +1,62 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type PubSubConfigurationRefMask uint32 + +const ( + PubSubConfigurationRefMaskElementAdd PubSubConfigurationRefMask = 1 + PubSubConfigurationRefMaskElementMatch PubSubConfigurationRefMask = 2 + PubSubConfigurationRefMaskElementModify PubSubConfigurationRefMask = 4 + PubSubConfigurationRefMaskElementRemove PubSubConfigurationRefMask = 8 + PubSubConfigurationRefMaskReferenceWriter PubSubConfigurationRefMask = 16 + PubSubConfigurationRefMaskReferenceReader PubSubConfigurationRefMask = 32 + PubSubConfigurationRefMaskReferenceWriterGroup PubSubConfigurationRefMask = 64 + PubSubConfigurationRefMaskReferenceReaderGroup PubSubConfigurationRefMask = 128 + PubSubConfigurationRefMaskReferenceConnection PubSubConfigurationRefMask = 256 + PubSubConfigurationRefMaskReferencePubDataset PubSubConfigurationRefMask = 512 + PubSubConfigurationRefMaskReferenceSubDataset PubSubConfigurationRefMask = 1024 + PubSubConfigurationRefMaskReferenceSecurityGroup PubSubConfigurationRefMask = 2048 + PubSubConfigurationRefMaskReferencePushTarget PubSubConfigurationRefMask = 4096 +) + +var EnumNamesPubSubConfigurationRefMask = map[PubSubConfigurationRefMask]string{ + PubSubConfigurationRefMaskElementAdd: "ElementAdd", + PubSubConfigurationRefMaskElementMatch: "ElementMatch", + PubSubConfigurationRefMaskElementModify: "ElementModify", + PubSubConfigurationRefMaskElementRemove: "ElementRemove", + PubSubConfigurationRefMaskReferenceWriter: "ReferenceWriter", + PubSubConfigurationRefMaskReferenceReader: "ReferenceReader", + PubSubConfigurationRefMaskReferenceWriterGroup: "ReferenceWriterGroup", + PubSubConfigurationRefMaskReferenceReaderGroup: "ReferenceReaderGroup", + PubSubConfigurationRefMaskReferenceConnection: "ReferenceConnection", + PubSubConfigurationRefMaskReferencePubDataset: "ReferencePubDataset", + PubSubConfigurationRefMaskReferenceSubDataset: "ReferenceSubDataset", + PubSubConfigurationRefMaskReferenceSecurityGroup: "ReferenceSecurityGroup", + PubSubConfigurationRefMaskReferencePushTarget: "ReferencePushTarget", +} + +var EnumValuesPubSubConfigurationRefMask = map[string]PubSubConfigurationRefMask{ + "ElementAdd": PubSubConfigurationRefMaskElementAdd, + "ElementMatch": PubSubConfigurationRefMaskElementMatch, + "ElementModify": PubSubConfigurationRefMaskElementModify, + "ElementRemove": PubSubConfigurationRefMaskElementRemove, + "ReferenceWriter": PubSubConfigurationRefMaskReferenceWriter, + "ReferenceReader": PubSubConfigurationRefMaskReferenceReader, + "ReferenceWriterGroup": PubSubConfigurationRefMaskReferenceWriterGroup, + "ReferenceReaderGroup": PubSubConfigurationRefMaskReferenceReaderGroup, + "ReferenceConnection": PubSubConfigurationRefMaskReferenceConnection, + "ReferencePubDataset": PubSubConfigurationRefMaskReferencePubDataset, + "ReferenceSubDataset": PubSubConfigurationRefMaskReferenceSubDataset, + "ReferenceSecurityGroup": PubSubConfigurationRefMaskReferenceSecurityGroup, + "ReferencePushTarget": PubSubConfigurationRefMaskReferencePushTarget, +} + +func (v PubSubConfigurationRefMask) String() string { + if s, ok := EnumNamesPubSubConfigurationRefMask[v]; ok { + return s + } + return "PubSubConfigurationRefMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/StructureType.go b/pkg/fbs/comm/opcua/enumeration/StructureType.go new file mode 100644 index 0000000..63e8b86 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/StructureType.go @@ -0,0 +1,38 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type StructureType int32 + +const ( + StructureTypeStructure StructureType = 0 + StructureTypeStructureWithOptionalFields StructureType = 1 + StructureTypeUnion StructureType = 2 + StructureTypeStructureWithSubtypedValues StructureType = 3 + StructureTypeUnionWithSubtypedValues StructureType = 4 +) + +var EnumNamesStructureType = map[StructureType]string{ + StructureTypeStructure: "Structure", + StructureTypeStructureWithOptionalFields: "StructureWithOptionalFields", + StructureTypeUnion: "Union", + StructureTypeStructureWithSubtypedValues: "StructureWithSubtypedValues", + StructureTypeUnionWithSubtypedValues: "UnionWithSubtypedValues", +} + +var EnumValuesStructureType = map[string]StructureType{ + "Structure": StructureTypeStructure, + "StructureWithOptionalFields": StructureTypeStructureWithOptionalFields, + "Union": StructureTypeUnion, + "StructureWithSubtypedValues": StructureTypeStructureWithSubtypedValues, + "UnionWithSubtypedValues": StructureTypeUnionWithSubtypedValues, +} + +func (v StructureType) String() string { + if s, ok := EnumNamesStructureType[v]; ok { + return s + } + return "StructureType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/UadpDataSetMessageContentMask.go b/pkg/fbs/comm/opcua/enumeration/UadpDataSetMessageContentMask.go new file mode 100644 index 0000000..42566e9 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/UadpDataSetMessageContentMask.go @@ -0,0 +1,41 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type UadpDataSetMessageContentMask uint32 + +const ( + UadpDataSetMessageContentMaskTimestamp UadpDataSetMessageContentMask = 1 + UadpDataSetMessageContentMaskPicoSeconds UadpDataSetMessageContentMask = 2 + UadpDataSetMessageContentMaskStatus UadpDataSetMessageContentMask = 4 + UadpDataSetMessageContentMaskMajorVersion UadpDataSetMessageContentMask = 8 + UadpDataSetMessageContentMaskMinorVersion UadpDataSetMessageContentMask = 16 + UadpDataSetMessageContentMaskSequenceNumber UadpDataSetMessageContentMask = 32 +) + +var EnumNamesUadpDataSetMessageContentMask = map[UadpDataSetMessageContentMask]string{ + UadpDataSetMessageContentMaskTimestamp: "Timestamp", + UadpDataSetMessageContentMaskPicoSeconds: "PicoSeconds", + UadpDataSetMessageContentMaskStatus: "Status", + UadpDataSetMessageContentMaskMajorVersion: "MajorVersion", + UadpDataSetMessageContentMaskMinorVersion: "MinorVersion", + UadpDataSetMessageContentMaskSequenceNumber: "SequenceNumber", +} + +var EnumValuesUadpDataSetMessageContentMask = map[string]UadpDataSetMessageContentMask{ + "Timestamp": UadpDataSetMessageContentMaskTimestamp, + "PicoSeconds": UadpDataSetMessageContentMaskPicoSeconds, + "Status": UadpDataSetMessageContentMaskStatus, + "MajorVersion": UadpDataSetMessageContentMaskMajorVersion, + "MinorVersion": UadpDataSetMessageContentMaskMinorVersion, + "SequenceNumber": UadpDataSetMessageContentMaskSequenceNumber, +} + +func (v UadpDataSetMessageContentMask) String() string { + if s, ok := EnumNamesUadpDataSetMessageContentMask[v]; ok { + return s + } + return "UadpDataSetMessageContentMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/UadpNetworkMessageContentMask.go b/pkg/fbs/comm/opcua/enumeration/UadpNetworkMessageContentMask.go new file mode 100644 index 0000000..f3bfc2b --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/UadpNetworkMessageContentMask.go @@ -0,0 +1,56 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type UadpNetworkMessageContentMask uint32 + +const ( + UadpNetworkMessageContentMaskPublisherId UadpNetworkMessageContentMask = 1 + UadpNetworkMessageContentMaskGroupHeader UadpNetworkMessageContentMask = 2 + UadpNetworkMessageContentMaskWriterGroupId UadpNetworkMessageContentMask = 4 + UadpNetworkMessageContentMaskGroupVersion UadpNetworkMessageContentMask = 8 + UadpNetworkMessageContentMaskNetworkMessageNumber UadpNetworkMessageContentMask = 16 + UadpNetworkMessageContentMaskSequenceNumber UadpNetworkMessageContentMask = 32 + UadpNetworkMessageContentMaskPayloadHeader UadpNetworkMessageContentMask = 64 + UadpNetworkMessageContentMaskTimestamp UadpNetworkMessageContentMask = 128 + UadpNetworkMessageContentMaskPicoSeconds UadpNetworkMessageContentMask = 256 + UadpNetworkMessageContentMaskDataSetClassId UadpNetworkMessageContentMask = 512 + UadpNetworkMessageContentMaskPromotedFields UadpNetworkMessageContentMask = 1024 +) + +var EnumNamesUadpNetworkMessageContentMask = map[UadpNetworkMessageContentMask]string{ + UadpNetworkMessageContentMaskPublisherId: "PublisherId", + UadpNetworkMessageContentMaskGroupHeader: "GroupHeader", + UadpNetworkMessageContentMaskWriterGroupId: "WriterGroupId", + UadpNetworkMessageContentMaskGroupVersion: "GroupVersion", + UadpNetworkMessageContentMaskNetworkMessageNumber: "NetworkMessageNumber", + UadpNetworkMessageContentMaskSequenceNumber: "SequenceNumber", + UadpNetworkMessageContentMaskPayloadHeader: "PayloadHeader", + UadpNetworkMessageContentMaskTimestamp: "Timestamp", + UadpNetworkMessageContentMaskPicoSeconds: "PicoSeconds", + UadpNetworkMessageContentMaskDataSetClassId: "DataSetClassId", + UadpNetworkMessageContentMaskPromotedFields: "PromotedFields", +} + +var EnumValuesUadpNetworkMessageContentMask = map[string]UadpNetworkMessageContentMask{ + "PublisherId": UadpNetworkMessageContentMaskPublisherId, + "GroupHeader": UadpNetworkMessageContentMaskGroupHeader, + "WriterGroupId": UadpNetworkMessageContentMaskWriterGroupId, + "GroupVersion": UadpNetworkMessageContentMaskGroupVersion, + "NetworkMessageNumber": UadpNetworkMessageContentMaskNetworkMessageNumber, + "SequenceNumber": UadpNetworkMessageContentMaskSequenceNumber, + "PayloadHeader": UadpNetworkMessageContentMaskPayloadHeader, + "Timestamp": UadpNetworkMessageContentMaskTimestamp, + "PicoSeconds": UadpNetworkMessageContentMaskPicoSeconds, + "DataSetClassId": UadpNetworkMessageContentMaskDataSetClassId, + "PromotedFields": UadpNetworkMessageContentMaskPromotedFields, +} + +func (v UadpNetworkMessageContentMask) String() string { + if s, ok := EnumNamesUadpNetworkMessageContentMask[v]; ok { + return s + } + return "UadpNetworkMessageContentMask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/opcua/enumeration/UserTokenType.go b/pkg/fbs/comm/opcua/enumeration/UserTokenType.go new file mode 100644 index 0000000..26acc40 --- /dev/null +++ b/pkg/fbs/comm/opcua/enumeration/UserTokenType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package enumeration + +import "strconv" + +type UserTokenType int32 + +const ( + UserTokenTypeAnonymous UserTokenType = 0 + UserTokenTypeUserName UserTokenType = 1 + UserTokenTypeCertificate UserTokenType = 2 + UserTokenTypeIssuedToken UserTokenType = 3 +) + +var EnumNamesUserTokenType = map[UserTokenType]string{ + UserTokenTypeAnonymous: "Anonymous", + UserTokenTypeUserName: "UserName", + UserTokenTypeCertificate: "Certificate", + UserTokenTypeIssuedToken: "IssuedToken", +} + +var EnumValuesUserTokenType = map[string]UserTokenType{ + "Anonymous": UserTokenTypeAnonymous, + "UserName": UserTokenTypeUserName, + "Certificate": UserTokenTypeCertificate, + "IssuedToken": UserTokenTypeIssuedToken, +} + +func (v UserTokenType) String() string { + if s, ok := EnumNamesUserTokenType[v]; ok { + return s + } + return "UserTokenType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/scheduler/fbs/ParameterEventTick.go b/pkg/fbs/common/scheduler/fbs/ParameterEventTick.go new file mode 100644 index 0000000..9293833 --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs/ParameterEventTick.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Parameter transfered to a callable during tick event call (SchedEventType::SCHED_EVENT_TICK) +type ParameterEventTickT struct { + CalculatedStartTime uint64 `json:"calculatedStartTime"` +} + +func (t *ParameterEventTickT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ParameterEventTickStart(builder) + ParameterEventTickAddCalculatedStartTime(builder, t.CalculatedStartTime) + return ParameterEventTickEnd(builder) +} + +func (rcv *ParameterEventTick) UnPackTo(t *ParameterEventTickT) { + t.CalculatedStartTime = rcv.CalculatedStartTime() +} + +func (rcv *ParameterEventTick) UnPack() *ParameterEventTickT { + if rcv == nil { return nil } + t := &ParameterEventTickT{} + rcv.UnPackTo(t) + return t +} + +type ParameterEventTick struct { + _tab flatbuffers.Table +} + +func GetRootAsParameterEventTick(buf []byte, offset flatbuffers.UOffsetT) *ParameterEventTick { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ParameterEventTick{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsParameterEventTick(buf []byte, offset flatbuffers.UOffsetT) *ParameterEventTick { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ParameterEventTick{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ParameterEventTick) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ParameterEventTick) Table() flatbuffers.Table { + return rcv._tab +} + +/// Calculated start time of task where the callable is executed +func (rcv *ParameterEventTick) CalculatedStartTime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// Calculated start time of task where the callable is executed +func (rcv *ParameterEventTick) MutateCalculatedStartTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func ParameterEventTickStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ParameterEventTickAddCalculatedStartTime(builder *flatbuffers.Builder, calculatedStartTime uint64) { + builder.PrependUint64Slot(0, calculatedStartTime, 0) +} +func ParameterEventTickEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdTorqueData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdTorqueData.go new file mode 100644 index 0000000..09fc94f --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdTorqueData.go @@ -0,0 +1,123 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis torque command +type AxsCmdTorqueDataT struct { + TargetTrq float64 `json:"targetTrq"` + TrqRamp float64 `json:"trqRamp"` + Lim *DynamicLimitsT `json:"lim"` +} + +func (t *AxsCmdTorqueDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + limOffset := t.Lim.Pack(builder) + AxsCmdTorqueDataStart(builder) + AxsCmdTorqueDataAddTargetTrq(builder, t.TargetTrq) + AxsCmdTorqueDataAddTrqRamp(builder, t.TrqRamp) + AxsCmdTorqueDataAddLim(builder, limOffset) + return AxsCmdTorqueDataEnd(builder) +} + +func (rcv *AxsCmdTorqueData) UnPackTo(t *AxsCmdTorqueDataT) { + t.TargetTrq = rcv.TargetTrq() + t.TrqRamp = rcv.TrqRamp() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *AxsCmdTorqueData) UnPack() *AxsCmdTorqueDataT { + if rcv == nil { return nil } + t := &AxsCmdTorqueDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdTorqueData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdTorqueData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdTorqueData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdTorqueData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdTorqueData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdTorqueData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdTorqueData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdTorqueData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdTorqueData) Table() flatbuffers.Table { + return rcv._tab +} + +/// commanded target torque (can be negative) +func (rcv *AxsCmdTorqueData) TargetTrq() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 1.0 +} + +/// commanded target torque (can be negative) +func (rcv *AxsCmdTorqueData) MutateTargetTrq(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// commanded target torque ramp (only positive) +func (rcv *AxsCmdTorqueData) TrqRamp() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded target torque ramp (only positive) +func (rcv *AxsCmdTorqueData) MutateTrqRamp(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// dynamic limits for the motion of this command +func (rcv *AxsCmdTorqueData) Lim(obj *DynamicLimits) *DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + 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 AxsCmdTorqueDataStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func AxsCmdTorqueDataAddTargetTrq(builder *flatbuffers.Builder, targetTrq float64) { + builder.PrependFloat64Slot(0, targetTrq, 1.0) +} +func AxsCmdTorqueDataAddTrqRamp(builder *flatbuffers.Builder, trqRamp float64) { + builder.PrependFloat64Slot(1, trqRamp, 0.0) +} +func AxsCmdTorqueDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(lim), 0) +} +func AxsCmdTorqueDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/drivecmd/fbtypes/HomingBehavior.go b/pkg/fbs/motion/drivecmd/fbtypes/HomingBehavior.go new file mode 100644 index 0000000..e16e1e0 --- /dev/null +++ b/pkg/fbs/motion/drivecmd/fbtypes/HomingBehavior.go @@ -0,0 +1,30 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// homing behavior to indicates use which movement behavior or which reference mark to establish the reference position +type HomingBehavior int8 + +const ( + HomingBehaviorCURRENT_POSITION HomingBehavior = 0 + HomingBehaviorHOME_SWITCH HomingBehavior = 1 +) + +var EnumNamesHomingBehavior = map[HomingBehavior]string{ + HomingBehaviorCURRENT_POSITION: "CURRENT_POSITION", + HomingBehaviorHOME_SWITCH: "HOME_SWITCH", +} + +var EnumValuesHomingBehavior = map[string]HomingBehavior{ + "CURRENT_POSITION": HomingBehaviorCURRENT_POSITION, + "HOME_SWITCH": HomingBehaviorHOME_SWITCH, +} + +func (v HomingBehavior) String() string { + if s, ok := EnumNamesHomingBehavior[v]; ok { + return s + } + return "HomingBehavior(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/robotics/fbtypes/CmdKinMoveToPointData.go b/pkg/fbs/motion/robotics/fbtypes/CmdKinMoveToPointData.go new file mode 100644 index 0000000..0f6d9a0 --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/CmdKinMoveToPointData.go @@ -0,0 +1,125 @@ +// 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/v2/pkg/fbs/motion/core/fbtypes" +) + +/// parameters for the move to point commands for a kinematic +type CmdKinMoveToPointDataT struct { + PointName string `json:"pointName"` + Lim *motion__core__fbtypes.DynamicLimitsT `json:"lim"` + Buffered bool `json:"buffered"` +} + +func (t *CmdKinMoveToPointDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pointNameOffset := flatbuffers.UOffsetT(0) + if t.PointName != "" { + pointNameOffset = builder.CreateString(t.PointName) + } + limOffset := t.Lim.Pack(builder) + CmdKinMoveToPointDataStart(builder) + CmdKinMoveToPointDataAddPointName(builder, pointNameOffset) + CmdKinMoveToPointDataAddLim(builder, limOffset) + CmdKinMoveToPointDataAddBuffered(builder, t.Buffered) + return CmdKinMoveToPointDataEnd(builder) +} + +func (rcv *CmdKinMoveToPointData) UnPackTo(t *CmdKinMoveToPointDataT) { + t.PointName = string(rcv.PointName()) + t.Lim = rcv.Lim(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *CmdKinMoveToPointData) UnPack() *CmdKinMoveToPointDataT { + if rcv == nil { return nil } + t := &CmdKinMoveToPointDataT{} + rcv.UnPackTo(t) + return t +} + +type CmdKinMoveToPointData struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdKinMoveToPointData(buf []byte, offset flatbuffers.UOffsetT) *CmdKinMoveToPointData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdKinMoveToPointData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdKinMoveToPointData(buf []byte, offset flatbuffers.UOffsetT) *CmdKinMoveToPointData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdKinMoveToPointData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdKinMoveToPointData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdKinMoveToPointData) Table() flatbuffers.Table { + return rcv._tab +} + +/// pointName +func (rcv *CmdKinMoveToPointData) PointName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// pointName +/// dynamic limits for the motion of this command +func (rcv *CmdKinMoveToPointData) Lim(obj *motion__core__fbtypes.DynamicLimits) *motion__core__fbtypes.DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + 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 +/// should this be a buffered command? +func (rcv *CmdKinMoveToPointData) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// should this be a buffered command? +func (rcv *CmdKinMoveToPointData) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func CmdKinMoveToPointDataStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CmdKinMoveToPointDataAddPointName(builder *flatbuffers.Builder, pointName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pointName), 0) +} +func CmdKinMoveToPointDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(lim), 0) +} +func CmdKinMoveToPointDataAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(2, buffered, true) +} +func CmdKinMoveToPointDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/CmdOptionBeltSync.go b/pkg/fbs/motion/robotics/fbtypes/CmdOptionBeltSync.go new file mode 100644 index 0000000..1c4be2d --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/CmdOptionBeltSync.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters for the command option belt sync +type CmdOptionBeltSyncT struct { + PermType string `json:"permType"` + BeltName string `json:"beltName"` + BeltValue float64 `json:"beltValue"` +} + +func (t *CmdOptionBeltSyncT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + permTypeOffset := flatbuffers.UOffsetT(0) + if t.PermType != "" { + permTypeOffset = builder.CreateString(t.PermType) + } + beltNameOffset := flatbuffers.UOffsetT(0) + if t.BeltName != "" { + beltNameOffset = builder.CreateString(t.BeltName) + } + CmdOptionBeltSyncStart(builder) + CmdOptionBeltSyncAddPermType(builder, permTypeOffset) + CmdOptionBeltSyncAddBeltName(builder, beltNameOffset) + CmdOptionBeltSyncAddBeltValue(builder, t.BeltValue) + return CmdOptionBeltSyncEnd(builder) +} + +func (rcv *CmdOptionBeltSync) UnPackTo(t *CmdOptionBeltSyncT) { + t.PermType = string(rcv.PermType()) + t.BeltName = string(rcv.BeltName()) + t.BeltValue = rcv.BeltValue() +} + +func (rcv *CmdOptionBeltSync) UnPack() *CmdOptionBeltSyncT { + if rcv == nil { return nil } + t := &CmdOptionBeltSyncT{} + rcv.UnPackTo(t) + return t +} + +type CmdOptionBeltSync struct { + _tab flatbuffers.Table +} + +func GetRootAsCmdOptionBeltSync(buf []byte, offset flatbuffers.UOffsetT) *CmdOptionBeltSync { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CmdOptionBeltSync{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmdOptionBeltSync(buf []byte, offset flatbuffers.UOffsetT) *CmdOptionBeltSync { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CmdOptionBeltSync{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CmdOptionBeltSync) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CmdOptionBeltSync) Table() flatbuffers.Table { + return rcv._tab +} + +/// permanent type (e.g. "PermOn", "PermOff") +func (rcv *CmdOptionBeltSync) PermType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// permanent type (e.g. "PermOn", "PermOff") +/// belt name +func (rcv *CmdOptionBeltSync) BeltName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// belt name +/// belt value +func (rcv *CmdOptionBeltSync) BeltValue() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// belt value +func (rcv *CmdOptionBeltSync) MutateBeltValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func CmdOptionBeltSyncStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CmdOptionBeltSyncAddPermType(builder *flatbuffers.Builder, permType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(permType), 0) +} +func CmdOptionBeltSyncAddBeltName(builder *flatbuffers.Builder, beltName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(beltName), 0) +} +func CmdOptionBeltSyncAddBeltValue(builder *flatbuffers.Builder, beltValue float64) { + builder.PrependFloat64Slot(2, beltValue, 0.0) +} +func CmdOptionBeltSyncEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/Point.go b/pkg/fbs/motion/robotics/fbtypes/Point.go new file mode 100644 index 0000000..cdb5f3c --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/Point.go @@ -0,0 +1,185 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + "bytes" + flatbuffers "github.com/google/flatbuffers/go" +) + +type PointT struct { + Name string `json:"name"` + Position *PositionT `json:"position"` + ReferenceSystem ReferenceSystem `json:"referenceSystem"` + Description string `json:"description"` + UiData string `json:"uiData"` +} + +func (t *PointT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + positionOffset := t.Position.Pack(builder) + descriptionOffset := flatbuffers.UOffsetT(0) + if t.Description != "" { + descriptionOffset = builder.CreateString(t.Description) + } + uiDataOffset := flatbuffers.UOffsetT(0) + if t.UiData != "" { + uiDataOffset = builder.CreateString(t.UiData) + } + PointStart(builder) + PointAddName(builder, nameOffset) + PointAddPosition(builder, positionOffset) + PointAddReferenceSystem(builder, t.ReferenceSystem) + PointAddDescription(builder, descriptionOffset) + PointAddUiData(builder, uiDataOffset) + return PointEnd(builder) +} + +func (rcv *Point) UnPackTo(t *PointT) { + t.Name = string(rcv.Name()) + t.Position = rcv.Position(nil).UnPack() + t.ReferenceSystem = rcv.ReferenceSystem() + t.Description = string(rcv.Description()) + t.UiData = string(rcv.UiData()) +} + +func (rcv *Point) UnPack() *PointT { + if rcv == nil { return nil } + t := &PointT{} + rcv.UnPackTo(t) + return t +} + +type Point struct { + _tab flatbuffers.Table +} + +func GetRootAsPoint(buf []byte, offset flatbuffers.UOffsetT) *Point { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Point{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPoint(buf []byte, offset flatbuffers.UOffsetT) *Point { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Point{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Point) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Point) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Point) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func PointKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { + obj1 := &Point{} + obj2 := &Point{} + obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + return string(obj1.Name()) < string(obj2.Name()) +} + +func (rcv *Point) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { + span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + start := flatbuffers.UOffsetT(0) + bKey := []byte(key) + for span != 0 { + middle := span / 2 + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + obj := &Point{} + obj.Init(buf, tableOffset) + comp := bytes.Compare(obj.Name(), bKey) + if comp > 0 { + span = middle + } else if comp < 0 { + middle += 1 + start += middle + span -= middle + } else { + rcv.Init(buf, tableOffset) + return true + } + } + return false +} + +func (rcv *Point) Position(obj *Position) *Position { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Position) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Point) ReferenceSystem() ReferenceSystem { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return ReferenceSystem(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Point) MutateReferenceSystem(n ReferenceSystem) bool { + return rcv._tab.MutateByteSlot(8, byte(n)) +} + +func (rcv *Point) Description() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Point) UiData() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func PointStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func PointAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func PointAddPosition(builder *flatbuffers.Builder, position flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(position), 0) +} +func PointAddReferenceSystem(builder *flatbuffers.Builder, referenceSystem ReferenceSystem) { + builder.PrependByteSlot(2, byte(referenceSystem), 0) +} +func PointAddDescription(builder *flatbuffers.Builder, description flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(description), 0) +} +func PointAddUiData(builder *flatbuffers.Builder, uiData flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(uiData), 0) +} +func PointEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/PointCollection.go b/pkg/fbs/motion/robotics/fbtypes/PointCollection.go new file mode 100644 index 0000000..81889c3 --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/PointCollection.go @@ -0,0 +1,117 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type PointCollectionT struct { + Points []*PointT `json:"points"` +} + +func (t *PointCollectionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pointsOffset := flatbuffers.UOffsetT(0) + if t.Points != nil { + pointsLength := len(t.Points) + pointsOffsets := make([]flatbuffers.UOffsetT, pointsLength) + for j := 0; j < pointsLength; j++ { + pointsOffsets[j] = t.Points[j].Pack(builder) + } + PointCollectionStartPointsVector(builder, pointsLength) + for j := pointsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(pointsOffsets[j]) + } + pointsOffset = builder.EndVector(pointsLength) + } + PointCollectionStart(builder) + PointCollectionAddPoints(builder, pointsOffset) + return PointCollectionEnd(builder) +} + +func (rcv *PointCollection) UnPackTo(t *PointCollectionT) { + pointsLength := rcv.PointsLength() + t.Points = make([]*PointT, pointsLength) + for j := 0; j < pointsLength; j++ { + x := Point{} + rcv.Points(&x, j) + t.Points[j] = x.UnPack() + } +} + +func (rcv *PointCollection) UnPack() *PointCollectionT { + if rcv == nil { return nil } + t := &PointCollectionT{} + rcv.UnPackTo(t) + return t +} + +type PointCollection struct { + _tab flatbuffers.Table +} + +func GetRootAsPointCollection(buf []byte, offset flatbuffers.UOffsetT) *PointCollection { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &PointCollection{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPointCollection(buf []byte, offset flatbuffers.UOffsetT) *PointCollection { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &PointCollection{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *PointCollection) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *PointCollection) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *PointCollection) Points(obj *Point, 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 *PointCollection) PointsByKey(obj *Point, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *PointCollection) PointsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func PointCollectionStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func PointCollectionAddPoints(builder *flatbuffers.Builder, points flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(points), 0) +} +func PointCollectionStartPointsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func PointCollectionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/Position.go b/pkg/fbs/motion/robotics/fbtypes/Position.go new file mode 100644 index 0000000..e68ee9a --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/Position.go @@ -0,0 +1,119 @@ +// 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/v2/pkg/fbs/motion/core/fbtypes" +) + +type PositionT struct { + Entries []*PositionEntryT `json:"entries"` +} + +func (t *PositionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + entriesOffset := flatbuffers.UOffsetT(0) + if t.Entries != nil { + entriesLength := len(t.Entries) + entriesOffsets := make([]flatbuffers.UOffsetT, entriesLength) + for j := 0; j < entriesLength; j++ { + entriesOffsets[j] = t.Entries[j].Pack(builder) + } + PositionStartEntriesVector(builder, entriesLength) + for j := entriesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(entriesOffsets[j]) + } + entriesOffset = builder.EndVector(entriesLength) + } + PositionStart(builder) + PositionAddEntries(builder, entriesOffset) + return PositionEnd(builder) +} + +func (rcv *Position) UnPackTo(t *PositionT) { + entriesLength := rcv.EntriesLength() + t.Entries = make([]*PositionEntryT, entriesLength) + for j := 0; j < entriesLength; j++ { + x := PositionEntry{} + rcv.Entries(&x, j) + t.Entries[j] = x.UnPack() + } +} + +func (rcv *Position) UnPack() *PositionT { + if rcv == nil { return nil } + t := &PositionT{} + rcv.UnPackTo(t) + return t +} + +type Position struct { + _tab flatbuffers.Table +} + +func GetRootAsPosition(buf []byte, offset flatbuffers.UOffsetT) *Position { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Position{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPosition(buf []byte, offset flatbuffers.UOffsetT) *Position { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Position{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Position) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Position) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Position) Entries(obj *PositionEntry, 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 *Position) EntriesByKey(obj *PositionEntry, key motion__core__fbtypes.Meaning) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *Position) EntriesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func PositionStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func PositionAddEntries(builder *flatbuffers.Builder, entries flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(entries), 0) +} +func PositionStartEntriesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func PositionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/PositionEntry.go b/pkg/fbs/motion/robotics/fbtypes/PositionEntry.go new file mode 100644 index 0000000..1a5f564 --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/PositionEntry.go @@ -0,0 +1,153 @@ +// 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/v2/pkg/fbs/motion/core/fbtypes" +) + +type PositionEntryT struct { + Meaning motion__core__fbtypes.Meaning `json:"meaning"` + Value float64 `json:"value"` + Unit string `json:"unit"` +} + +func (t *PositionEntryT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + unitOffset := flatbuffers.UOffsetT(0) + if t.Unit != "" { + unitOffset = builder.CreateString(t.Unit) + } + PositionEntryStart(builder) + PositionEntryAddMeaning(builder, t.Meaning) + PositionEntryAddValue(builder, t.Value) + PositionEntryAddUnit(builder, unitOffset) + return PositionEntryEnd(builder) +} + +func (rcv *PositionEntry) UnPackTo(t *PositionEntryT) { + t.Meaning = rcv.Meaning() + t.Value = rcv.Value() + t.Unit = string(rcv.Unit()) +} + +func (rcv *PositionEntry) UnPack() *PositionEntryT { + if rcv == nil { return nil } + t := &PositionEntryT{} + rcv.UnPackTo(t) + return t +} + +type PositionEntry struct { + _tab flatbuffers.Table +} + +func GetRootAsPositionEntry(buf []byte, offset flatbuffers.UOffsetT) *PositionEntry { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &PositionEntry{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsPositionEntry(buf []byte, offset flatbuffers.UOffsetT) *PositionEntry { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &PositionEntry{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *PositionEntry) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *PositionEntry) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *PositionEntry) Meaning() motion__core__fbtypes.Meaning { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return motion__core__fbtypes.Meaning(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *PositionEntry) MutateMeaning(n motion__core__fbtypes.Meaning) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func PositionEntryKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { + obj1 := &PositionEntry{} + obj2 := &PositionEntry{} + obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + return obj1.Meaning() < obj2.Meaning() +} + +func (rcv *PositionEntry) LookupByKey(key motion__core__fbtypes.Meaning, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { + span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + start := flatbuffers.UOffsetT(0) + for span != 0 { + middle := span / 2 + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + obj := &PositionEntry{} + obj.Init(buf, tableOffset) + val := obj.Meaning() + comp := 0 + if val > key { + comp = 1 + } else if val < key { + comp = -1 + } + if comp > 0 { + span = middle + } else if comp < 0 { + middle += 1 + start += middle + span -= middle + } else { + rcv.Init(buf, tableOffset) + return true + } + } + return false +} + +func (rcv *PositionEntry) 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 *PositionEntry) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *PositionEntry) Unit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func PositionEntryStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func PositionEntryAddMeaning(builder *flatbuffers.Builder, meaning motion__core__fbtypes.Meaning) { + builder.PrependInt8Slot(0, int8(meaning), 0) +} +func PositionEntryAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(1, value, 0.0) +} +func PositionEntryAddUnit(builder *flatbuffers.Builder, unit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(unit), 0) +} +func PositionEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/robotics/fbtypes/ReferenceSystem.go b/pkg/fbs/motion/robotics/fbtypes/ReferenceSystem.go new file mode 100644 index 0000000..fb74495 --- /dev/null +++ b/pkg/fbs/motion/robotics/fbtypes/ReferenceSystem.go @@ -0,0 +1,39 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +type ReferenceSystem byte + +const ( + /// default value + ReferenceSystemUNDEFINED ReferenceSystem = 0 + /// custom semantics + ReferenceSystemCUSTOM ReferenceSystem = 1 + /// axis coordinate system + ReferenceSystemACS ReferenceSystem = 2 + /// machine coordinate system + ReferenceSystemMCS ReferenceSystem = 3 +) + +var EnumNamesReferenceSystem = map[ReferenceSystem]string{ + ReferenceSystemUNDEFINED: "UNDEFINED", + ReferenceSystemCUSTOM: "CUSTOM", + ReferenceSystemACS: "ACS", + ReferenceSystemMCS: "MCS", +} + +var EnumValuesReferenceSystem = map[string]ReferenceSystem{ + "UNDEFINED": ReferenceSystemUNDEFINED, + "CUSTOM": ReferenceSystemCUSTOM, + "ACS": ReferenceSystemACS, + "MCS": ReferenceSystemMCS, +} + +func (v ReferenceSystem) String() string { + if s, ok := EnumNamesReferenceSystem[v]; ok { + return s + } + return "ReferenceSystem(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/plc/cmp/datalayer/fbs/AsyncTimeoutSettings.go b/pkg/fbs/plc/cmp/datalayer/fbs/AsyncTimeoutSettings.go new file mode 100644 index 0000000..42ba880 --- /dev/null +++ b/pkg/fbs/plc/cmp/datalayer/fbs/AsyncTimeoutSettings.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// This object defines the Timeouts for Asynchronus Methods +type AsyncTimeoutSettingsT struct { + Timeout uint64 `json:"Timeout"` +} + +func (t *AsyncTimeoutSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AsyncTimeoutSettingsStart(builder) + AsyncTimeoutSettingsAddTimeout(builder, t.Timeout) + return AsyncTimeoutSettingsEnd(builder) +} + +func (rcv *AsyncTimeoutSettings) UnPackTo(t *AsyncTimeoutSettingsT) { + t.Timeout = rcv.Timeout() +} + +func (rcv *AsyncTimeoutSettings) UnPack() *AsyncTimeoutSettingsT { + if rcv == nil { return nil } + t := &AsyncTimeoutSettingsT{} + rcv.UnPackTo(t) + return t +} + +type AsyncTimeoutSettings struct { + _tab flatbuffers.Table +} + +func GetRootAsAsyncTimeoutSettings(buf []byte, offset flatbuffers.UOffsetT) *AsyncTimeoutSettings { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AsyncTimeoutSettings{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAsyncTimeoutSettings(buf []byte, offset flatbuffers.UOffsetT) *AsyncTimeoutSettings { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AsyncTimeoutSettings{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AsyncTimeoutSettings) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AsyncTimeoutSettings) Table() flatbuffers.Table { + return rcv._tab +} + +/// Variable that the defines the maximal waited time (ms) for an asynchronus Mehtod +func (rcv *AsyncTimeoutSettings) Timeout() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// Variable that the defines the maximal waited time (ms) for an asynchronus Mehtod +func (rcv *AsyncTimeoutSettings) MutateTimeout(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func AsyncTimeoutSettingsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AsyncTimeoutSettingsAddTimeout(builder *flatbuffers.Builder, timeout uint64) { + builder.PrependUint64Slot(0, timeout, 0) +} +func AsyncTimeoutSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfo.go b/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfo.go new file mode 100644 index 0000000..766e8ad --- /dev/null +++ b/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfo.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// License Object +type LicenseInfoT struct { + Name string `json:"name"` + Version string `json:"version"` + Quantity uint32 `json:"quantity"` +} + +func (t *LicenseInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + versionOffset := flatbuffers.UOffsetT(0) + if t.Version != "" { + versionOffset = builder.CreateString(t.Version) + } + LicenseInfoStart(builder) + LicenseInfoAddName(builder, nameOffset) + LicenseInfoAddVersion(builder, versionOffset) + LicenseInfoAddQuantity(builder, t.Quantity) + return LicenseInfoEnd(builder) +} + +func (rcv *LicenseInfo) UnPackTo(t *LicenseInfoT) { + t.Name = string(rcv.Name()) + t.Version = string(rcv.Version()) + t.Quantity = rcv.Quantity() +} + +func (rcv *LicenseInfo) UnPack() *LicenseInfoT { + if rcv == nil { return nil } + t := &LicenseInfoT{} + rcv.UnPackTo(t) + return t +} + +type LicenseInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsLicenseInfo(buf []byte, offset flatbuffers.UOffsetT) *LicenseInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LicenseInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLicenseInfo(buf []byte, offset flatbuffers.UOffsetT) *LicenseInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LicenseInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LicenseInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LicenseInfo) Table() flatbuffers.Table { + return rcv._tab +} + +/// Name of the license +func (rcv *LicenseInfo) 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 license +/// version of the license +func (rcv *LicenseInfo) Version() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// version of the license +/// quantity +func (rcv *LicenseInfo) Quantity() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +/// quantity +func (rcv *LicenseInfo) MutateQuantity(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func LicenseInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func LicenseInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func LicenseInfoAddVersion(builder *flatbuffers.Builder, version flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(version), 0) +} +func LicenseInfoAddQuantity(builder *flatbuffers.Builder, quantity uint32) { + builder.PrependUint32Slot(2, quantity, 0) +} +func LicenseInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfoArray.go b/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfoArray.go new file mode 100644 index 0000000..c9ad290 --- /dev/null +++ b/pkg/fbs/plc/cmp/datalayer/fbs/LicenseInfoArray.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// An Array that holds all Licenses +type LicenseInfoArrayT struct { + LicenseArray []*LicenseInfoT `json:"license_array"` +} + +func (t *LicenseInfoArrayT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + licenseArrayOffset := flatbuffers.UOffsetT(0) + if t.LicenseArray != nil { + licenseArrayLength := len(t.LicenseArray) + licenseArrayOffsets := make([]flatbuffers.UOffsetT, licenseArrayLength) + for j := 0; j < licenseArrayLength; j++ { + licenseArrayOffsets[j] = t.LicenseArray[j].Pack(builder) + } + LicenseInfoArrayStartLicenseArrayVector(builder, licenseArrayLength) + for j := licenseArrayLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(licenseArrayOffsets[j]) + } + licenseArrayOffset = builder.EndVector(licenseArrayLength) + } + LicenseInfoArrayStart(builder) + LicenseInfoArrayAddLicenseArray(builder, licenseArrayOffset) + return LicenseInfoArrayEnd(builder) +} + +func (rcv *LicenseInfoArray) UnPackTo(t *LicenseInfoArrayT) { + licenseArrayLength := rcv.LicenseArrayLength() + t.LicenseArray = make([]*LicenseInfoT, licenseArrayLength) + for j := 0; j < licenseArrayLength; j++ { + x := LicenseInfo{} + rcv.LicenseArray(&x, j) + t.LicenseArray[j] = x.UnPack() + } +} + +func (rcv *LicenseInfoArray) UnPack() *LicenseInfoArrayT { + if rcv == nil { return nil } + t := &LicenseInfoArrayT{} + rcv.UnPackTo(t) + return t +} + +type LicenseInfoArray struct { + _tab flatbuffers.Table +} + +func GetRootAsLicenseInfoArray(buf []byte, offset flatbuffers.UOffsetT) *LicenseInfoArray { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LicenseInfoArray{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsLicenseInfoArray(buf []byte, offset flatbuffers.UOffsetT) *LicenseInfoArray { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LicenseInfoArray{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *LicenseInfoArray) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LicenseInfoArray) Table() flatbuffers.Table { + return rcv._tab +} + +/// Description of all available cores +func (rcv *LicenseInfoArray) LicenseArray(obj *LicenseInfo, 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 *LicenseInfoArray) LicenseArrayLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// Description of all available cores +func LicenseInfoArrayStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func LicenseInfoArrayAddLicenseArray(builder *flatbuffers.Builder, licenseArray flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(licenseArray), 0) +} +func LicenseInfoArrayStartLicenseArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func LicenseInfoArrayEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsTorque.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsTorque.go new file mode 100644 index 0000000..e8880bc --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsTorque.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_AxsTorqueT struct { + Base *Cmd_BaseT `json:"base"` + TargetTrq float64 `json:"targetTrq"` + TrqRamp float64 `json:"trqRamp"` + Lim *Cmd_DynLimitsT `json:"lim"` +} + +func (t *Cmd_AxsTorqueT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + limOffset := t.Lim.Pack(builder) + Cmd_AxsTorqueStart(builder) + Cmd_AxsTorqueAddBase(builder, baseOffset) + Cmd_AxsTorqueAddTargetTrq(builder, t.TargetTrq) + Cmd_AxsTorqueAddTrqRamp(builder, t.TrqRamp) + Cmd_AxsTorqueAddLim(builder, limOffset) + return Cmd_AxsTorqueEnd(builder) +} + +func (rcv *Cmd_AxsTorque) UnPackTo(t *Cmd_AxsTorqueT) { + t.Base = rcv.Base(nil).UnPack() + t.TargetTrq = rcv.TargetTrq() + t.TrqRamp = rcv.TrqRamp() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *Cmd_AxsTorque) UnPack() *Cmd_AxsTorqueT { + if rcv == nil { return nil } + t := &Cmd_AxsTorqueT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsTorque struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsTorque(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsTorque { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsTorque{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsTorque(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsTorque { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsTorque{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsTorque) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsTorque) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsTorque) 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_AxsTorque) TargetTrq() 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_AxsTorque) MutateTargetTrq(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +func (rcv *Cmd_AxsTorque) TrqRamp() 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_AxsTorque) MutateTrqRamp(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *Cmd_AxsTorque) 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_AxsTorqueStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_AxsTorqueAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsTorqueAddTargetTrq(builder *flatbuffers.Builder, targetTrq float64) { + builder.PrependFloat64Slot(1, targetTrq, 0.0) +} +func Cmd_AxsTorqueAddTrqRamp(builder *flatbuffers.Builder, trqRamp float64) { + builder.PrependFloat64Slot(2, trqRamp, 0.0) +} +func Cmd_AxsTorqueAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_AxsTorqueEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveToPoint.go b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveToPoint.go new file mode 100644 index 0000000..74f82be --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_KinMoveToPoint.go @@ -0,0 +1,142 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_KinMoveToPointT struct { + Base *Cmd_BaseT `json:"base"` + TargetPointName string `json:"targetPointName"` + Lim *Cmd_DynLimitsT `json:"lim"` + Buffered bool `json:"buffered"` +} + +func (t *Cmd_KinMoveToPointT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + targetPointNameOffset := flatbuffers.UOffsetT(0) + if t.TargetPointName != "" { + targetPointNameOffset = builder.CreateString(t.TargetPointName) + } + limOffset := t.Lim.Pack(builder) + Cmd_KinMoveToPointStart(builder) + Cmd_KinMoveToPointAddBase(builder, baseOffset) + Cmd_KinMoveToPointAddTargetPointName(builder, targetPointNameOffset) + Cmd_KinMoveToPointAddLim(builder, limOffset) + Cmd_KinMoveToPointAddBuffered(builder, t.Buffered) + return Cmd_KinMoveToPointEnd(builder) +} + +func (rcv *Cmd_KinMoveToPoint) UnPackTo(t *Cmd_KinMoveToPointT) { + t.Base = rcv.Base(nil).UnPack() + t.TargetPointName = string(rcv.TargetPointName()) + t.Lim = rcv.Lim(nil).UnPack() + t.Buffered = rcv.Buffered() +} + +func (rcv *Cmd_KinMoveToPoint) UnPack() *Cmd_KinMoveToPointT { + if rcv == nil { return nil } + t := &Cmd_KinMoveToPointT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_KinMoveToPoint struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_KinMoveToPoint(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveToPoint { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_KinMoveToPoint{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_KinMoveToPoint(buf []byte, offset flatbuffers.UOffsetT) *Cmd_KinMoveToPoint { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_KinMoveToPoint{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_KinMoveToPoint) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_KinMoveToPoint) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_KinMoveToPoint) 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 +} + +/// Name of the commanded target point +func (rcv *Cmd_KinMoveToPoint) TargetPointName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Name of the commanded target point +/// dynamic limits for the motion of this command +func (rcv *Cmd_KinMoveToPoint) 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 +} + +/// dynamic limits for the motion of this command +/// buffered or unbuffered command +func (rcv *Cmd_KinMoveToPoint) Buffered() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// buffered or unbuffered command +func (rcv *Cmd_KinMoveToPoint) MutateBuffered(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func Cmd_KinMoveToPointStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_KinMoveToPointAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_KinMoveToPointAddTargetPointName(builder *flatbuffers.Builder, targetPointName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(targetPointName), 0) +} +func Cmd_KinMoveToPointAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(lim), 0) +} +func Cmd_KinMoveToPointAddBuffered(builder *flatbuffers.Builder, buffered bool) { + builder.PrependBoolSlot(3, buffered, true) +} +func Cmd_KinMoveToPointEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/test/datalayer/provider_subscription_suite_test.go b/test/datalayer/provider_subscription_suite_test.go new file mode 100644 index 0000000..8a909b4 --- /dev/null +++ b/test/datalayer/provider_subscription_suite_test.go @@ -0,0 +1,275 @@ +/* + * SPDX-FileCopyrightText: Bosch Rexroth AG + * + * SPDX-License-Identifier: MIT + */ + +package datalayer_test + +import ( + "fmt" + "testing" + "time" + + "github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/datalayer" + "github.com/stretchr/testify/suite" +) + +const ( + addressbasesub = "test-go-datalayer-provider-sub/folder/" + addressFolderSub = addressbasesub + "**" + addressSubInt1 = addressbasesub + "int1" +) + +// helper for 'local' provider +type testProviderSub struct { + system *datalayer.System + provider *datalayer.Provider + node *newNodeDataFolderSub +} + +// test suite client +type ProviderSubTestSuite struct { + suite.Suite + tp *testProviderSub +} + +// test entry function +func TestProviderSubTestSuite(t *testing.T) { + suite.Run(t, new(ProviderSubTestSuite)) +} + +func (suite *ProviderSubTestSuite) TestProviderClientSubscription() { + client := suite.initClient() + defer datalayer.DeleteClient(client) + + suite.True(client.IsConnected()) + + done := make(chan bool) + + onSubscribe := func(result datalayer.Result, items map[string]datalayer.Variant) { + suite.Equal(datalayer.Result(0), result) + suite.Equal(len(items), 1) + done <- true + } + + s, r := client.CreateSubscription("myProviderSub", datalayer.DefaultSubscriptionProperties(), onSubscribe) + suite.Equal(datalayer.Result(0), r) + suite.NotNil(s) + + r = s.Subscribe(addressSubInt1) + suite.Equal(datalayer.Result(0), r) + + suite.Equal(s.Id(), "myProviderSub") + suite.True(len(s.Addresses()) == 1) + + select { + case <-done: + case <-time.After(5 * time.Second): + suite.Fail("callback timeout") + } + + suite.NotPanics(func() { client.DeleteSubscription(s) }) + close(done) + +} + +// create 'local' provider +func (suite *ProviderSubTestSuite) initProvider() { + suite.tp = &testProviderSub{} + suite.tp.create() +} + +// close 'local' provider +func (suite *ProviderSubTestSuite) closeProvider() { + if suite.tp == nil { + return + } + suite.tp.close() + suite.tp = nil +} + +// this function executes bevor all tests executed +func (suite *ProviderSubTestSuite) SetupSuite() { + + suite.initProvider() + fmt.Println(">>> From SetupSuite") +} + +// this function executes after all tests executed +func (suite *ProviderSubTestSuite) TearDownSuite() { + suite.closeProvider() + fmt.Println(">>> From TearDownSuite") +} + +// create a 'local' client +func (suite *ProviderSubTestSuite) initClient() *datalayer.Client { + system := suite.tp.system + //system.Start(true) + + client := system.Factory().CreateClient("ipc://") + client.SetTimeout(datalayer.TimeoutSettingPing, ctrlxClientTimeout()) + return client +} + +// create a 'local' provider with provider nodes +func (p *testProviderSub) create() { + p.system = datalayer.NewSystem("") + p.system.Start(true) + p.provider = p.system.Factory().CreateProvider("ipc://") + r := p.provider.Start() + fmt.Println("Start Provider: ", r) + if r != datalayer.ResultOk { + return + } + p.createNodes() +} + +// create folder provider nodes and folder manage different subnodes +func (p *testProviderSub) createNodes() { + ndf := &newNodeDataFolderSub{ + name: addressFolderSub, + node: datalayer.NewProviderNodeSub(), + Subscriptions: make(map[uint64]*datalayer.ProviderSubscription), + } + p.node = ndf + go startnodeDataSubHandler(*ndf) + r := p.provider.RegisterNode(ndf.Name(), ndf.Node()) + if r != datalayer.ResultOk { + fmt.Println("ERROR Registering node ", ndf.Name(), " failed: ", r) + } +} + +// close provider +func (p *testProviderSub) closeProvider() { + p.provider.UnregisterNode(addressFolderSub) + datalayer.DeleteProviderNode(p.node.node) + p.provider.Stop() + datalayer.DeleteProvider(p.provider) +} + +// close runtime +func (p *testProviderSub) close() { + p.closeProvider() + p.system.Stop(true) + datalayer.DeleteSystem(p.system) +} + +type newNodeDataFolderSub struct { + name string + node *datalayer.ProviderNode + + Subscriptions map[uint64]*datalayer.ProviderSubscription +} + +func (n *newNodeDataFolderSub) Node() *datalayer.ProviderNode { + return n.node +} + +func (n *newNodeDataFolderSub) Name() string { + return n.name +} + +// handler for provider node +func startnodeDataSubHandler(d newNodeDataFolderSub) { + for { + if d.Node() == nil { + return + } + select { + case event, ok := <-d.Node().Channels().OnCreate: + if !ok { + return + } + fmt.Println("event: oncreate: ", d.Name(), event.Address) + event.Callback(datalayer.ResultOk, nil) + + case event, ok := <-d.Node().Channels().OnRemove: + if !ok { + return + } + + fmt.Println("event: OnRemove: ", d.Name()) + event.Callback(datalayer.ResultOk, nil) + + case event, ok := <-d.Node().Channels().OnBrowse: + func() { + if !ok { + return + } + + newData := datalayer.NewVariant() + defer datalayer.DeleteVariant(newData) + newData.SetArrayString([]string{d.Name()}) + fmt.Println("event: OnBrowse: ", d.Name()) + event.Callback(datalayer.Result(0), newData) + }() + + case event, ok := <-d.Node().Channels().OnRead: + func() { + if !ok { + return + } + + newData := datalayer.NewVariant() + defer datalayer.DeleteVariant(newData) + newData.SetInt32(123) + fmt.Println("event: OnRead: ", d.Name(), event.Address) + event.Callback(datalayer.ResultOk, newData) + }() + + case event, ok := <-d.Node().Channels().OnWrite: + if !ok { + return + } + + fmt.Println("event: OnWrite: ", d.Name()) + event.Callback(datalayer.ResultOk, event.Data) + + case event, ok := <-d.Node().Channels().OnMetadata: + func() { + if !ok { + return + } + + fmt.Println("event: OnMetadata: ", d.Name()) + + event.Callback(datalayer.ResultOk, nil) + }() + + case event, ok := <-d.Node().Channels().OnSubscribe: + func() { + if !ok { + return + } + + fmt.Println("event: OnSubscribe: ", d.Name(), event.Address, event.Subsciption.GetUniqueId()) + fmt.Println(" Props: PublishInterval:", event.Subsciption.GetProps().PublishInterval()) + _, ok := d.Subscriptions[event.Subsciption.GetUniqueId()] + if ok { + return + } + d.Subscriptions[event.Subsciption.GetUniqueId()] = event.Subsciption + n := datalayer.NewNotifyItemPublish(event.Address) + l := []*datalayer.NotifyItemPublish{n} + event.Subsciption.Publish(datalayer.ResultOk, l) + datalayer.DeleteNotifyItemsPublish(l) + }() + case event, ok := <-d.Node().Channels().OnUnsubscribe: + func() { + if !ok { + return + } + + fmt.Println("event: OnUnsubscribe: ", d.Name(), event.Address, event.Subsciption.GetUniqueId()) + if len(event.Subsciption.GetNodes()) != 0 { + return + } + delete(d.Subscriptions, event.Subsciption.GetUniqueId()) + }() + case <-d.Node().Channels().Done: + fmt.Println("event: Done: ", d.Name()) + return + } + } +} diff --git a/test/datalayer/provider_suite_test.go b/test/datalayer/provider_suite_test.go new file mode 100644 index 0000000..a619d22 --- /dev/null +++ b/test/datalayer/provider_suite_test.go @@ -0,0 +1,64 @@ +/* + * SPDX-FileCopyrightText: Bosch Rexroth AG + * + * SPDX-License-Identifier: MIT + */ + +package datalayer_test + +import ( + "testing" + + "github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/datalayer" + "github.com/stretchr/testify/suite" +) + +// test suite client +type ProviderTestSuite struct { + ClientTestSuite +} + +// test entry function +func TestProviderTestSuite(t *testing.T) { + suite.Run(t, new(ProviderTestSuite)) +} + +func (suite *ProviderTestSuite) TestGetRegisteredType() { + r, d := suite.tp.provider.GetRegisteredType("identity") //see test "c_provider_test.cpp" + + defer datalayer.DeleteVariant(d) + suite.Equal(datalayer.ResultOk, r) + suite.NotNil(d) + suite.Equal(d.GetType(), datalayer.VariantTypeArrayUint8) + + d.SetBool8(true) + r = suite.tp.provider.RegisterTypeVariant("types/GetRegisteredType/test1", d) + suite.Equal(datalayer.ResultOk, r) + + r, d1 := suite.tp.provider.GetRegisteredType("types/GetRegisteredType/test1") //see test "c_provider_test.cpp" + defer datalayer.DeleteVariant(d1) + suite.Equal(datalayer.ResultOk, r) + suite.NotNil(d1) + suite.Equal(d1.GetType(), datalayer.VariantTypeBool8) +} + +func (suite *ProviderTestSuite) TestGetRegisteredNodePaths() { + r, d := suite.tp.provider.GetRegisteredNodePaths() + suite.Equal(datalayer.ResultOk, r) + suite.NotNil(d) + suite.True(len(d) >= 2) +} + +func (suite *ProviderTestSuite) TestGetRejectedNodePaths() { + r, d := suite.tp.provider.GetRejectedNodePaths() + suite.Equal(datalayer.ResultOk, r) + suite.NotNil(d) + suite.True(len(d) >= 0) +} + +func (suite *ProviderTestSuite) TestPublishEvent() { + data := datalayer.NewVariant() + defer datalayer.DeleteVariant(data) + r := suite.tp.provider.PublishEvent(data, data) + suite.Equal(datalayer.ResultTypeMismatch, r) +} diff --git a/test/datalayer/provider_test.go b/test/datalayer/provider_test.go index 7605155..cb13865 100644 --- a/test/datalayer/provider_test.go +++ b/test/datalayer/provider_test.go @@ -135,6 +135,23 @@ func TestProviderRegisterType(t *testing.T) { a.Equal(t, datalayer.Result(0), provider.UnregisterType("types/godata/test")) } +func TestGetRegisteredType(t *testing.T) { + if providerAddress == "" { + t.Skip("ctrlX device does not exist") + } + system, provider := initProvider() + defer datalayer.DeleteSystem(system) + defer datalayer.DeleteProvider(provider) + + a.Equal(t, datalayer.Result(0), provider.Start()) + a.Equal(t, true, provider.IsConnected()) + + r, d := provider.GetRegisteredType("identity") + a.Equal(t, datalayer.ResultOk, r) + a.NotNil(t, d) + a.Equal(t, d.GetType(), datalayer.VariantTypeArrayUint8) +} + var goFloat float32 = 0.369 func startTestNode(node *datalayer.ProviderNode) { diff --git a/test/datalayer/utils_test.go b/test/datalayer/utils_test.go index 947f5e8..dd473a2 100644 --- a/test/datalayer/utils_test.go +++ b/test/datalayer/utils_test.go @@ -105,14 +105,14 @@ func asyncTestTimeout() time.Duration { } func TestClientAddressNoTests(t *testing.T) { - os.Setenv("CTRLX_ADDRESS", "-") + t.Setenv("CTRLX_ADDRESS", "-") e := ctrlxAddress() assert.Equal(t, e, "") resetGlobalEnvs() } func TestClientAddressSetEnv(t *testing.T) { - os.Setenv("CTRLX_ADDRESS", "10.0.2.2") + t.Setenv("CTRLX_ADDRESS", "10.0.2.2") e := ctrlxAddress() assert.True(t, e == "tcp://boschrexroth:boschrexroth@10.0.2.2" || e == "tcp://boschrexroth:boschrexroth@10.0.2.2?sslport=443" || @@ -121,36 +121,36 @@ func TestClientAddressSetEnv(t *testing.T) { } func TestClientAddressSetEnv2(t *testing.T) { - os.Setenv("CTRLX_ADDRESS", "10.0.2.2") - os.Setenv("CTRLX_SSL_PORT", "8443") + t.Setenv("CTRLX_ADDRESS", "10.0.2.2") + t.Setenv("CTRLX_SSL_PORT", "8443") e := ctrlxAddress() assert.Equal(t, e, "tcp://boschrexroth:boschrexroth@10.0.2.2?sslport=8443") resetGlobalEnvs() } func TestClientTimeout(t *testing.T) { - os.Setenv("CTRLX_TIMEOUT", "-") + t.Setenv("CTRLX_TIMEOUT", "-") e := ctrlxClientTimeout() assert.Equal(t, e, uint(2000)) resetGlobalEnvs() } func TestClientTimeoutSetEnv(t *testing.T) { - os.Setenv("CTRLX_TIMEOUT", "4000") + t.Setenv("CTRLX_TIMEOUT", "4000") e := ctrlxClientTimeout() assert.Equal(t, e, uint(4000)) resetGlobalEnvs() } func TestAsyncWaitTimeout(t *testing.T) { - os.Setenv("CTRLX_TIMEOUT", "-") + t.Setenv("CTRLX_TIMEOUT", "-") e := asyncTestTimeout() assert.Equal(t, e, 5*time.Second) resetGlobalEnvs() } func TestAsyncWaitTimeoutSetEnv(t *testing.T) { - os.Setenv("CTRLX_TIMEOUT", "4000") + t.Setenv("CTRLX_TIMEOUT", "4000") e := asyncTestTimeout() assert.Equal(t, e, (4000/1000)*2*time.Second) resetGlobalEnvs()