ddl_helpers.h

Go to the documentation of this file.

 
#pragma once
 
#include <adtf_file/adtf_file_reader.h>
#include <adtf_file/stream_type.h>
#include <ddl/ddl.h>
#include <ddl/codec/codec_factory.h>

#define A_UTIL_THROW_IF_FAILED(__exp, __msg)\
{\
    auto __result = (__exp);\
    if (!__result)\
    {\
        throw std::runtime_error(std::string(__msg) + ": " +\
                                 a_util::result::toString(__result));\
    }\
}
 
namespace adtfdat_processing
{

inline std::tuple<std::string, std::string, bool> getMediaDescriptionFromStreamType(const std::shared_ptr<const adtf_file::StreamType>& stream_type)
{
    auto property_type = std::dynamic_pointer_cast<const adtf_file::PropertyStreamType>(stream_type);
    if (!property_type)
    {
        throw std::runtime_error("The stream type is not a property stream type");
    }
 
    auto media_description = property_type->getProperty("md_definitions");
    auto struct_name = property_type->getProperty("md_struct");
    bool data_is_serialized = false;
    try
    {
        data_is_serialized = property_type->getProperty("md_data_serialized").second == "true";
    }
    catch (...)
    {
    }
 
    return {struct_name.second, media_description.second, data_is_serialized};
}

inline std::shared_ptr<adtf_file::StreamType> createAdtfDefaultStreamType(const std::string& struct_name,
                                                                          const std::string& struct_definition,
                                                                          bool is_serialized = false)
{
    auto type = std::make_shared<adtf_file::DefaultStreamType>("adtf/default");
    type->setProperty("md_definitions", "cString", struct_definition);
    type->setProperty("md_struct", "cString", struct_name);
    type->setProperty("md_data_serialized", "tBool", is_serialized ? "true" : "false");
    return type;
}

inline std::tuple<ddl::codec::CodecFactory, bool> createDDLCodecFactoryFromStreamType(const std::shared_ptr<const adtf_file::StreamType>& stream_type)
{
    const auto media_description = getMediaDescriptionFromStreamType(stream_type);
 
    ddl::codec::CodecFactory factory(std::get<0>(media_description), std::get<1>(media_description));
    if (!factory.isValid())
    {
        throw std::runtime_error("unable to parse media description: " + a_util::result::toString(factory.isValid()));
    }
 
    return std::tuple<ddl::codec::CodecFactory, bool>(std::move(factory), std::get<2>(media_description));
}

template<typename ElementsType>
using element_callback = std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                                const typename ElementsType::element_type,
                                                                typename ElementsType::element_type>&)>;

template<typename ElementsType>
void for_each_leaf_element(ElementsType& elements, const element_callback<ElementsType>& callback)
{
    for (auto& current_element : elements)
    {
        if (current_element.hasChildren())
        {
            if (current_element.isArray())
            {
                for (size_t array_pos = 0; array_pos < current_element.getArraySize(); ++array_pos)
                {
                    auto array_element = current_element.getArrayElement(array_pos);
                    auto& children = array_element.getChildElements();
                    for_each_leaf_element(children, callback);
                }
            }
            else
            {
                auto& children = current_element.getChildElements();
                for_each_leaf_element(children, callback);
            }
        }
        else
        {
            if (current_element.isArray())
            {
                for (size_t array_pos = 0; array_pos < current_element.getArraySize(); ++array_pos)
                {
                    auto array_element = current_element.getArrayElement(array_pos);
                    callback(array_element);
                }
            }
            else
            {
                callback(current_element);
            }
        }
    }
}
 
}