Namespace astutedds::xtypes

Namespace List > astutedds > xtypes

Namespaces

Type	Name
namespace	TypeLookupSerialization Serialization for TypeLookup messages.
namespace	TypeLookupTopics Topic names for TypeLookup service.

Classes

Type	Name
struct	CommonEnumeratedLiteral
struct	CommonStructMember
struct	CompleteEnumeratedLiteral
struct	CompleteEnumeratedType
struct	CompleteStructMember
struct	CompleteStructType
struct	CompleteTypeObject
class	DynamicData Runtime data container with type information.
class	DynamicType Runtime type representation.
struct	GetTypeDependenciesReply GetTypeDependencies reply data.
struct	GetTypeDependenciesRequest GetTypeDependencies request data.
struct	GetTypesReply GetTypes reply data.
struct	GetTypesRequest GetTypes request data.
struct	MemberFlag
struct	MinimalEnumeratedLiteral
struct	MinimalEnumeratedType
struct	MinimalStructMember
struct	MinimalStructType
struct	MinimalTypeObject
struct	PlainArrayLElemDefn
struct	PlainArraySElemDefn
struct	PlainMapLTypeDefn
struct	PlainMapSTypeDefn
struct	PlainSequenceLElemDefn
struct	PlainSequenceSElemDefn
struct	StringLTypeDefn
struct	StringSTypeDefn
struct	TypeIdentifier
struct	TypeIdentifierTypeObjectPair TypeObject with type identifier pair.
struct	TypeIdentifierWithDependencies Type identifier with dependencies.
class	TypeLookupManager Per-participant type lookup manager.
struct	TypeLookupReply TypeLookup reply message.
struct	TypeLookupRequest TypeLookup request message.
class	TypeLookupService TypeLookup service for remote type discovery.
struct	TypeObject

Public Types

Type	Name
typedef std::array< uint8_t, 14 >	EquivalenceHash
typedef int64_t	RequestSequenceNumber Sequence number for request correlation.
enum uint8_t	TypeIdKind
typedef std::string	TypeIdentifierKey Type identifier key for maps (hash-based string key)
typedef std::vector< TypeIdentifier >	TypeIdentifierSeq Type identifier sequence for batch requests.
enum uint8_t	TypeKind
typedef std::function< void(const TypeLookupReply &)>	TypeLookupCallback Callback for receiving type lookup replies.
enum uint8_t	TypeLookupReplyStatus TypeLookup reply status.
typedef std::function< TypeLookupReply(const TypeLookupRequest &)>	TypeLookupRequestHandler Callback for handling type lookup requests (for server mode)
enum uint8_t	TypeLookupRequestKind TypeLookup request types.

Public Functions

Type	Name
bool	are_struct_members_assignable (const CommonStructMember & source, const CommonStructMember & target)
TypeIdentifier	clone_type_identifier (const TypeIdentifier & source)
TypeIdentifier	create_array_type_identifier (const TypeIdentifier & element_type, const std::vector< uint32_t > & bounds)
CompleteTypeObject	create_complete_enum_type_object (const std::string & name, const std::vector< CompleteEnumeratedLiteral > & literals, uint16_t bit_bound=32)
CompleteTypeObject	create_complete_struct_type_object (const std::string & name, const std::vector< CompleteStructMember > & members, cdr::ExtensibilityKind extensibility=cdr::ExtensibilityKind::FINAL)
MinimalTypeObject	create_minimal_enum_type_object (const std::vector< MinimalEnumeratedLiteral > & literals, uint16_t bit_bound=32)
MinimalTypeObject	create_minimal_struct_type_object (const std::vector< MinimalStructMember > & members, cdr::ExtensibilityKind extensibility=cdr::ExtensibilityKind::FINAL)
TypeIdentifier	create_primitive_type_identifier (TypeKind kind)
TypeIdentifier	create_sequence_type_identifier (const TypeIdentifier & element_type, uint32_t bound=0)
TypeIdentifier	create_string_type_identifier (uint32_t bound=0)
TypeIdentifier	create_type_identifier_from_hash (const EquivalenceHash & hash, bool use_minimal=true)
EquivalenceHash	generate_equivalence_hash (const TypeObject & type_obj)
bool	is_assignable (const TypeObject & source, const TypeObject & target)
bool	is_collection_type_identifier (const TypeIdentifier & ti)
bool	is_enum_assignable (const CompleteEnumeratedType & source, const CompleteEnumeratedType & target)
bool	is_primitive_assignable (TypeKind source, TypeKind target)
bool	is_primitive_type_identifier (const TypeIdentifier & ti)
bool	is_string_assignable (const TypeIdentifier & source, const TypeIdentifier & target)
bool	is_string_type_identifier (const TypeIdentifier & ti)
bool	is_struct_assignable (const CompleteStructType & source, const CompleteStructType & target)
bool	operator!= (const TypeIdentifier & lhs, const TypeIdentifier & rhs)
bool	operator== (const TypeIdentifier & lhs, const TypeIdentifier & rhs)
std::vector< uint8_t >	serialize_type_object (const TypeObject & type_obj)
MinimalEnumeratedLiteral	to_minimal_enum_literal (const CompleteEnumeratedLiteral & complete)
MinimalStructMember	to_minimal_struct_member (const CompleteStructMember & complete)
std::string	to_string (const TypeIdentifier & ti)
TypeIdentifierKey	type_id_to_key (const TypeIdentifier & id) Convert TypeIdentifier to string key for map storage.

