test_msgs_msg

package
v0.0.0-...-56b24e1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 31, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Constants_BOOL_CONST    bool    = true
	Constants_BYTE_CONST    byte    = 50
	Constants_CHAR_CONST    byte    = 100
	Constants_FLOAT32_CONST float32 = 1.125
	Constants_FLOAT64_CONST float64 = 1.125
	Constants_INT8_CONST    int8    = -50
	Constants_UINT8_CONST   uint8   = 200
	Constants_INT16_CONST   int16   = -1000
	Constants_UINT16_CONST  uint16  = 2000
	Constants_INT32_CONST   int32   = -30000
	Constants_UINT32_CONST  uint32  = 60000
	Constants_INT64_CONST   int64   = -40000000
	Constants_UINT64_CONST  uint64  = 50000000
)
View Source 
const (
	Strings_STRING_CONST string = "Hello world!"
)

Variables

View Source 
var ArraysTypeSupport types.MessageTypeSupport = _ArraysTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var BasicTypesTypeSupport types.MessageTypeSupport = _BasicTypesTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var BoundedPlainSequencesTypeSupport types.MessageTypeSupport = _BoundedPlainSequencesTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var BoundedSequencesTypeSupport types.MessageTypeSupport = _BoundedSequencesTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var BuiltinsTypeSupport types.MessageTypeSupport = _BuiltinsTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var ConstantsTypeSupport types.MessageTypeSupport = _ConstantsTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var DefaultsTypeSupport types.MessageTypeSupport = _DefaultsTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var EmptyTypeSupport types.MessageTypeSupport = _EmptyTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var MultiNestedTypeSupport types.MessageTypeSupport = _MultiNestedTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var NestedTypeSupport types.MessageTypeSupport = _NestedTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var StringsTypeSupport types.MessageTypeSupport = _StringsTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var UnboundedSequencesTypeSupport types.MessageTypeSupport = _UnboundedSequencesTypeSupport{}

Modifying this variable is undefined behavior.

View Source 
var WStringsTypeSupport types.MessageTypeSupport = _WStringsTypeSupport{}

Modifying this variable is undefined behavior.

Functions

func Arrays__Array_to_C 

func Arrays__Array_to_C(cSlice []CArrays, goSlice []Arrays)

func Arrays__Array_to_Go 

func Arrays__Array_to_Go(goSlice []Arrays, cSlice []CArrays)

func Arrays__Sequence_to_C 

func Arrays__Sequence_to_C(cSlice *CArrays__Sequence, goSlice []Arrays)

func Arrays__Sequence_to_Go 

func Arrays__Sequence_to_Go(goSlice *[]Arrays, cSlice CArrays__Sequence)

func BasicTypes__Array_to_C 

func BasicTypes__Array_to_C(cSlice []CBasicTypes, goSlice []BasicTypes)

func BasicTypes__Array_to_Go 

func BasicTypes__Array_to_Go(goSlice []BasicTypes, cSlice []CBasicTypes)

func BasicTypes__Sequence_to_C 

func BasicTypes__Sequence_to_C(cSlice *CBasicTypes__Sequence, goSlice []BasicTypes)

func BasicTypes__Sequence_to_Go 

func BasicTypes__Sequence_to_Go(goSlice *[]BasicTypes, cSlice CBasicTypes__Sequence)

func BoundedPlainSequences__Array_to_C 

func BoundedPlainSequences__Array_to_C(cSlice []CBoundedPlainSequences, goSlice []BoundedPlainSequences)

func BoundedPlainSequences__Array_to_Go 

func BoundedPlainSequences__Array_to_Go(goSlice []BoundedPlainSequences, cSlice []CBoundedPlainSequences)

func BoundedPlainSequences__Sequence_to_C 

func BoundedPlainSequences__Sequence_to_C(cSlice *CBoundedPlainSequences__Sequence, goSlice []BoundedPlainSequences)

func BoundedPlainSequences__Sequence_to_Go 

func BoundedPlainSequences__Sequence_to_Go(goSlice *[]BoundedPlainSequences, cSlice CBoundedPlainSequences__Sequence)

func BoundedSequences__Array_to_C 

func BoundedSequences__Array_to_C(cSlice []CBoundedSequences, goSlice []BoundedSequences)

func BoundedSequences__Array_to_Go 

func BoundedSequences__Array_to_Go(goSlice []BoundedSequences, cSlice []CBoundedSequences)

func BoundedSequences__Sequence_to_C 

func BoundedSequences__Sequence_to_C(cSlice *CBoundedSequences__Sequence, goSlice []BoundedSequences)

func BoundedSequences__Sequence_to_Go 

func BoundedSequences__Sequence_to_Go(goSlice *[]BoundedSequences, cSlice CBoundedSequences__Sequence)

func Builtins__Array_to_C 

func Builtins__Array_to_C(cSlice []CBuiltins, goSlice []Builtins)

func Builtins__Array_to_Go 

func Builtins__Array_to_Go(goSlice []Builtins, cSlice []CBuiltins)

func Builtins__Sequence_to_C 

func Builtins__Sequence_to_C(cSlice *CBuiltins__Sequence, goSlice []Builtins)

func Builtins__Sequence_to_Go 

func Builtins__Sequence_to_Go(goSlice *[]Builtins, cSlice CBuiltins__Sequence)

func CloneArraysSlice 

func CloneArraysSlice(dst, src []Arrays)

CloneArraysSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneBasicTypesSlice 

func CloneBasicTypesSlice(dst, src []BasicTypes)

CloneBasicTypesSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneBoundedPlainSequencesSlice 

func CloneBoundedPlainSequencesSlice(dst, src []BoundedPlainSequences)

CloneBoundedPlainSequencesSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneBoundedSequencesSlice 

func CloneBoundedSequencesSlice(dst, src []BoundedSequences)

CloneBoundedSequencesSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneBuiltinsSlice 

func CloneBuiltinsSlice(dst, src []Builtins)

CloneBuiltinsSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneConstantsSlice 

func CloneConstantsSlice(dst, src []Constants)

CloneConstantsSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneDefaultsSlice 

func CloneDefaultsSlice(dst, src []Defaults)

CloneDefaultsSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneEmptySlice 

func CloneEmptySlice(dst, src []Empty)

CloneEmptySlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneMultiNestedSlice 

func CloneMultiNestedSlice(dst, src []MultiNested)

CloneMultiNestedSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneNestedSlice 

func CloneNestedSlice(dst, src []Nested)

CloneNestedSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneStringsSlice 

func CloneStringsSlice(dst, src []Strings)

CloneStringsSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneUnboundedSequencesSlice 

func CloneUnboundedSequencesSlice(dst, src []UnboundedSequences)

CloneUnboundedSequencesSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func CloneWStringsSlice 

func CloneWStringsSlice(dst, src []WStrings)

CloneWStringsSlice clones src to dst by calling Clone for each element in src. Panics if len(dst) < len(src).

func Constants__Array_to_C 

func Constants__Array_to_C(cSlice []CConstants, goSlice []Constants)

func Constants__Array_to_Go 

func Constants__Array_to_Go(goSlice []Constants, cSlice []CConstants)

func Constants__Sequence_to_C 

func Constants__Sequence_to_C(cSlice *CConstants__Sequence, goSlice []Constants)

func Constants__Sequence_to_Go 

func Constants__Sequence_to_Go(goSlice *[]Constants, cSlice CConstants__Sequence)

func Defaults__Array_to_C 

func Defaults__Array_to_C(cSlice []CDefaults, goSlice []Defaults)

func Defaults__Array_to_Go 

func Defaults__Array_to_Go(goSlice []Defaults, cSlice []CDefaults)

func Defaults__Sequence_to_C 

func Defaults__Sequence_to_C(cSlice *CDefaults__Sequence, goSlice []Defaults)

func Defaults__Sequence_to_Go 

func Defaults__Sequence_to_Go(goSlice *[]Defaults, cSlice CDefaults__Sequence)

func Empty__Array_to_C 

func Empty__Array_to_C(cSlice []CEmpty, goSlice []Empty)

func Empty__Array_to_Go 

func Empty__Array_to_Go(goSlice []Empty, cSlice []CEmpty)

func Empty__Sequence_to_C 

func Empty__Sequence_to_C(cSlice *CEmpty__Sequence, goSlice []Empty)

func Empty__Sequence_to_Go 

func Empty__Sequence_to_Go(goSlice *[]Empty, cSlice CEmpty__Sequence)

func MultiNested__Array_to_C 

func MultiNested__Array_to_C(cSlice []CMultiNested, goSlice []MultiNested)

func MultiNested__Array_to_Go 

func MultiNested__Array_to_Go(goSlice []MultiNested, cSlice []CMultiNested)

func MultiNested__Sequence_to_C 

func MultiNested__Sequence_to_C(cSlice *CMultiNested__Sequence, goSlice []MultiNested)

func MultiNested__Sequence_to_Go 

func MultiNested__Sequence_to_Go(goSlice *[]MultiNested, cSlice CMultiNested__Sequence)

func Nested__Array_to_C 

func Nested__Array_to_C(cSlice []CNested, goSlice []Nested)

func Nested__Array_to_Go 

func Nested__Array_to_Go(goSlice []Nested, cSlice []CNested)

func Nested__Sequence_to_C 

func Nested__Sequence_to_C(cSlice *CNested__Sequence, goSlice []Nested)

func Nested__Sequence_to_Go 

func Nested__Sequence_to_Go(goSlice *[]Nested, cSlice CNested__Sequence)

func Strings__Array_to_C 

func Strings__Array_to_C(cSlice []CStrings, goSlice []Strings)

func Strings__Array_to_Go 

func Strings__Array_to_Go(goSlice []Strings, cSlice []CStrings)

func Strings__Sequence_to_C 

func Strings__Sequence_to_C(cSlice *CStrings__Sequence, goSlice []Strings)

func Strings__Sequence_to_Go 

func Strings__Sequence_to_Go(goSlice *[]Strings, cSlice CStrings__Sequence)

func UnboundedSequences__Array_to_C 

func UnboundedSequences__Array_to_C(cSlice []CUnboundedSequences, goSlice []UnboundedSequences)

func UnboundedSequences__Array_to_Go 

func UnboundedSequences__Array_to_Go(goSlice []UnboundedSequences, cSlice []CUnboundedSequences)

func UnboundedSequences__Sequence_to_C 

func UnboundedSequences__Sequence_to_C(cSlice *CUnboundedSequences__Sequence, goSlice []UnboundedSequences)

func UnboundedSequences__Sequence_to_Go 

func UnboundedSequences__Sequence_to_Go(goSlice *[]UnboundedSequences, cSlice CUnboundedSequences__Sequence)

func WStrings__Array_to_C 

func WStrings__Array_to_C(cSlice []CWStrings, goSlice []WStrings)

func WStrings__Array_to_Go 

func WStrings__Array_to_Go(goSlice []WStrings, cSlice []CWStrings)

func WStrings__Sequence_to_C 

func WStrings__Sequence_to_C(cSlice *CWStrings__Sequence, goSlice []WStrings)

func WStrings__Sequence_to_Go 

func WStrings__Sequence_to_Go(goSlice *[]WStrings, cSlice CWStrings__Sequence)

Types

type Arrays 

type Arrays struct {
	BoolValues           [3]bool       `yaml:"bool_values"` // Arrays of different types
	ByteValues           [3]byte       `yaml:"byte_values"`
	CharValues           [3]byte       `yaml:"char_values"`
	Float32Values        [3]float32    `yaml:"float32_values"`
	Float64Values        [3]float64    `yaml:"float64_values"`
	Int8Values           [3]int8       `yaml:"int8_values"`
	Uint8Values          [3]uint8      `yaml:"uint8_values"`
	Int16Values          [3]int16      `yaml:"int16_values"`
	Uint16Values         [3]uint16     `yaml:"uint16_values"`
	Int32Values          [3]int32      `yaml:"int32_values"`
	Uint32Values         [3]uint32     `yaml:"uint32_values"`
	Int64Values          [3]int64      `yaml:"int64_values"`
	Uint64Values         [3]uint64     `yaml:"uint64_values"`
	StringValues         [3]string     `yaml:"string_values"`
	BasicTypesValues     [3]BasicTypes `yaml:"basic_types_values"`
	ConstantsValues      [3]Constants  `yaml:"constants_values"`
	DefaultsValues       [3]Defaults   `yaml:"defaults_values"`
	BoolValuesDefault    [3]bool       `yaml:"bool_values_default"`
	ByteValuesDefault    [3]byte       `yaml:"byte_values_default"`
	CharValuesDefault    [3]byte       `yaml:"char_values_default"`
	Float32ValuesDefault [3]float32    `yaml:"float32_values_default"`
	Float64ValuesDefault [3]float64    `yaml:"float64_values_default"`
	Int8ValuesDefault    [3]int8       `yaml:"int8_values_default"`
	Uint8ValuesDefault   [3]uint8      `yaml:"uint8_values_default"`
	Int16ValuesDefault   [3]int16      `yaml:"int16_values_default"`
	Uint16ValuesDefault  [3]uint16     `yaml:"uint16_values_default"`
	Int32ValuesDefault   [3]int32      `yaml:"int32_values_default"`
	Uint32ValuesDefault  [3]uint32     `yaml:"uint32_values_default"`
	Int64ValuesDefault   [3]int64      `yaml:"int64_values_default"`
	Uint64ValuesDefault  [3]uint64     `yaml:"uint64_values_default"`
	StringValuesDefault  [3]string     `yaml:"string_values_default"`
	AlignmentCheck       int32         `yaml:"alignment_check"` // Regression test: check alignment of basic field after an array field is correct
}

