streamtype.h

Go to the documentation of this file.

#pragma once
#include "streamtype_intf.h"
 
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/adtf_base.h>
 
#include <type_traits>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
class cStreamMetaType : public adtf::ucom::catwo::object<IStreamMetaType>
{
    public: 
        using cProperties = ::adtf::base::cProperties;
        using IString     = ::adtf::base::IString;
        using tVersion    = ::adtf_util::tVersion;
        using cString     = ::adtf_util::cString;
 
    protected:
        cString                                         m_strMetaTypeName;
        adtf::ucom::object_ptr<adtf::base::IProperties> m_pDefaultProperties;
        adtf::ucom::object_ptr<IStreamMetaType>         m_pParentMetaType;
        tVersion                                        m_sVersion;
 
    public: // implements IStreamMetaType
        tResult  GetMetaTypeName(IString&& strTypeName) const override;
        adtf::util::tVersion GetVersion() const override;
        tResult  GetDefaultConfig(adtf::ucom::ant::iobject_ptr<const adtf::base::IProperties>& pProperties) const override;
        tResult  GetParent(adtf::ucom::ant::iobject_ptr<const IStreamMetaType>& pParent) const override;

        tResult IsCompatible(const IStreamType& oTypeToCheck, const IStreamType& oTypeExpected) const override;
 
    public:
        cStreamMetaType();
        virtual ~cStreamMetaType() override;
 
    private:
        cStreamMetaType(const cStreamMetaType& oFromStream) = delete;
        cStreamMetaType(cStreamMetaType&& oSource) = delete;
        cStreamMetaType& operator=(const cStreamMetaType& oStreamType) = delete;
        cStreamMetaType& operator=(cStreamMetaType&& oStreamType) = delete;
 
    protected:
        tResult SetMetaTypeName(const char* strTypeName);
 
 
};
 
/*********************************************************************************************************************************************************
 * internal namespace
 ********************************************************************************************************************************************************/
namespace detail
{
 
template <typename T>
class has_set_properties: private T
{
    typedef char one;
    typedef long two;
 
    template <typename C> static one test(decltype(static_cast<void(*)(const adtf::ucom::ant::iobject_ptr<adtf::base::ant::IProperties>&)>(&has_set_properties<C>::SetProperties)));
    template <typename C> static two test(...);
 
public:
    enum { value = sizeof(test<T>(static_cast<void(*)(const adtf::ucom::ant::iobject_ptr<adtf::base::ant::IProperties>&)>(nullptr))) == sizeof(char) };
};
 
 
template <typename T, typename Enable = void>
struct stream_meta_type_properties_helper;
 
template<typename T>
struct stream_meta_type_properties_helper<T, std::enable_if_t<!has_set_properties<T>::value>>
{
    static void set_default_properties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& /*pProperties*/)
    {
    }
};
 
template <typename T>
struct stream_meta_type_properties_helper<T, std::enable_if_t<has_set_properties<T>::value>>
{
    static void set_default_properties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        T::SetProperties(pProperties);
    }
};
 
template <typename T>
class has_is_compatible: private T
{
    typedef char one;
    typedef long two;
 
    template <typename C> static one test(decltype(static_cast<tResult(*)(const adtf::streaming::ant::IStreamType&,
                                                                          const adtf::streaming::ant::IStreamType&)>(&has_is_compatible<C>::IsCompatible)));
    template <typename C> static two test(...);
 
public:
    enum { value = sizeof(test<T>(static_cast<tResult(*)(const adtf::streaming::ant::IStreamType&,
                                                         const adtf::streaming::ant::IStreamType&)>(nullptr))) == sizeof(char) };
};
 
template <typename T, typename Enable = void>
struct stream_meta_type_is_compatible_helper;
 
template<typename T>
struct stream_meta_type_is_compatible_helper<T, std::enable_if_t<!has_is_compatible<T>::value>>
{
    static constexpr bool HasIsCompatible()
    {
        return false;
    }
 
