TypeObject and TypeCode

Hello

It is possible to serialize TypeCodes or TypeObjects, store them, and deserialize them later to use them as TypesCode or TypeObjects. I’m attaching three snippets of code to show how to serialize and deserialize a TypeCode object in Java, C++11, and C/C++98

To get the TypeCode or TypeObject used by other DataWriters or DataReaders we need to subscribe to the Publication or Subscription Builtin Topic. Depending on the Types we want to gather.

Using the Java API is the easiest way since TypeCode Class implements the Serializable interface, so it is as easy as writing the object to a FileOutputStream to serialize and store, and later you can read the object from an ObjectInputStream to deserialize it and recover the typeCode.

SubscriptionBuiltinTopicData subscription_builtin_topic_data = 
        (SubscriptionBuiltinTopicData) _dataSeq.get(i);

//Extract type_code from the builtin topic
TypeCode type_code = subscription_builtin_topic_data.type_code;
TypeCode type_code_deserialize;
try{
    // Serializing 'type_code'
    FileOutputStream fos = new FileOutputStream("example_file.txt");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(type_code);
    // De-serializing 'type_code'
    FileInputStream fis = new FileInputStream("example_file.txt");
    ObjectInputStream ois = new ObjectInputStream(fis);
    try {
        type_code_deserialize = (TypeCode)ois.readObject();
    } catch (ClassNotFoundException ex1) {
        return;
    }
} catch (IOException ex2) {
    return;
}

if (type_code.equals(type_code_deserialize)) {
    System.out.println("TypeObjects are equal");
} else {
    System.out.println("TypeObjects are not equal");
}

If you are using the modern C++ API, the traditional C++ API, or the C API, it will not be as easy When using these APIs, you have to use functions from the underlying C API which are not publicly documented and may change without previous notice.

In C++98 or C the serialization and deserialization could be done as shown below: 

// Get TypeObject from the sample
DDS_TypeObject * type_object = data_seq[i].type;
DDS_TypeObjectFactory * type_object_factory = DDS_TypeObjectFactory_new();

// Create a buffer to store the serialized typeObject
unsigned int buffer_size = DDS_TypeObject_get_serialized_size(type_object);
char * buffer = new char[buffer_size];
DDS_TypeObject_serialize(type_object,buffer,&buffer_size);

// Deserialize the typeObject
DDS_TypeObject * deserialize_type_object = 
        DDS_TypeObjectFactory_create_typeobject_from_serialize_buffer(
                type_object_factory, 
                buffer, buffer_size);

delete buffer;
DDS_TypeObjectFactory_delete(type_object_factory);

// Compare the original TypeObject with the deserialized one
if (DDS_TypeObject_equal(deserialize_type_object,type_object)) {
    std::cout << "TypeObjects are equal" << std::endl;
} else {
    std::cout << "TypeObjects are not equal" << std::endl;
}

// Lastly, we could convert the TypeObject to TypeCode if required
// const DDS_TypeCode * type_code = 
//         DDS_TypeObject_convert_to_typecode(deserialize_type_object);

C++11 is so similar to C++98 but first, we should extract TypeCode from a DynamicType as the type information received by the built-in topics (SubscriptionBuiltinTopicData or PublicationBuiltinTopicData) is in the DynamicType format:

// Get Dynamic type and convert it to TypeCode
rti::core::xtypes::DynamicTypeImpl dynamic_type = 
        sample.data()->type().get();
const DDS_TypeCode type_code = dynamic_type.native();

// Convert TypeCode to TypeObject
DDS_TypeObject * type_object;
type_object = DDS_TypeObject_create_from_typecode(&type_code);

// Create a TypeObject factory
DDS_TypeObjectFactory * type_object_factory = DDS_TypeObjectFactory_new();

// Create a buffer to store serialize typeObject and serialize it
unsigned int buffer_size = DDS_TypeObject_get_serialized_size(type_object);
char * buffer = new char[buffer_size];
DDS_TypeObject_serialize(type_object,buffer,&buffer_size);

// Deserialize the typeObject
DDS_TypeObject * deserialize_type_object = 
        DDS_TypeObjectFactory_create_typeobject_from_serialize_buffer(
                type_object_factory, 
                buffer, buffer_size);
delete buffer;

// Compare the original TypeObject with the deserialized one
if(DDS_TypeObject_equal(deserialize_type_object,type_object)) {
    std::cout << "TypeObjects are equal" << std::endl;
} else {
    std::cout << "TypeObjects are not equal" << std::endl;
}

// We could convert the TypeObject to TypeCode
// const DDS_TypeCode * new_type_code = DDS_TypeObject_convert_to_typecode(deserialize_type_object);

Regards,

Alberto