func NewArrays 

func NewArrays() *Arrays

NewArrays creates a new Arrays with default values.

func (*Arrays) Clone 

func (t *Arrays) Clone() *Arrays

func (*Arrays) CloneMsg 

func (t *Arrays) CloneMsg() types.Message

func (*Arrays) GetTypeSupport 

func (t *Arrays) GetTypeSupport() types.MessageTypeSupport

func (*Arrays) SetDefaults 

func (t *Arrays) SetDefaults()

type ArraysPublisher 

type ArraysPublisher struct {
	*rclgo.Publisher
}

ArraysPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewArraysPublisher 

func NewArraysPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*ArraysPublisher, error)

NewArraysPublisher creates and returns a new publisher for the Arrays

func (*ArraysPublisher) Publish 

func (p *ArraysPublisher) Publish(msg *Arrays) error

type ArraysSubscription 

type ArraysSubscription struct {
	*rclgo.Subscription
}

ArraysSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewArraysSubscription 

func NewArraysSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback ArraysSubscriptionCallback) (*ArraysSubscription, error)

NewArraysSubscription creates and returns a new subscription for the Arrays

func (*ArraysSubscription) TakeMessage 

func (s *ArraysSubscription) TakeMessage(out *Arrays) (*rclgo.MessageInfo, error)

type ArraysSubscriptionCallback 

type ArraysSubscriptionCallback func(msg *Arrays, info *rclgo.MessageInfo, err error)

ArraysSubscriptionCallback type is used to provide a subscription handler function for a ArraysSubscription.

type BasicTypes 

type BasicTypes struct {
	BoolValue    bool    `yaml:"bool_value"`
	ByteValue    byte    `yaml:"byte_value"`
	CharValue    byte    `yaml:"char_value"`
	Float32Value float32 `yaml:"float32_value"`
	Float64Value float64 `yaml:"float64_value"`
	Int8Value    int8    `yaml:"int8_value"`
	Uint8Value   uint8   `yaml:"uint8_value"`
	Int16Value   int16   `yaml:"int16_value"`
	Uint16Value  uint16  `yaml:"uint16_value"`
	Int32Value   int32   `yaml:"int32_value"`
	Uint32Value  uint32  `yaml:"uint32_value"`
	Int64Value   int64   `yaml:"int64_value"`
	Uint64Value  uint64  `yaml:"uint64_value"`
}

func NewBasicTypes 

func NewBasicTypes() *BasicTypes

NewBasicTypes creates a new BasicTypes with default values.

func (*BasicTypes) Clone 

func (t *BasicTypes) Clone() *BasicTypes

func (*BasicTypes) CloneMsg 

func (t *BasicTypes) CloneMsg() types.Message

func (*BasicTypes) GetTypeSupport 

func (t *BasicTypes) GetTypeSupport() types.MessageTypeSupport

func (*BasicTypes) SetDefaults 

func (t *BasicTypes) SetDefaults()

type BasicTypesPublisher 

type BasicTypesPublisher struct {
	*rclgo.Publisher
}

BasicTypesPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewBasicTypesPublisher 

func NewBasicTypesPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*BasicTypesPublisher, error)

NewBasicTypesPublisher creates and returns a new publisher for the BasicTypes

func (*BasicTypesPublisher) Publish 

func (p *BasicTypesPublisher) Publish(msg *BasicTypes) error

type BasicTypesSubscription 

type BasicTypesSubscription struct {
	*rclgo.Subscription
}

BasicTypesSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewBasicTypesSubscription 

func NewBasicTypesSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback BasicTypesSubscriptionCallback) (*BasicTypesSubscription, error)

NewBasicTypesSubscription creates and returns a new subscription for the BasicTypes

func (*BasicTypesSubscription) TakeMessage 

func (s *BasicTypesSubscription) TakeMessage(out *BasicTypes) (*rclgo.MessageInfo, error)

type BasicTypesSubscriptionCallback 

type BasicTypesSubscriptionCallback func(msg *BasicTypes, info *rclgo.MessageInfo, err error)

BasicTypesSubscriptionCallback type is used to provide a subscription handler function for a BasicTypesSubscription.

type BoundedPlainSequences 