    static tResult IsCompatible(const adtf::streaming::IStreamType& /*oSourceType*/,
                                const adtf::streaming::IStreamType& /*oDestinationType*/)
    {
        RETURN_ERROR(ERR_INVALID_FUNCTION);
    }
};
 
template <typename T>
struct stream_meta_type_is_compatible_helper<T, std::enable_if_t<has_is_compatible<T>::value>>
{
    static constexpr bool HasIsCompatible()
    {
        return true;
    }
 
    static tResult IsCompatible(const adtf::streaming::IStreamType& oSourceType,
                                const adtf::streaming::IStreamType& oDestinationType)
    {
        return T::IsCompatible(oSourceType, oDestinationType);
    }
};
 
} // namespace detail
/*********************************************************************************************************************************************************
 * internal namespace end
 ********************************************************************************************************************************************************/

template <typename MetaTypeStruct>
class stream_meta_type: public cStreamMetaType
{
    public:
        stream_meta_type()
        {
            SetMetaTypeName(MetaTypeStruct::MetaTypeName);
            detail::stream_meta_type_properties_helper<MetaTypeStruct>::set_default_properties(m_pDefaultProperties);
        }

        tResult IsCompatible(const IStreamType& oCheckedType,
                             const IStreamType& oExpectedType) const override
        {
            if (detail::stream_meta_type_is_compatible_helper<MetaTypeStruct>::HasIsCompatible())
            {
                return detail::stream_meta_type_is_compatible_helper<MetaTypeStruct>::IsCompatible(oCheckedType, oExpectedType);
            }
            else
            {
                return cStreamMetaType::IsCompatible(oCheckedType, oExpectedType);
            }
        }
};

class cStreamType : public ucom::catwo::object<IStreamType>
{
    private:
        adtf::ucom::object_ptr<base::ant::IProperties> m_pProperties;
        adtf::ucom::object_ptr<const IStreamMetaType>  m_pStreamMetaType;
 
        //TODO Remove
        tTimeStamp m_pTimeStamp = -1;
    public:
        cStreamType();

        template <typename MetaType>
        cStreamType(const MetaType&)
        {
            using namespace adtf::ucom;
            m_pProperties = make_object_ptr<adtf::base::cProperties>();
            m_pStreamMetaType = make_object_ptr<stream_meta_type<MetaType>>();
            InitPropertiesFromStreamTypeDefintion(*m_pProperties.Get(), *m_pStreamMetaType.Get());
        }

        cStreamType(const IStreamType& pType);

        virtual ~cStreamType();
 
    protected:
        cStreamType(const cStreamType& oType) = delete;
        cStreamType& operator=(const cStreamType& oType)= delete;
        cStreamType(cStreamType&& oType) = delete;
        cStreamType& operator=(cStreamType&& oType) = delete;
 
    public: // implements IStreamType
        tTimeStamp GetTime() const
        {
            return m_pTimeStamp;
        }
 
        tResult SetTime(tTimeStamp oTimeStamp)
        {
            m_pTimeStamp = oTimeStamp;
            RETURN_NOERROR;
        }

        tResult  GetMetaTypeName(base::ant::IString&& strTypeName) const override;
        adtf::util::tVersion GetVersion() const override;
        tResult  GetConfig(adtf::ucom::iobject_ptr<base::ant::IProperties>& pProperties) override;
        tResult  GetConfig(adtf::ucom::iobject_ptr<const base::ant::IProperties>& pProperties) const override;
        tResult  GetMetaType(adtf::ucom::iobject_ptr<const IStreamMetaType>& pMetaType) const override;
 
    private:
        tResult InitPropertiesFromStreamTypeDefintion(base::ant::IProperties& oWhereToSet,
                                                      const IStreamMetaType& oStreamTypeDefintion);
 
};
 
} //namespace ant
 
 
 
namespace flash
{

template <typename StreamMetaType>
class stream_type: public ant::cStreamType
{
    public:
        stream_type(): ant::cStreamType(StreamMetaType())
        {
        }
};
 
} //namespace flash

using ant::cStreamMetaType;

using ant::cStreamType;

using ant::stream_meta_type;

using flash::stream_type;
 
} //namespace streaming
} //namespace adtf