Public Types Documentation

typedef EquivalenceHash

using astutedds::xtypes::EquivalenceHash = typedef std::array<uint8_t, 14>;

---

typedef RequestSequenceNumber

Sequence number for request correlation.

using astutedds::xtypes::RequestSequenceNumber = typedef int64_t;

---

enum TypeIdKind

enum astutedds::xtypes::TypeIdKind {
    TI_STRING8_SMALL = 0x70,
    TI_STRING8_LARGE = 0x71,
    TI_STRING16_SMALL = 0x72,
    TI_STRING16_LARGE = 0x73,
    TI_PLAIN_SEQUENCE_SMALL = 0x74,
    TI_PLAIN_SEQUENCE_LARGE = 0x75,
    TI_PLAIN_ARRAY_SMALL = 0x76,
    TI_PLAIN_ARRAY_LARGE = 0x77,
    TI_PLAIN_MAP_SMALL = 0x78,
    TI_PLAIN_MAP_LARGE = 0x79,
    TI_STRONGLY_CONNECTED_COMPONENT = 0x7a,
    EK_COMPLETE = 0x7b,
    EK_MINIMAL = 0x7c
};

---

typedef TypeIdentifierKey

Type identifier key for maps (hash-based string key)

using astutedds::xtypes::TypeIdentifierKey = typedef std::string;

---

typedef TypeIdentifierSeq

Type identifier sequence for batch requests.

using astutedds::xtypes::TypeIdentifierSeq = typedef std::vector<TypeIdentifier>;

---

enum TypeKind

enum astutedds::xtypes::TypeKind {
    TK_NONE = 0x00,
    TK_BOOLEAN = 0x01,
    TK_BYTE = 0x02,
    TK_INT16 = 0x03,
    TK_INT32 = 0x04,
    TK_INT64 = 0x05,
    TK_UINT16 = 0x06,
    TK_UINT32 = 0x07,
    TK_UINT64 = 0x08,
    TK_FLOAT32 = 0x09,
    TK_FLOAT64 = 0x0a,
    TK_FLOAT128 = 0x0b,
    TK_INT8 = 0x0c,
    TK_UINT8 = 0x0d,
    TK_CHAR8 = 0x10,
    TK_CHAR16 = 0x11,
    TK_STRING8 = 0x20,
    TK_STRING16 = 0x21,
    TK_ALIAS = 0x30,
    TK_ENUM = 0x31,
    TK_BITMASK = 0x32,
    TK_ANNOTATION = 0x33,
    TK_STRUCTURE = 0x34,
    TK_UNION = 0x35,
    TK_BITSET = 0x36,
    TK_SEQUENCE = 0x40,
    TK_ARRAY = 0x41,
    TK_MAP = 0x42
};

---

typedef TypeLookupCallback

Callback for receiving type lookup replies.

using astutedds::xtypes::TypeLookupCallback = typedef std::function<void(const TypeLookupReply&)>;

---

enum TypeLookupReplyStatus

TypeLookup reply status.

enum astutedds::xtypes::TypeLookupReplyStatus {
    OK = 0,
    ERROR = 1,
    UNKNOWN_TYPE = 2,
    UNSUPPORTED_OPERATION = 3
};

---

typedef TypeLookupRequestHandler

Callback for handling type lookup requests (for server mode)

using astutedds::xtypes::TypeLookupRequestHandler = typedef std::function<TypeLookupReply(const TypeLookupRequest&)>;

---

enum TypeLookupRequestKind

TypeLookup request types.

enum astutedds::xtypes::TypeLookupRequestKind {
    GET_TYPES = 0,
    GET_TYPE_DEPENDENCIES
};

---

Public Functions Documentation

function are_struct_members_assignable

bool astutedds::xtypes::are_struct_members_assignable (
    const CommonStructMember & source,
    const CommonStructMember & target
) 

Check if struct members are assignable

---

function clone_type_identifier

TypeIdentifier astutedds::xtypes::clone_type_identifier (
    const TypeIdentifier & source
) 

Clone a TypeIdentifier (deep copy)

---

function create_array_type_identifier

TypeIdentifier astutedds::xtypes::create_array_type_identifier (
    const TypeIdentifier & element_type,
    const std::vector< uint32_t > & bounds
) 

Create TypeIdentifier for array types

---

function create_complete_enum_type_object