type BoundedPlainSequences struct {
	BoolValues           []bool       `yaml:"bool_values"` // Bounded sequences of different POD types
	ByteValues           []byte       `yaml:"byte_values"`
	CharValues           []byte       `yaml:"char_values"`
	Float32Values        []float32    `yaml:"float32_values"`
	Float64Values        []float64    `yaml:"float64_values"`
	Int8Values           []int8       `yaml:"int8_values"`
	Uint8Values          []uint8      `yaml:"uint8_values"`
	Int16Values          []int16      `yaml:"int16_values"`
	Uint16Values         []uint16     `yaml:"uint16_values"`
	Int32Values          []int32      `yaml:"int32_values"`
	Uint32Values         []uint32     `yaml:"uint32_values"`
	Int64Values          []int64      `yaml:"int64_values"`
	Uint64Values         []uint64     `yaml:"uint64_values"`
	BasicTypesValues     []BasicTypes `yaml:"basic_types_values"`
	ConstantsValues      []Constants  `yaml:"constants_values"`
	DefaultsValues       []Defaults   `yaml:"defaults_values"`
	BoolValuesDefault    []bool       `yaml:"bool_values_default"`
	ByteValuesDefault    []byte       `yaml:"byte_values_default"`
	CharValuesDefault    []byte       `yaml:"char_values_default"`
	Float32ValuesDefault []float32    `yaml:"float32_values_default"`
	Float64ValuesDefault []float64    `yaml:"float64_values_default"`
	Int8ValuesDefault    []int8       `yaml:"int8_values_default"`
	Uint8ValuesDefault   []uint8      `yaml:"uint8_values_default"`
	Int16ValuesDefault   []int16      `yaml:"int16_values_default"`
	Uint16ValuesDefault  []uint16     `yaml:"uint16_values_default"`
	Int32ValuesDefault   []int32      `yaml:"int32_values_default"`
	Uint32ValuesDefault  []uint32     `yaml:"uint32_values_default"`
	Int64ValuesDefault   []int64      `yaml:"int64_values_default"`
	Uint64ValuesDefault  []uint64     `yaml:"uint64_values_default"`
	AlignmentCheck       int32        `yaml:"alignment_check"` // Regression test: check alignment of basic field after a sequence field is correct
}

func NewBoundedPlainSequences 

func NewBoundedPlainSequences() *BoundedPlainSequences

NewBoundedPlainSequences creates a new BoundedPlainSequences with default values.

func (*BoundedPlainSequences) Clone 

func (t *BoundedPlainSequences) Clone() *BoundedPlainSequences

func (*BoundedPlainSequences) CloneMsg 

func (t *BoundedPlainSequences) CloneMsg() types.Message

func (*BoundedPlainSequences) GetTypeSupport 

func (t *BoundedPlainSequences) GetTypeSupport() types.MessageTypeSupport

func (*BoundedPlainSequences) SetDefaults 

func (t *BoundedPlainSequences) SetDefaults()

type BoundedPlainSequencesPublisher 

type BoundedPlainSequencesPublisher struct {
	*rclgo.Publisher
}

BoundedPlainSequencesPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewBoundedPlainSequencesPublisher 

func NewBoundedPlainSequencesPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*BoundedPlainSequencesPublisher, error)

NewBoundedPlainSequencesPublisher creates and returns a new publisher for the BoundedPlainSequences

func (*BoundedPlainSequencesPublisher) Publish 

func (p *BoundedPlainSequencesPublisher) Publish(msg *BoundedPlainSequences) error

type BoundedPlainSequencesSubscription 

type BoundedPlainSequencesSubscription struct {
	*rclgo.Subscription
}

BoundedPlainSequencesSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewBoundedPlainSequencesSubscription 

func NewBoundedPlainSequencesSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback BoundedPlainSequencesSubscriptionCallback) (*BoundedPlainSequencesSubscription, error)

NewBoundedPlainSequencesSubscription creates and returns a new subscription for the BoundedPlainSequences

func (*BoundedPlainSequencesSubscription) TakeMessage 

func (s *BoundedPlainSequencesSubscription) TakeMessage(out *BoundedPlainSequences) (*rclgo.MessageInfo, error)

type BoundedPlainSequencesSubscriptionCallback 

type BoundedPlainSequencesSubscriptionCallback func(msg *BoundedPlainSequences, info *rclgo.MessageInfo, err error)

BoundedPlainSequencesSubscriptionCallback type is used to provide a subscription handler function for a BoundedPlainSequencesSubscription.

type BoundedSequences 

type BoundedSequences struct {
	BoolValues           []bool       `yaml:"bool_values"` // Bounded sequences of different types
	ByteValues           []byte       `yaml:"byte_values"`
	CharValues           []byte       `yaml:"char_values"`
	Float32Values        []float32    `yaml:"float32_values"`
	Float64Values        []float64    `yaml:"float64_values"`
	Int8Values           []int8       `yaml:"int8_values"`
	Uint8Values          []uint8      `yaml:"uint8_values"`
	Int16Values          []int16      `yaml:"int16_values"`
	Uint16Values         []uint16     `yaml:"uint16_values"`
	Int32Values          []int32      `yaml:"int32_values"`
	Uint32Values         []uint32     `yaml:"uint32_values"`
	Int64Values          []int64      `yaml:"int64_values"`
	Uint64Values         []uint64     `yaml:"uint64_values"`
	StringValues         []string     `yaml:"string_values"`
	BasicTypesValues     []BasicTypes `yaml:"basic_types_values"`
	ConstantsValues      []Constants  `yaml:"constants_values"`
	DefaultsValues       []Defaults   `yaml:"defaults_values"`
	BoolValuesDefault    []bool       `yaml:"bool_values_default"`
	ByteValuesDefault    []byte       `yaml:"byte_values_default"`
	CharValuesDefault    []byte       `yaml:"char_values_default"`
	Float32ValuesDefault []float32    `yaml:"float32_values_default"`
	Float64ValuesDefault []float64    `yaml:"float64_values_default"`
	Int8ValuesDefault    []int8       `yaml:"int8_values_default"`
	Uint8ValuesDefault   []uint8      `yaml:"uint8_values_default"`
	Int16ValuesDefault   []int16      `yaml:"int16_values_default"`
	Uint16ValuesDefault  []uint16     `yaml:"uint16_values_default"`
	Int32ValuesDefault   []int32      `yaml:"int32_values_default"`
	Uint32ValuesDefault  []uint32     `yaml:"uint32_values_default"`
	Int64ValuesDefault   []int64      `yaml:"int64_values_default"`
	Uint64ValuesDefault  []uint64     `yaml:"uint64_values_default"`
	StringValuesDefault  []string     `yaml:"string_values_default"`
	AlignmentCheck       int32        `yaml:"alignment_check"` // Regression test: check alignment of basic field after a sequence field is correct
}

func NewBoundedSequences 

func NewBoundedSequences() *BoundedSequences

NewBoundedSequences creates a new BoundedSequences with default values.

func (*BoundedSequences) Clone 

func (t *BoundedSequences) Clone() *BoundedSequences

func (*BoundedSequences) CloneMsg 

func (t *BoundedSequences) CloneMsg() types.Message

func (*BoundedSequences) GetTypeSupport 

func (t *BoundedSequences) GetTypeSupport() types.MessageTypeSupport

func (*BoundedSequences) SetDefaults 

func (t *BoundedSequences) SetDefaults()

