DDL Decoder/Codec

Table of Contents

• Accessing Data with a Decoder/Codec
• Decoding
• Encoding
• Selecting the Data Representation
• Inspection
• Transformation

Accessing Data with a Decoder/Codec

Let's take a look at a basic structure:

<struct alignment="4" name="tTest" version="1" ddlversion="2.0">
    <element name="bBool" type="tBool" arraysize="1">
        <serialized byteorder="LE" bytepos="0" bitpos="0" numbits="8"/>
        <deserialized alignment="1"/>
    </element>
    <element name="nInt8" type="tInt8" arraysize="1">
        <serialized byteorder="LE" bytepos="1" bitpos="0" numbits="8"/>
        <deserialized alignment="1"/>
    </element>
    <element name="nUInt32" type="tUInt32" arraysize="1">
        <serialized byteorder="LE" bytepos="2" bitpos="0" numbits="32"/>
        <deserialized alignment="4"/>
    </element>
    <element name="fFloat32" type="tFloat32" arraysize="1">
        <serialized byteorder="LE" bytepos="6" bitpos="0" numbits="32"/>
        <deserialized alignment="4"/>
    </element>
</struct>

Decoding

Read access is handled with the ddl::codec::StaticDecoder or ddl::codec::Decoder class:

tFloat64 readData(const void* const_data, size_t data_size)
{
    // this should of course be cached (as a member etc.)
    ddl::CodecFactory factory("tTest", "<ddl:ddl>....");
 
    // retrieve the codec index for a value for fast access
    auto codec_index_for_fFloat32 = factory.getElement("fFloat32").getIndex();
 
    // start decoding for data
    auto decoder = factory.makeDecoderFor(const_data, data_size);
    float value;
 
    // for name based lookup use getElement
    {
        value = decoder.getElement("fFloat32").getValue<float>();
    }
 
    // alternativley you can of course use indexed based lookup for fast access
    {
        value = decoder.getElementValue<float>(codec_index_for_fFloat32);
    }
 
    return value;
}

The example shows the usage of the ddl::codec::Decoder class with which handling of dynamic elements is possible (see also dynamic arrays within structs). A more efficient decoding initialization is provided via ddl::codec::StaticDecoder, but it allows only access to the static elements.

Encoding

Write access is handled with the ddl::codec::Codec or ddl::codec::StaticCodec class:

void writeData(void* data, size_t data_size, tFloat64 value)
{
    // this should of course be cached (as a member etc.)
    ddl::codec::CodecFactory factory("tTest", "<ddl:ddl>....");
    // retrieve the codec index for a value for fast access
    auto codec_index_for_fFloat32 = factory.getElement("fFloat32").getIndex();
 
    // start decoding / encoding for data
    auto codec = factory.makeCodecFor(data, data_size);
 
    // name based lookup
    codec.getElement("fFloat32").setValue(value);
    // or codec index based for fast access
    codec.setElementValue(codec_index_for_fFloat32, value);
}

The example shows the usage of the ddl::codec::Coder class with which handling of dynamic elements is possible (see also dynamic arrays within structs). A more efficient coding initialization is provided via ddl::codec::StaticCodec, but it allows only access to the static elements.

Selecting the Data Representation

By default decoders/codecs are created for the deserialized representation. To create them for the serialized representation pass the correct parameters to the "make..." methods.

auto decoder = factory.makeDecoderFor(const_data, data_size,
                                      DataRepresentation::serialized);

Inspection

You can inspect the struct handled by a decoder/codec with the help of forEachLeafElement and ddl::codec::StaticDecoder::getElements:

void dumpStructElements(const ddl::codec::StaticDecoder& decoder)
{
    forEachLeafElement(decoder.getElements(),
                       [](auto& element)
                       {
                           std::cout << element.getFullName();
                       });
}

Transformation

Converting between the representations can be done with ddl::codec::transform:

a_util::memory::MemoryBuffer getSerializedBuffer(const ddl::codec::Decoder& decoder)
{
    const auto serialized_size = decoder.getStaticBufferSize(ddl::DataRepresentation::serialized);
    a_util::memory::MemoryBuffer buffer(serialized_size);
    auto codec = decoder.makeCodecFor(
        buffer.getPtr(), buffer.getSize(), ddl::DataRepresentation::serialized);
    ddl::codec::transform(decoder, codec);
    return buffer;
}