CompleteTypeObject astutedds::xtypes::create_complete_enum_type_object (
    const std::string & name,
    const std::vector< CompleteEnumeratedLiteral > & literals,
    uint16_t bit_bound=32
) 

Create a complete enum TypeObject

---

function create_complete_struct_type_object

CompleteTypeObject astutedds::xtypes::create_complete_struct_type_object (
    const std::string & name,
    const std::vector< CompleteStructMember > & members,
    cdr::ExtensibilityKind extensibility=cdr::ExtensibilityKind::FINAL
) 

Create a complete struct TypeObject

---

function create_minimal_enum_type_object

MinimalTypeObject astutedds::xtypes::create_minimal_enum_type_object (
    const std::vector< MinimalEnumeratedLiteral > & literals,
    uint16_t bit_bound=32
) 

Create a minimal enum TypeObject

---

function create_minimal_struct_type_object

MinimalTypeObject astutedds::xtypes::create_minimal_struct_type_object (
    const std::vector< MinimalStructMember > & members,
    cdr::ExtensibilityKind extensibility=cdr::ExtensibilityKind::FINAL
) 

Create a minimal struct TypeObject

---

function create_primitive_type_identifier

TypeIdentifier astutedds::xtypes::create_primitive_type_identifier (
    TypeKind kind
) 

Create TypeIdentifier for primitive types

---

function create_sequence_type_identifier

TypeIdentifier astutedds::xtypes::create_sequence_type_identifier (
    const TypeIdentifier & element_type,
    uint32_t bound=0
) 

Create TypeIdentifier for sequence types

---

function create_string_type_identifier

TypeIdentifier astutedds::xtypes::create_string_type_identifier (
    uint32_t bound=0
) 

Create TypeIdentifier for string types

---

function create_type_identifier_from_hash

TypeIdentifier astutedds::xtypes::create_type_identifier_from_hash (
    const EquivalenceHash & hash,
    bool use_minimal=true
) 

Create TypeIdentifier from equivalence hash

---

function generate_equivalence_hash

EquivalenceHash astutedds::xtypes::generate_equivalence_hash (
    const TypeObject & type_obj
) 

Generate equivalence hash for a TypeObject

---

function is_assignable

bool astutedds::xtypes::is_assignable (
    const TypeObject & source,
    const TypeObject & target
) 

Main assignability check - returns true if source type can be assigned to target type

---

function is_collection_type_identifier

bool astutedds::xtypes::is_collection_type_identifier (
    const TypeIdentifier & ti
) 

Check if TypeIdentifier represents a collection type

---

function is_enum_assignable

bool astutedds::xtypes::is_enum_assignable (
    const CompleteEnumeratedType & source,
    const CompleteEnumeratedType & target
) 

Check if enum types are assignable

---

function is_primitive_assignable

bool astutedds::xtypes::is_primitive_assignable (
    TypeKind source,
    TypeKind target
) 

Check if two primitive types are assignable

---

function is_primitive_type_identifier

bool astutedds::xtypes::is_primitive_type_identifier (
    const TypeIdentifier & ti
) 

Check if TypeIdentifier represents a primitive type

---

function is_string_assignable

bool astutedds::xtypes::is_string_assignable (
    const TypeIdentifier & source,
    const TypeIdentifier & target
) 

Check if string types are assignable

---

function is_string_type_identifier

bool astutedds::xtypes::is_string_type_identifier (
    const TypeIdentifier & ti
) 

Check if TypeIdentifier represents a string type

---

function is_struct_assignable

bool astutedds::xtypes::is_struct_assignable (
    const CompleteStructType & source,
    const CompleteStructType & target
) 

Check if struct types are assignable

---

function operator!=

bool astutedds::xtypes::operator!= (
    const TypeIdentifier & lhs,
    const TypeIdentifier & rhs
) 

---

function operator==

bool astutedds::xtypes::operator== (
    const TypeIdentifier & lhs,
    const TypeIdentifier & rhs
) 

Compare two TypeIdentifiers for equality

---

function serialize_type_object

std::vector< uint8_t > astutedds::xtypes::serialize_type_object (
    const TypeObject & type_obj
) 

Serialize a TypeObject to bytes (for hashing)

---

function to_minimal_enum_literal

MinimalEnumeratedLiteral astutedds::xtypes::to_minimal_enum_literal (
    const CompleteEnumeratedLiteral & complete
) 

Convert complete enum literal to minimal

---

function to_minimal_struct_member

MinimalStructMember astutedds::xtypes::to_minimal_struct_member (
    const CompleteStructMember & complete
) 

Convert complete struct member to minimal

---

function to_string

std::string astutedds::xtypes::to_string (
    const TypeIdentifier & ti
) 

Get string representation of TypeIdentifier

---

function type_id_to_key

Convert TypeIdentifier to string key for map storage.

inline TypeIdentifierKey astutedds::xtypes::type_id_to_key (
    const TypeIdentifier & id
) 

---

---

The documentation for this class was generated from the following file include/astutedds/xtypes/dynamic_data.hpp