type BoundedSequencesPublisher 

type BoundedSequencesPublisher struct {
	*rclgo.Publisher
}

BoundedSequencesPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewBoundedSequencesPublisher 

func NewBoundedSequencesPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*BoundedSequencesPublisher, error)

NewBoundedSequencesPublisher creates and returns a new publisher for the BoundedSequences

func (*BoundedSequencesPublisher) Publish 

func (p *BoundedSequencesPublisher) Publish(msg *BoundedSequences) error

type BoundedSequencesSubscription 

type BoundedSequencesSubscription struct {
	*rclgo.Subscription
}

BoundedSequencesSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewBoundedSequencesSubscription 

func NewBoundedSequencesSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback BoundedSequencesSubscriptionCallback) (*BoundedSequencesSubscription, error)

NewBoundedSequencesSubscription creates and returns a new subscription for the BoundedSequences

func (*BoundedSequencesSubscription) TakeMessage 

func (s *BoundedSequencesSubscription) TakeMessage(out *BoundedSequences) (*rclgo.MessageInfo, error)

type BoundedSequencesSubscriptionCallback 

type BoundedSequencesSubscriptionCallback func(msg *BoundedSequences, info *rclgo.MessageInfo, err error)

BoundedSequencesSubscriptionCallback type is used to provide a subscription handler function for a BoundedSequencesSubscription.

type Builtins 

type Builtins struct {
	DurationValue builtin_interfaces_msg.Duration `yaml:"duration_value"`
	TimeValue     builtin_interfaces_msg.Time     `yaml:"time_value"`
}

func NewBuiltins 

func NewBuiltins() *Builtins

NewBuiltins creates a new Builtins with default values.

func (*Builtins) Clone 

func (t *Builtins) Clone() *Builtins

func (*Builtins) CloneMsg 

func (t *Builtins) CloneMsg() types.Message

func (*Builtins) GetTypeSupport 

func (t *Builtins) GetTypeSupport() types.MessageTypeSupport

func (*Builtins) SetDefaults 

func (t *Builtins) SetDefaults()

type BuiltinsPublisher 

type BuiltinsPublisher struct {
	*rclgo.Publisher
}

BuiltinsPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewBuiltinsPublisher 

func NewBuiltinsPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*BuiltinsPublisher, error)

NewBuiltinsPublisher creates and returns a new publisher for the Builtins

func (*BuiltinsPublisher) Publish 

func (p *BuiltinsPublisher) Publish(msg *Builtins) error

type BuiltinsSubscription 

type BuiltinsSubscription struct {
	*rclgo.Subscription
}

BuiltinsSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewBuiltinsSubscription 

func NewBuiltinsSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback BuiltinsSubscriptionCallback) (*BuiltinsSubscription, error)

NewBuiltinsSubscription creates and returns a new subscription for the Builtins

func (*BuiltinsSubscription) TakeMessage 

func (s *BuiltinsSubscription) TakeMessage(out *Builtins) (*rclgo.MessageInfo, error)

type BuiltinsSubscriptionCallback 

type BuiltinsSubscriptionCallback func(msg *Builtins, info *rclgo.MessageInfo, err error)

BuiltinsSubscriptionCallback type is used to provide a subscription handler function for a BuiltinsSubscription.

type CArrays 

type CArrays = C.test_msgs__msg__Arrays

type CArrays__Sequence 

type CArrays__Sequence = C.test_msgs__msg__Arrays__Sequence

type CBasicTypes 

type CBasicTypes = C.test_msgs__msg__BasicTypes

type CBasicTypes__Sequence 

type CBasicTypes__Sequence = C.test_msgs__msg__BasicTypes__Sequence

type CBoundedPlainSequences 

type CBoundedPlainSequences = C.test_msgs__msg__BoundedPlainSequences

type CBoundedPlainSequences__Sequence 

type CBoundedPlainSequences__Sequence = C.test_msgs__msg__BoundedPlainSequences__Sequence

type CBoundedSequences 

type CBoundedSequences = C.test_msgs__msg__BoundedSequences

type CBoundedSequences__Sequence 

type CBoundedSequences__Sequence = C.test_msgs__msg__BoundedSequences__Sequence

type CBuiltins 

type CBuiltins = C.test_msgs__msg__Builtins

type CBuiltins__Sequence 

type CBuiltins__Sequence = C.test_msgs__msg__Builtins__Sequence

type CConstants 

type CConstants = C.test_msgs__msg__Constants

type CConstants__Sequence 

type CConstants__Sequence = C.test_msgs__msg__Constants__Sequence

type CDefaults 

type CDefaults = C.test_msgs__msg__Defaults

type CDefaults__Sequence 

type CDefaults__Sequence = C.test_msgs__msg__Defaults__Sequence

type CEmpty 

type CEmpty = C.test_msgs__msg__Empty

type CEmpty__Sequence 

type CEmpty__Sequence = C.test_msgs__msg__Empty__Sequence

type CMultiNested 

type CMultiNested = C.test_msgs__msg__MultiNested

type CMultiNested__Sequence 

type CMultiNested__Sequence = C.test_msgs__msg__MultiNested__Sequence

type CNested 

type CNested = C.test_msgs__msg__Nested

type CNested__Sequence 

type CNested__Sequence = C.test_msgs__msg__Nested__Sequence

type CStrings 

type CStrings = C.test_msgs__msg__Strings

type CStrings__Sequence 

type CStrings__Sequence = C.test_msgs__msg__Strings__Sequence

type CUnboundedSequences 

type CUnboundedSequences = C.test_msgs__msg__UnboundedSequences

type CUnboundedSequences__Sequence 

type CUnboundedSequences__Sequence = C.test_msgs__msg__UnboundedSequences__Sequence

type CWStrings 

type CWStrings = C.test_msgs__msg__WStrings

type CWStrings__Sequence 

type CWStrings__Sequence = C.test_msgs__msg__WStrings__Sequence

type Constants 

type Constants struct {
}

func NewConstants 

func NewConstants() *Constants

NewConstants creates a new Constants with default values.

func (*Constants) Clone 

func (t *Constants) Clone() *Constants

func (*Constants) CloneMsg 

func (t *Constants) CloneMsg() types.Message

func (*Constants) GetTypeSupport 

func (t *Constants) GetTypeSupport() types.MessageTypeSupport

