streammetatypestring.h

Go to the documentation of this file.

 
#pragma once
#include "streamtype.h"
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/adtf_base.h>
#include <adtf_base_deprecated.h>
#include <type_traits>
#include <cinttypes>
 
namespace adtf
{
namespace streaming
{
namespace penguin
{
 
struct stream_meta_type_string
{
    static constexpr const tChar* const MetaTypeName = "adtf/string";
 
    static constexpr const tChar* const DataEndianess = "data_endianess";
 
    enum class EncodingType
    {
        unknown = 0,
        unspecified = 1,
        c_char = 2,
        utf8 = 3,
        w_char = 4,
        w_char_16 = w_char,
        utf16 = 5
    };
    static constexpr const tChar* const Encoding = "encoding";
    static constexpr const tChar* const EncodingValueUnspecified = "unspecified";
    static constexpr const tChar* const EncodingValueCChar = "c-char";
    static constexpr const tChar* const EncodingValueUTF8 = "utf8";
    static constexpr const tChar* const EncodingValueWChar = "w-char";
    static constexpr const tChar* const EncodingValueUTF16 = "utf16";
 
    static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(Encoding, EncodingValueUnspecified));
        pProperties->SetProperty(adtf::base::property<uint8_t>(DataEndianess, PLATFORM_BYTEORDER));
    }
 
    static adtf_util::cString GetEncoding(const adtf::streaming::IStreamType& pStreamType)
    {
        adtf::ucom::object_ptr<const adtf::base::IProperties> pProperties;
        THROW_IF_FAILED(pStreamType.GetConfig(pProperties));
        if (pProperties)
        {
            return adtf::base::get_property<adtf_util::cString>(*pProperties, Encoding);
        }
        else
        {
            THROW_ERROR_DESC(ERR_NOT_FOUND, "StreamType has no properties");
        }
    }
    static void SetEncoding(adtf::streaming::IStreamType& pStreamType, const char* strEncodingType)
    {
        adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
        THROW_IF_FAILED(pStreamType.GetConfig(pProperties));
        if (pProperties)
        {
            THROW_IF_FAILED(adtf::base::set_property<adtf_util::cString>(*pProperties, Encoding, strEncodingType));
        }
        else
        {
            THROW_ERROR_DESC(ERR_NOT_FOUND, "StreamType has no properties");
        }
    }
 
    static EncodingType GetEncodingType(const adtf::streaming::IStreamType& pStreamType)
    {
        auto oEncodingType = GetEncoding(pStreamType);
        if (oEncodingType == EncodingValueCChar)
        {
            return EncodingType::c_char;
        }
        else if (oEncodingType == EncodingValueUnspecified)
        {
            return EncodingType::unspecified;
        }
        else if (oEncodingType == EncodingValueUTF8)
        {
            return EncodingType::utf8;
        }
        else if (oEncodingType == EncodingValueWChar)
        {
            return EncodingType::w_char_16;
        }
        else if (oEncodingType == EncodingValueUTF16)
        {
            return EncodingType::utf16;
        }
        else
        {
            return EncodingType::unknown;
        }
    }
    static void SetEncodingType(adtf::streaming::IStreamType& pStreamType, EncodingType eEncodingType)
    {
        switch (eEncodingType)
        {
            case EncodingType::unknown:
            {
                THROW_ERROR_DESC(ERR_INVALID_ARG, "EncodingType::unknown can not be set");
            }
            break;
            case EncodingType::c_char:
            {
                SetEncoding(pStreamType, EncodingValueCChar);
            }
            break;
            case EncodingType::utf8:
            {
                SetEncoding(pStreamType, EncodingValueUTF8);
            }
            break;
            case EncodingType::w_char_16:
            {
                SetEncoding(pStreamType, EncodingValueWChar);
            }
            break;
            case EncodingType::utf16:
            {
                SetEncoding(pStreamType, EncodingValueUTF16);
            }
            break;
            case EncodingType::unspecified:
            {
                SetEncoding(pStreamType, EncodingValueUnspecified);
            }
            break;
        }
    }
 
