streamtype_intf.h

Go to the documentation of this file.

 
#pragma once
 
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/string_intf.h>
#include <adtfbase/property_intf.h>
#include <adtfbase/properties.h>
#include <adtfucom3/adtf_ucom3.h>
 
#include <string>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
class IStreamType;
 
class IStreamMetaType : public ucom::ant::IObject
{
protected:
    ~IStreamMetaType() = default;
public:
 
public:
    ADTF_IID(IStreamMetaType, "streamtypedef.ant.streaming.adtf.iid");
 
    virtual tResult  GetMetaTypeName(base::ant::IString&& strTypeName) const = 0;
 
    virtual adtf::util::tVersion GetVersion() const = 0;
 
    virtual tResult  GetDefaultConfig(ucom::ant::iobject_ptr<const base::ant::IProperties>& pProperties) const = 0;
 
    virtual tResult GetParent(ucom::ant::iobject_ptr<const IStreamMetaType>& pParent) const = 0;
 
    virtual tResult IsCompatible(const IStreamType& oTypeToCheck, const IStreamType& oExpectedType) const = 0;
};//class IStreamMetaType
            
class IStreamType: public ::adtf::ucom::IObject
{
protected:
    ~IStreamType() = default;
 
public:
    ADTF_IID(IStreamType, "streamtype.ant.streaming.adtf.iid");
 
    virtual tResult  GetMetaTypeName(base::ant::IString&& strTypeName) const = 0;
 
    virtual adtf::util::tVersion GetVersion() const = 0;
 
    virtual tResult GetConfig(ucom::ant::iobject_ptr<base::ant::IProperties>& pProperties) = 0;
 
    virtual tResult GetConfig(ucom::ant::iobject_ptr<const base::ant::IProperties>& pProperties) const = 0;
 
    virtual tResult GetMetaType(ucom::ant::iobject_ptr<const IStreamMetaType>& pMetaType) const = 0;
};//class IStreamType
 
}
 
namespace spider
{
 
inline tResult is_equal(const ant::IStreamType& oLeftType, const ant::IStreamType& oRightType)
{
    if (&oLeftType == &oRightType)
    {
        RETURN_NOERROR;
    }
 
    if (IS_FAILED(oLeftType.GetMetaTypeName(base::cStringRedirect([&](const base::IString& strLeftValue) -> tResult
    {
        return oRightType.GetMetaTypeName(base::cStringRedirect([&](const base::IString& strRightValue) -> tResult
        {
            if (std::string_view(strLeftValue.Get(), strLeftValue.GetLength()) != 
                std::string_view(strRightValue.Get(), strRightValue.GetLength()))
            {
                RETURN_ERROR(ERR_FAILED);
            }
            RETURN_NOERROR;
        }));
    }))))
    {
        RETURN_ERROR(ERR_FAILED);
    }
 
    ucom::object_ptr<const base::IProperties> pPropertiesLeft;
    RETURN_IF_FAILED(oLeftType.GetConfig(pPropertiesLeft));
    ucom::object_ptr<const base::IProperties> pPropertiesRight;
    RETURN_IF_FAILED(oRightType.GetConfig(pPropertiesRight));
 
    return base::is_equal(*pPropertiesLeft, *pPropertiesRight);
}
 
}
namespace ant
{
 
template<typename T>
bool operator==(const IStreamType& oStreamType, T /* oValue */)
{
    adtf::util::cString strMetaTypeName;
    oStreamType.GetMetaTypeName(adtf_string_intf(strMetaTypeName));
    return strMetaTypeName.IsEqual(T::MetaTypeName);
}
 
template<typename T>
bool operator!=(const IStreamType& oStreamType, T oValue)
{
    return !(oStreamType == oValue);
}
 
inline bool operator==(const IStreamType& oStreamTypeLeft, const IStreamType& oStreamTypeRight)
{
    return IS_OK(spider::is_equal(oStreamTypeLeft, oStreamTypeRight));
}
 
inline bool operator!=(const IStreamType& oStreamTypeLeft, const IStreamType& oStreamTypeRight)
{
    return !(oStreamTypeLeft == oStreamTypeRight);
}
 
template<typename VALUETYPE>
tResult set_property(IStreamType& oStreamType, const char* strNameOfValue, VALUETYPE oValue)
{
    adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
    RETURN_IF_FAILED(oStreamType.GetConfig(pProperties));
    return adtf::base::set_property<VALUETYPE>(*pProperties, strNameOfValue, oValue);
}
 
inline tResult set_property(IStreamType& oStreamType, const char* strNameOfValue, const char* poValue)
{
    adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
    RETURN_IF_FAILED(oStreamType.GetConfig(pProperties));
    return adtf::base::set_property<adtf_util::cString>(*pProperties, strNameOfValue, adtf_util::cString(poValue));
}
 
template<typename VALUETYPE>
VALUETYPE get_property(const IStreamType& oStreamType, const char* strNameOfValue, VALUETYPE oDefaultValue)
{
    adtf::ucom::object_ptr<const adtf::base::IProperties> pProperties;
    if (IS_OK(oStreamType.GetConfig(pProperties)))
    {
        return adtf::base::get_property<VALUETYPE>(*pProperties, strNameOfValue, oDefaultValue);
    }
    else
    {
        return oDefaultValue;
    }
}
template<typename VALUETYPE>
VALUETYPE get_property(const IStreamType& oStreamType, const char* strNameOfValue)
{
    return get_property<VALUETYPE>(oStreamType, strNameOfValue, VALUETYPE());
}
 
} //namespace ant
 
namespace flash
{
 
tResult is_compatible(const ant::IStreamType& oCheckedType,
                      const ant::IStreamType& oExpectedType);
 
tResult is_compatible(const ucom::ant::iobject_ptr<const ant::IStreamType>& pCheckedType,
                      const ucom::ant::iobject_ptr<const ant::IStreamType>& pExpectedType);
 
tResult is_compatible(const ant::IStreamType& oCheckedType,
                      const ucom::ant::iobject_ptr<const ant::IStreamType>& pExpectedType);
 
tResult is_compatible(const ucom::ant::iobject_ptr<const ant::IStreamType>& pCheckedType,
                      const ant::IStreamType& oExpectedType);
 
template <typename T>
class is_stream_meta_type
{
    typedef char one;
    typedef long two;
 
    template <typename C> static one test( decltype(&C::MetaTypeName) ) ;
 
    template <typename C> static two test(...);
 
public:
    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
};
 
}
 
namespace ant
{
 
template<typename T,
         typename std::enable_if_t<flash::is_stream_meta_type<T>::value, int> = 0>
bool operator==(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType,
                 const T& oValue)
{
    if (!pStreamType.Get())
    {
        return false;
    }
    return *pStreamType.Get() == oValue;
}
 
template<typename T,
         typename std::enable_if_t<flash::is_stream_meta_type<T>::value, int> = 0>
bool operator!=(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType,
                 const T& oValue)
{
    return !(pStreamType == oValue);
}
 
}
 
using ant::IStreamMetaType;
using ant::IStreamType;
using ant::get_property;
using ant::set_property;
using flash::is_compatible;
using flash::is_stream_meta_type;
using spider::is_equal;
 
} //namespac streaming
} // namespace adtf