func (*Constants) SetDefaults 

func (t *Constants) SetDefaults()

type ConstantsPublisher 

type ConstantsPublisher struct {
	*rclgo.Publisher
}

ConstantsPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewConstantsPublisher 

func NewConstantsPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*ConstantsPublisher, error)

NewConstantsPublisher creates and returns a new publisher for the Constants

func (*ConstantsPublisher) Publish 

func (p *ConstantsPublisher) Publish(msg *Constants) error

type ConstantsSubscription 

type ConstantsSubscription struct {
	*rclgo.Subscription
}

ConstantsSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewConstantsSubscription 

func NewConstantsSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback ConstantsSubscriptionCallback) (*ConstantsSubscription, error)

NewConstantsSubscription creates and returns a new subscription for the Constants

func (*ConstantsSubscription) TakeMessage 

func (s *ConstantsSubscription) TakeMessage(out *Constants) (*rclgo.MessageInfo, error)

type ConstantsSubscriptionCallback 

type ConstantsSubscriptionCallback func(msg *Constants, info *rclgo.MessageInfo, err error)

ConstantsSubscriptionCallback type is used to provide a subscription handler function for a ConstantsSubscription.

type Defaults 

type Defaults struct {
	BoolValue    bool    `yaml:"bool_value"`
	ByteValue    byte    `yaml:"byte_value"`
	CharValue    byte    `yaml:"char_value"`
	Float32Value float32 `yaml:"float32_value"`
	Float64Value float64 `yaml:"float64_value"`
	Int8Value    int8    `yaml:"int8_value"`
	Uint8Value   uint8   `yaml:"uint8_value"`
	Int16Value   int16   `yaml:"int16_value"`
	Uint16Value  uint16  `yaml:"uint16_value"`
	Int32Value   int32   `yaml:"int32_value"`
	Uint32Value  uint32  `yaml:"uint32_value"`
	Int64Value   int64   `yaml:"int64_value"`
	Uint64Value  uint64  `yaml:"uint64_value"`
}

func NewDefaults 

func NewDefaults() *Defaults

NewDefaults creates a new Defaults with default values.

func (*Defaults) Clone 

func (t *Defaults) Clone() *Defaults

func (*Defaults) CloneMsg 

func (t *Defaults) CloneMsg() types.Message

func (*Defaults) GetTypeSupport 

func (t *Defaults) GetTypeSupport() types.MessageTypeSupport

func (*Defaults) SetDefaults 

func (t *Defaults) SetDefaults()

type DefaultsPublisher 

type DefaultsPublisher struct {
	*rclgo.Publisher
}

DefaultsPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewDefaultsPublisher 

func NewDefaultsPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*DefaultsPublisher, error)

NewDefaultsPublisher creates and returns a new publisher for the Defaults

func (*DefaultsPublisher) Publish 

func (p *DefaultsPublisher) Publish(msg *Defaults) error

type DefaultsSubscription 

type DefaultsSubscription struct {
	*rclgo.Subscription
}

DefaultsSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewDefaultsSubscription 

func NewDefaultsSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback DefaultsSubscriptionCallback) (*DefaultsSubscription, error)

NewDefaultsSubscription creates and returns a new subscription for the Defaults

func (*DefaultsSubscription) TakeMessage 

func (s *DefaultsSubscription) TakeMessage(out *Defaults) (*rclgo.MessageInfo, error)

type DefaultsSubscriptionCallback 

type DefaultsSubscriptionCallback func(msg *Defaults, info *rclgo.MessageInfo, err error)

DefaultsSubscriptionCallback type is used to provide a subscription handler function for a DefaultsSubscription.

type Empty 

type Empty struct {
}

func NewEmpty 

func NewEmpty() *Empty

NewEmpty creates a new Empty with default values.

func (*Empty) Clone 

func (t *Empty) Clone() *Empty

func (*Empty) CloneMsg 

func (t *Empty) CloneMsg() types.Message

func (*Empty) GetTypeSupport 

func (t *Empty) GetTypeSupport() types.MessageTypeSupport

func (*Empty) SetDefaults 

func (t *Empty) SetDefaults()

type EmptyPublisher 

type EmptyPublisher struct {
	*rclgo.Publisher
}

EmptyPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewEmptyPublisher 

func NewEmptyPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*EmptyPublisher, error)

NewEmptyPublisher creates and returns a new publisher for the Empty

func (*EmptyPublisher) Publish 

func (p *EmptyPublisher) Publish(msg *Empty) error

type EmptySubscription 

type EmptySubscription struct {
	*rclgo.Subscription
}

EmptySubscription wraps rclgo.Subscription to provide type safe helper functions

func NewEmptySubscription 

func NewEmptySubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback EmptySubscriptionCallback) (*EmptySubscription, error)

NewEmptySubscription creates and returns a new subscription for the Empty

func (*EmptySubscription) TakeMessage 

func (s *EmptySubscription) TakeMessage(out *Empty) (*rclgo.MessageInfo, error)

type EmptySubscriptionCallback 

type EmptySubscriptionCallback func(msg *Empty, info *rclgo.MessageInfo, err error)

EmptySubscriptionCallback type is used to provide a subscription handler function for a EmptySubscription.

type MultiNested 

type MultiNested struct {
	ArrayOfArrays                         [3]Arrays             `yaml:"array_of_arrays"` // Mulitple levels of nested messages
	ArrayOfBoundedSequences               [3]BoundedSequences   `yaml:"array_of_bounded_sequences"`
	ArrayOfUnboundedSequences             [3]UnboundedSequences `yaml:"array_of_unbounded_sequences"`
	BoundedSequenceOfArrays               []Arrays              `yaml:"bounded_sequence_of_arrays"`
	BoundedSequenceOfBoundedSequences     []BoundedSequences    `yaml:"bounded_sequence_of_bounded_sequences"`
	BoundedSequenceOfUnboundedSequences   []UnboundedSequences  `yaml:"bounded_sequence_of_unbounded_sequences"`
	UnboundedSequenceOfArrays             []Arrays              `yaml:"unbounded_sequence_of_arrays"`
	UnboundedSequenceOfBoundedSequences   []BoundedSequences    `yaml:"unbounded_sequence_of_bounded_sequences"`
	UnboundedSequenceOfUnboundedSequences []UnboundedSequences  `yaml:"unbounded_sequence_of_unbounded_sequences"`
}