    static tResult IsCompatible(const adtf::streaming::IStreamType& oTypeToCheck,
                                const adtf::streaming::IStreamType& oTypeExpected)
    {
        adtf::ucom::object_ptr<const adtf::base::IProperties> pCheckProperties;
        RETURN_IF_FAILED(oTypeToCheck.GetConfig(pCheckProperties));
        adtf::ucom::object_ptr<const adtf::base::IProperties> pExpectedProperties;
        RETURN_IF_FAILED(oTypeExpected.GetConfig(pExpectedProperties));
 
        auto strCheckEncoding = adtf::base::get_property<adtf_util::cString>(*pCheckProperties, Encoding);
        auto strExpectedEncoding = adtf::base::get_property<adtf_util::cString>(*pExpectedProperties, Encoding);
        if (strExpectedEncoding != EncodingValueUnspecified && strCheckEncoding != strExpectedEncoding)
        {
            RETURN_ERROR_DESC(ERR_FAILED,
                              "The destination stream type string Encoding expects '%s' but '%s' was found!",
                              strCheckEncoding.GetPtr(), strExpectedEncoding.GetPtr());
        }
        if (strExpectedEncoding != EncodingValueUnspecified && strCheckEncoding != EncodingValueUTF8
            && strCheckEncoding != EncodingValueCChar)
        {
            const auto nByteOrderCheck
                = adtf::base::get_property<uint8_t>(*pCheckProperties, DataEndianess, PLATFORM_LITTLE_ENDIAN_8);
            const auto nByteOrderExpected
                = adtf::base::get_property<uint8_t>(*pExpectedProperties, DataEndianess, PLATFORM_LITTLE_ENDIAN_8);
            if (nByteOrderCheck != nByteOrderExpected)
            {
                RETURN_ERROR_DESC(ERR_FAILED,
                                  "The destination stream type string byte order expects '%" PRIu8 "' but '%" PRIu8 "' was found!",
                                  nByteOrderCheck, nByteOrderExpected);
            }
        }
        RETURN_NOERROR;
    }
};
 
template<typename T>
class stream_type_string
{
public:
    stream_type_string(stream_meta_type_string::EncodingType eEncoding)
    {
        static_assert(base::penguin::detail::always_false<T>,
                      "Invalid type for stream_type_string<T> used!"
                      "Use supported std::string or std::u16string only");
    }
};
 
template<>
class stream_type_string<std::string> : public cStreamType
{
public:
    stream_type_string(stream_meta_type_string::EncodingType eEncoding = stream_meta_type_string::EncodingType::c_char):
        cStreamType(stream_meta_type_string())
    {
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties;
        GetConfig(pProperties);
        if (pProperties)
        {
            stream_meta_type_string::SetEncodingType(*this, eEncoding);
        }
    }
};
 
template<>
class 
ADTF3_DEPRECATED("std::wstring can only be used if value type is guaranteed for 16Bit encodings. Use "
                   "stream_type_string<std::u16string> instead!")
stream_type_string<std::wstring> : public cStreamType
{
public:
    stream_type_string(stream_meta_type_string::EncodingType eEncoding = stream_meta_type_string::EncodingType::w_char):
        cStreamType(stream_meta_type_string())
    {
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties;
        GetConfig(pProperties);
        if (pProperties)
        {
            stream_meta_type_string::SetEncodingType(*this, eEncoding);
        }
    }
};
 
template<>
class stream_type_string<std::u16string> : public cStreamType
{
public:
    stream_type_string(stream_meta_type_string::EncodingType eEncoding = stream_meta_type_string::EncodingType::w_char_16):
        cStreamType(stream_meta_type_string())
    {
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties;
        GetConfig(pProperties);
        if (pProperties)
        {
            stream_meta_type_string::SetEncodingType(*this, eEncoding);
        }
    }
};
}
 
using penguin::stream_meta_type_string;
 
using penguin::stream_type_string;
 
} //namespace streaming
} //namespace adtf