Set supported data_representations for type, add recursive scan on typetree to determine it.

Author: thijsmie

clayer/pysertype.c

@@ -795,7 +795,7 @@ static bool valid_pt_or_set_error(void *py_obj)
 static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
 {
     // PyObjects
-    PyObject *idl = NULL, *pyname = NULL, *pykeyless = NULL, *pyxcdrv2 = NULL, *v0pykeysize = NULL, *v2pykeysize = NULL;
+    PyObject *idl = NULL, *pyname = NULL, *pykeyless = NULL, *pyversion_support = NULL, *v0pykeysize = NULL, *v2pykeysize = NULL;
 #ifdef DDS_HAS_TYPE_DISCOVERY
     PyObject *xt_type_data = NULL;
     Py_buffer xt_type_map_bytes, xt_type_info_bytes;
@@ -815,8 +815,8 @@ static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
     pykeyless = PyObject_GetAttrString(idl, "keyless");
     if (!valid_topic_py_or_set_error(pykeyless)) goto err;
 
-    pyxcdrv2 = PyObject_GetAttrString(idl, "xcdrv2");
-    if (!valid_topic_py_or_set_error(pyxcdrv2)) goto err;
+    pyversion_support = PyObject_GetAttrString(idl, "version_support");
+    if (!valid_topic_py_or_set_error(pyversion_support)) goto err;
 
 #ifdef DDS_HAS_TYPE_DISCOVERY
     xt_type_data = PyObject_GetAttrString(idl, "_xt_bytedata");
@@ -833,7 +833,7 @@ static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
     Py_INCREF(pytype);
     new->my_py_type = pytype;
     new->keyless = keyless;
-    new->is_v2_by_default = pyxcdrv2 == Py_True;
+    new->is_v2_by_default = PyLong_AsLong(pyversion_support) == 2; // XCDRSupported.SupportsBasic = 1, SupportsV2 = 2
 
 #ifdef DDS_HAS_TYPE_DISCOVERY
     if (xt_type_data != Py_None && PyTuple_GetItem(xt_type_data, 0) != Py_None) {
@@ -881,20 +881,36 @@ static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
 #endif
 
     if (!keyless) {
-        new->v0_key_vm = make_key_vm(idl, false);
-        if (!valid_pt_or_set_error(new->v0_key_vm)) goto err;
         new->v2_key_vm = make_key_vm(idl, true);
         if (!valid_pt_or_set_error(new->v2_key_vm)) goto err;
 
         v0pykeysize = PyObject_GetAttrString(idl, "v0_key_max_size");
-        if (!valid_topic_py_or_set_error(v0pykeysize)) goto err;
-        v2pykeysize = PyObject_GetAttrString(idl, "v2_key_max_size");
-        if (!valid_topic_py_or_set_error(v2pykeysize)) goto err;
+        if (!valid_topic_py_or_set_error(v0pykeysize)) {
+            // No support for v0
+            if ((PyLong_AsLong(pyversion_support) & 1) > 0)
+                goto err;
+            new->v0_key_vm = NULL;
+            new->v0_key_maxsize_bigger_16 = false;
+        } else {
+            new->v0_key_vm = make_key_vm(idl, false);
+            if (!valid_pt_or_set_error(new->v0_key_vm)) goto err;
+            long long v0keysize = PyLong_AsLongLong(v0pykeysize);
+            new->v0_key_maxsize_bigger_16 = v0keysize > 16;
+        }
 
-        long long v0keysize = PyLong_AsLongLong(v0pykeysize);
-        new->v0_key_maxsize_bigger_16 = v0keysize > 16;
-        long long v2keysize = PyLong_AsLongLong(v2pykeysize);
-        new->v2_key_maxsize_bigger_16 = v2keysize > 16;
+        v2pykeysize = PyObject_GetAttrString(idl, "v2_key_max_size");
+        if (!valid_topic_py_or_set_error(v2pykeysize)) {
+            // No support for v0
+            if ((PyLong_AsLong(pyversion_support) & 2) > 0)
+                goto err;
+            new->v2_key_vm = NULL;
+            new->v2_key_maxsize_bigger_16 = false;
+        } else {
+            new->v2_key_vm = make_key_vm(idl, true);
+            if (!valid_pt_or_set_error(new->v2_key_vm)) goto err;
+            long long v2keysize = PyLong_AsLongLong(v2pykeysize);
+            new->v2_key_maxsize_bigger_16 = v2keysize > 16;
+        }
     } else {
         new->v0_key_vm = NULL;
         new->v0_key_maxsize_bigger_16 = true;
@@ -909,6 +925,12 @@ static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
         &ddspy_serdata_ops,
         keyless
     );
+
+    if (new->is_v2_by_default)
+        new->my_c_type.allowed_data_representation = DDS_DATA_REPRESENTATION_FLAG_XCDR2;
+    else
+        new->my_c_type.allowed_data_representation = DDS_DATA_REPRESENTATION_FLAG_XCDR1 | DDS_DATA_REPRESENTATION_FLAG_XCDR2;
+
     constructed = true;
 
 err:
@@ -921,7 +943,7 @@ static ddspy_sertype_t *ddspy_sertype_new(PyObject *pytype)
     Py_XDECREF(idl);
     Py_XDECREF(pyname);
     Py_XDECREF(pykeyless);
-    Py_XDECREF(pyxcdrv2);
+    Py_XDECREF(pyversion_support);
     Py_XDECREF(v0pykeysize);
     Py_XDECREF(v2pykeysize);
 

cyclonedds/builtin.py

@@ -147,7 +147,7 @@ def endpoint_constructor(keybytes, participant_keybytes, p_instance_handle, topi
             ident = None
             if typeid_bytes is not None:
                 try:
-                    ident = TypeIdentifier.deserialize(typeid_bytes, has_header=False)
+                    ident = TypeIdentifier.deserialize(typeid_bytes, has_header=False, use_version_2=True)
                 except Exception:
                     pass
 

cyclonedds/dynamic.py

@@ -45,7 +45,7 @@ def get_types_for_typeid(participant: DomainParticipant, type_id: TypeIdentifier
             raise DDSException(ret, f"Could not fetch typeobject for {tid}")
 
         try:
-            type_object = TypeObject.deserialize(ret, has_header=False)
+            type_object = TypeObject.deserialize(ret, has_header=False, use_version_2=True)
         except Exception as e:
             raise DDSException(DDSException.DDS_RETCODE_ERROR, "Got invalid TypeObject from C layer.") from e
 

cyclonedds/idl/__init__.py

@@ -25,12 +25,12 @@
 
 
 class IdlStruct(metaclass=IdlMeta):
-    def serialize(self, buffer: Optional[Buffer] = None, endianness: Optional[Endianness] = None, use_version_2: bool = None) -> bytes:
+    def serialize(self, buffer: Optional[Buffer] = None, endianness: Optional[Endianness] = None, use_version_2: Optional[bool] = None) -> bytes:
         return self.__idl__.serialize(self, buffer=buffer, endianness=endianness, use_version_2=use_version_2)
 
     @classmethod
-    def deserialize(cls: Type[_TIS], data: bytes, has_header: bool = True) -> _TIS:
-        return cls.__idl__.deserialize(data, has_header=has_header)
+    def deserialize(cls: Type[_TIS], data: bytes, has_header: bool = True, use_version_2: Optional[bool] = None) -> _TIS:
+        return cls.__idl__.deserialize(data, has_header=has_header, use_version_2=use_version_2)
 
 
 def make_idl_struct(class_name: str, typename: str, fields: Dict[str, Any], *, dataclassify=True,
@@ -157,12 +157,12 @@ def __eq__(self, other):
             return False
         return True
 
-    def serialize(self, buffer: Optional[Buffer] = None, endianness: Optional[Endianness] = None, use_version_2: bool = None) -> bytes:
+    def serialize(self, buffer: Optional[Buffer] = None, endianness: Optional[Endianness] = None, use_version_2: Optional[bool] = None) -> bytes:
         return self.__idl__.serialize(self, buffer=buffer, endianness=endianness, use_version_2=use_version_2)
 
     @classmethod
-    def deserialize(cls: Type[_TIU], data: bytes, has_header: bool = True) -> _TIU:
-        return cls.__idl__.deserialize(data, has_header=has_header)
+    def deserialize(cls: Type[_TIU], data: bytes, has_header: bool = True, use_version_2: Optional[bool] = None) -> _TIU:
+        return cls.__idl__.deserialize(data, has_header=has_header, use_version_2=use_version_2)
 
 
 def make_idl_union(class_name: str, typename: str, fields: Dict[str, ValidUnionHolder],

cyclonedds/idl/_builder.py

@@ -10,7 +10,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 """
 
-from enum import Enum
+from enum import Enum, IntFlag, auto
 from inspect import isclass
 from typing import Tuple, Type, Union
 
@@ -26,6 +26,12 @@
     case, default
 
 
+class XCDRSupported(IntFlag):
+    SupportsBasic = 1
+    SupportsV2 = 2
+    SupportsBoth = SupportsBasic | SupportsV2
+
+
 class Builder:
     easy_types = {
         char: CharMachine,
@@ -36,6 +42,70 @@ class Builder:
         None: NoneMachine
     }
 
+    @classmethod
+    def _scan_for_support(cls, _type, done) -> XCDRSupported:
+        if id(_type) in done:
+            return XCDRSupported.SupportsBoth
+        # to avoid infinite recursing. Since this is the 'all' flag it
+        # will not affect the result, because of the tree structure it is
+        # guaranteed to be binary and'ed with the real result.
+        done.add(id(_type))
+
+        if isinstance(_type, WrapOpt):
+            return XCDRSupported.SupportsV2
+        elif isinstance(_type, (typedef, sequence, array)):
+            return cls._scan_for_support(_type.subtype, done)
+        elif get_origin(_type) == list:
+            return cls._scan_for_support(get_args(_type)[0], done)
+        elif get_origin(_type) == dict:
+            return cls._scan_for_support(get_args(_type)[0], done) & cls._scan_for_support(get_args(_type)[1], done)
+        elif isclass(_type) and issubclass(_type, IdlStruct):
+            fields = get_extended_type_hints(_type)
+            annotations = get_idl_annotations(_type)
+
+            # Explicit setter
+            if 'xcdrv2' in annotations:
+                if annotations['xcdrv2']:
+                    return XCDRSupported.SupportsV2
+                else:
+                    return XCDRSupported.SupportsBasic
+
+            # Appendable and mutable is definitely V2
+            if 'extensibility' in annotations:
+                if annotations['extensibility'] in ['appendable', 'mutable']:
+                    return XCDRSupported.SupportsV2
+
+            # Check for optionals or nested mutable/appendable
+            support = XCDRSupported.SupportsBoth
+            for _, _ftype in fields.items():
+                support &= cls._scan_for_support(_ftype, done)
+
+            return support
+        elif isclass(_type) and issubclass(_type, IdlUnion):
+            fields = get_extended_type_hints(_type)
+            annotations = get_idl_annotations(_type)
+
+            # Explicit setter
+            if 'xcdrv2' in annotations:
+                if annotations['xcdrv2']:
+                    return XCDRSupported.SupportsV2
+                else:
+                    return XCDRSupported.SupportsBasic
+
+            # Appendable and mutable is definitely V2
+            if 'extensibility' in annotations:
+                if annotations['extensibility'] in ['appendable', 'mutable']:
+                    return XCDRSupported.SupportsV2
+
+            # Check for optionals or nested mutable/appendable
+            support = XCDRSupported.SupportsBoth
+            for _, _ftype in fields.items():
+                support &= cls._scan_for_support(_ftype.subtype, done)
+
+            return support
+        return XCDRSupported.SupportsBoth
+
+
     @classmethod
     def _machine_for_type(cls, _type, add_size_header, use_version_2):
         if _type in cls.easy_types:
@@ -242,4 +312,4 @@ def build_machines(cls, _type):
         else:
             raise Exception(f"Cannot build for {_type}, not struct or union.")
 
-        return v0_machine, v2_machine, keyless
+        return v0_machine, v2_machine, keyless, cls._scan_for_support(_type, set())