func NewMultiNested 

func NewMultiNested() *MultiNested

NewMultiNested creates a new MultiNested with default values.

func (*MultiNested) Clone 

func (t *MultiNested) Clone() *MultiNested

func (*MultiNested) CloneMsg 

func (t *MultiNested) CloneMsg() types.Message

func (*MultiNested) GetTypeSupport 

func (t *MultiNested) GetTypeSupport() types.MessageTypeSupport

func (*MultiNested) SetDefaults 

func (t *MultiNested) SetDefaults()

type MultiNestedPublisher 

type MultiNestedPublisher struct {
	*rclgo.Publisher
}

MultiNestedPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewMultiNestedPublisher 

func NewMultiNestedPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*MultiNestedPublisher, error)

NewMultiNestedPublisher creates and returns a new publisher for the MultiNested

func (*MultiNestedPublisher) Publish 

func (p *MultiNestedPublisher) Publish(msg *MultiNested) error

type MultiNestedSubscription 

type MultiNestedSubscription struct {
	*rclgo.Subscription
}

MultiNestedSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewMultiNestedSubscription 

func NewMultiNestedSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback MultiNestedSubscriptionCallback) (*MultiNestedSubscription, error)

NewMultiNestedSubscription creates and returns a new subscription for the MultiNested

func (*MultiNestedSubscription) TakeMessage 

func (s *MultiNestedSubscription) TakeMessage(out *MultiNested) (*rclgo.MessageInfo, error)

type MultiNestedSubscriptionCallback 

type MultiNestedSubscriptionCallback func(msg *MultiNested, info *rclgo.MessageInfo, err error)

MultiNestedSubscriptionCallback type is used to provide a subscription handler function for a MultiNestedSubscription.

type Nested 

type Nested struct {
	BasicTypesValue BasicTypes `yaml:"basic_types_value"`
}

func NewNested 

func NewNested() *Nested

NewNested creates a new Nested with default values.

func (*Nested) Clone 

func (t *Nested) Clone() *Nested

func (*Nested) CloneMsg 

func (t *Nested) CloneMsg() types.Message

func (*Nested) GetTypeSupport 

func (t *Nested) GetTypeSupport() types.MessageTypeSupport

func (*Nested) SetDefaults 

func (t *Nested) SetDefaults()

type NestedPublisher 

type NestedPublisher struct {
	*rclgo.Publisher
}

NestedPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewNestedPublisher 

func NewNestedPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*NestedPublisher, error)

NewNestedPublisher creates and returns a new publisher for the Nested

func (*NestedPublisher) Publish 

func (p *NestedPublisher) Publish(msg *Nested) error

type NestedSubscription 

type NestedSubscription struct {
	*rclgo.Subscription
}

NestedSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewNestedSubscription 

func NewNestedSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback NestedSubscriptionCallback) (*NestedSubscription, error)

NewNestedSubscription creates and returns a new subscription for the Nested

func (*NestedSubscription) TakeMessage 

func (s *NestedSubscription) TakeMessage(out *Nested) (*rclgo.MessageInfo, error)

type NestedSubscriptionCallback 

type NestedSubscriptionCallback func(msg *Nested, info *rclgo.MessageInfo, err error)

NestedSubscriptionCallback type is used to provide a subscription handler function for a NestedSubscription.

type Strings 

type Strings struct {
	StringValue                string `yaml:"string_value"`
	StringValueDefault1        string `yaml:"string_value_default1"`
	StringValueDefault2        string `yaml:"string_value_default2"`
	StringValueDefault3        string `yaml:"string_value_default3"`
	StringValueDefault4        string `yaml:"string_value_default4"`
	StringValueDefault5        string `yaml:"string_value_default5"`
	BoundedStringValue         string `yaml:"bounded_string_value"`
	BoundedStringValueDefault1 string `yaml:"bounded_string_value_default1"`
	BoundedStringValueDefault2 string `yaml:"bounded_string_value_default2"`
	BoundedStringValueDefault3 string `yaml:"bounded_string_value_default3"`
	BoundedStringValueDefault4 string `yaml:"bounded_string_value_default4"`
	BoundedStringValueDefault5 string `yaml:"bounded_string_value_default5"`
}

func NewStrings 

func NewStrings() *Strings

NewStrings creates a new Strings with default values.

func (*Strings) Clone 

func (t *Strings) Clone() *Strings

func (*Strings) CloneMsg 

func (t *Strings) CloneMsg() types.Message

func (*Strings) GetTypeSupport 

func (t *Strings) GetTypeSupport() types.MessageTypeSupport

func (*Strings) SetDefaults 

func (t *Strings) SetDefaults()

type StringsPublisher 

type StringsPublisher struct {
	*rclgo.Publisher
}

StringsPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewStringsPublisher 

func NewStringsPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*StringsPublisher, error)

NewStringsPublisher creates and returns a new publisher for the Strings

func (*StringsPublisher) Publish 

func (p *StringsPublisher) Publish(msg *Strings) error

type StringsSubscription 

type StringsSubscription struct {
	*rclgo.Subscription
}

StringsSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewStringsSubscription 

func NewStringsSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback StringsSubscriptionCallback) (*StringsSubscription, error)

NewStringsSubscription creates and returns a new subscription for the Strings

func (*StringsSubscription) TakeMessage 

func (s *StringsSubscription) TakeMessage(out *Strings) (*rclgo.MessageInfo, error)

type StringsSubscriptionCallback 

type StringsSubscriptionCallback func(msg *Strings, info *rclgo.MessageInfo, err error)

StringsSubscriptionCallback type is used to provide a subscription handler function for a StringsSubscription.

type UnboundedSequences 

