RscTypeDeduction.Impl.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Rsc/Commons/RscType.hpp"
#include "Arp/Base/Rsc/Commons/RscSerializable.hpp"
#include <type_traits>
 
// forwards
namespace Arp::Base::Commons::Security
{
class SecurityToken;
}
namespace Arp::Base::Rsc::Commons
{
class RscGuid;
class RscVersion;
template<int N> class RscString;
template<int N> class RscSecureString;
template<int N> class RscVariant;
}
 
namespace Arp::Base::Rsc::Commons::Impl
{
 
using Arp::Base::Commons::Security::SecurityToken;
 
// concept BoundedCharArray
template<class>
struct  IsBoundedCharArray : std::false_type {};
 
template<size_t N>
struct  IsBoundedCharArray<char[N]> : std::true_type {};
 
template<class T>
concept BoundedCharArray = IsBoundedCharArray<T>::value;
 
// concept RscArryType
template <class T>
concept ArrayType = std::is_array_v<T>&& !IsBoundedCharArray<T>::value;
 
// GetRscType<T> implementation
template<class T>
constexpr RscType GetRscType(void)
{
    // REMARK: constexpr might only have a single return statement
    return std::is_enum<T>::value ? GetRscType<typename underlying_enum_type<T>::type>() :
           (
               std::is_base_of<RscSerializable, T>::value ? RscType::Struct :
               (
                   std::is_array<T>::value ? RscType::Array : RscType::None
               )
           );
}
 
template<>
constexpr RscType GetRscType<boolean>()
{
    return RscType::Bool;
}
 
template<>
constexpr RscType GetRscType<char8>()
{
    return RscType::Uint8;
}
 
template<>
constexpr RscType GetRscType<char16>()
{
    return RscType::Char;
}
 
template<>
constexpr RscType GetRscType<uint8>()
{
    return RscType::Uint8;
}
 
template<>
constexpr RscType GetRscType<int8>()
{
    return RscType::Int8;
}
 
template<>
constexpr RscType GetRscType<uint16>()
{
    return RscType::Uint16;
}
 
template<>
constexpr RscType GetRscType<int16>()
{
    return RscType::Int16;
}
 
template<>
constexpr RscType GetRscType<uint32>()
{
    return RscType::Uint32;
}
 
template<>
constexpr RscType GetRscType<int32>()
{
    return RscType::Int32;
}
 
template<>
constexpr RscType GetRscType<uint64>()
{
    return RscType::Uint64;
}
 
template<>
constexpr RscType GetRscType<int64>()
{
    return RscType::Int64;
}
 
template<>
constexpr RscType GetRscType<float32>()
{
    return RscType::Real32;
}
 
template<>
constexpr RscType GetRscType<float64>()
{
    return RscType::Real64;
}
 
template<>
constexpr RscType GetRscType<String>()
{
    return RscType::String;
}
 
template<>
constexpr RscType GetRscType<char8*>()
{
    return RscType::String;
}
 
template<>
constexpr RscType GetRscType<char8[]>()
{
    return RscType::String;
}
 
template<>
constexpr RscType GetRscType<const char8*>()
{
    return RscType::String;
}
 
template<>
constexpr RscType GetRscType<const char8[]>()
{
    return RscType::String;
}
 
template<>
constexpr RscType GetRscType<SecurityToken>()
{
    return RscType::SecurityToken;
}
 
template<>
constexpr RscType GetRscType<DateTime>()
{
    return RscType::DateTime;
}
 
template<>
constexpr RscType GetRscType<RscVersion>()
{
    return RscType::Version;
}
 
template<>
constexpr RscType GetRscType<RscGuid>()
{
    return RscType::Guid;
}
 
} // end of namespace Arp::Base::Rsc::Commons::Impl