type UnboundedSequences struct {
	BoolValues           []bool       `yaml:"bool_values"` // Unbounded sequences of different types
	ByteValues           []byte       `yaml:"byte_values"`
	CharValues           []byte       `yaml:"char_values"`
	Float32Values        []float32    `yaml:"float32_values"`
	Float64Values        []float64    `yaml:"float64_values"`
	Int8Values           []int8       `yaml:"int8_values"`
	Uint8Values          []uint8      `yaml:"uint8_values"`
	Int16Values          []int16      `yaml:"int16_values"`
	Uint16Values         []uint16     `yaml:"uint16_values"`
	Int32Values          []int32      `yaml:"int32_values"`
	Uint32Values         []uint32     `yaml:"uint32_values"`
	Int64Values          []int64      `yaml:"int64_values"`
	Uint64Values         []uint64     `yaml:"uint64_values"`
	StringValues         []string     `yaml:"string_values"`
	BasicTypesValues     []BasicTypes `yaml:"basic_types_values"`
	ConstantsValues      []Constants  `yaml:"constants_values"`
	DefaultsValues       []Defaults   `yaml:"defaults_values"`
	BoolValuesDefault    []bool       `yaml:"bool_values_default"`
	ByteValuesDefault    []byte       `yaml:"byte_values_default"`
	CharValuesDefault    []byte       `yaml:"char_values_default"`
	Float32ValuesDefault []float32    `yaml:"float32_values_default"`
	Float64ValuesDefault []float64    `yaml:"float64_values_default"`
	Int8ValuesDefault    []int8       `yaml:"int8_values_default"`
	Uint8ValuesDefault   []uint8      `yaml:"uint8_values_default"`
	Int16ValuesDefault   []int16      `yaml:"int16_values_default"`
	Uint16ValuesDefault  []uint16     `yaml:"uint16_values_default"`
	Int32ValuesDefault   []int32      `yaml:"int32_values_default"`
	Uint32ValuesDefault  []uint32     `yaml:"uint32_values_default"`
	Int64ValuesDefault   []int64      `yaml:"int64_values_default"`
	Uint64ValuesDefault  []uint64     `yaml:"uint64_values_default"`
	StringValuesDefault  []string     `yaml:"string_values_default"`
	AlignmentCheck       int32        `yaml:"alignment_check"` // Regression test: check alignment of basic field after a sequence field is correct
}

func NewUnboundedSequences 

func NewUnboundedSequences() *UnboundedSequences

NewUnboundedSequences creates a new UnboundedSequences with default values.

func (*UnboundedSequences) Clone 

func (t *UnboundedSequences) Clone() *UnboundedSequences

func (*UnboundedSequences) CloneMsg 

func (t *UnboundedSequences) CloneMsg() types.Message

func (*UnboundedSequences) GetTypeSupport 

func (t *UnboundedSequences) GetTypeSupport() types.MessageTypeSupport

func (*UnboundedSequences) SetDefaults 

func (t *UnboundedSequences) SetDefaults()

type UnboundedSequencesPublisher 

type UnboundedSequencesPublisher struct {
	*rclgo.Publisher
}

UnboundedSequencesPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewUnboundedSequencesPublisher 

func NewUnboundedSequencesPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*UnboundedSequencesPublisher, error)

NewUnboundedSequencesPublisher creates and returns a new publisher for the UnboundedSequences

func (*UnboundedSequencesPublisher) Publish 

func (p *UnboundedSequencesPublisher) Publish(msg *UnboundedSequences) error

type UnboundedSequencesSubscription 

type UnboundedSequencesSubscription struct {
	*rclgo.Subscription
}

UnboundedSequencesSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewUnboundedSequencesSubscription 

func NewUnboundedSequencesSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback UnboundedSequencesSubscriptionCallback) (*UnboundedSequencesSubscription, error)

NewUnboundedSequencesSubscription creates and returns a new subscription for the UnboundedSequences

func (*UnboundedSequencesSubscription) TakeMessage 

func (s *UnboundedSequencesSubscription) TakeMessage(out *UnboundedSequences) (*rclgo.MessageInfo, error)

type UnboundedSequencesSubscriptionCallback 

type UnboundedSequencesSubscriptionCallback func(msg *UnboundedSequences, info *rclgo.MessageInfo, err error)

UnboundedSequencesSubscriptionCallback type is used to provide a subscription handler function for a UnboundedSequencesSubscription.

type WStrings 

type WStrings struct {
	WstringValue                string    `yaml:"wstring_value"`
	WstringValueDefault1        string    `yaml:"wstring_value_default1"`
	WstringValueDefault2        string    `yaml:"wstring_value_default2"`
	WstringValueDefault3        string    `yaml:"wstring_value_default3"`
	ArrayOfWstrings             [3]string `yaml:"array_of_wstrings"` // wstring WSTRING_CONST="Hello world!"wstring<=22 bounded_wstring_valuewstring<=22 bounded_wstring_value_default1 "Hello world!"
	BoundedSequenceOfWstrings   []string  `yaml:"bounded_sequence_of_wstrings"`
	UnboundedSequenceOfWstrings []string  `yaml:"unbounded_sequence_of_wstrings"`
}

func NewWStrings 

func NewWStrings() *WStrings

NewWStrings creates a new WStrings with default values.

func (*WStrings) Clone 

func (t *WStrings) Clone() *WStrings

func (*WStrings) CloneMsg 

func (t *WStrings) CloneMsg() types.Message

func (*WStrings) GetTypeSupport 

func (t *WStrings) GetTypeSupport() types.MessageTypeSupport

func (*WStrings) SetDefaults 

func (t *WStrings) SetDefaults()

type WStringsPublisher 

type WStringsPublisher struct {
	*rclgo.Publisher
}

WStringsPublisher wraps rclgo.Publisher to provide type safe helper functions

func NewWStringsPublisher 

func NewWStringsPublisher(node *rclgo.Node, topic_name string, options *rclgo.PublisherOptions) (*WStringsPublisher, error)

NewWStringsPublisher creates and returns a new publisher for the WStrings

func (*WStringsPublisher) Publish 

func (p *WStringsPublisher) Publish(msg *WStrings) error

type WStringsSubscription 

type WStringsSubscription struct {
	*rclgo.Subscription
}

WStringsSubscription wraps rclgo.Subscription to provide type safe helper functions

func NewWStringsSubscription 

func NewWStringsSubscription(node *rclgo.Node, topic_name string, opts *rclgo.SubscriptionOptions, subscriptionCallback WStringsSubscriptionCallback) (*WStringsSubscription, error)

NewWStringsSubscription creates and returns a new subscription for the WStrings

func (*WStringsSubscription) TakeMessage 

func (s *WStringsSubscription) TakeMessage(out *WStrings) (*rclgo.MessageInfo, error)

type WStringsSubscriptionCallback 

type WStringsSubscriptionCallback func(msg *WStrings, info *rclgo.MessageInfo, err error)

WStringsSubscriptionCallback type is used to provide a subscription handler function for a WStringsSubscription.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.