RscType.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Enum.hxx"
#include "Arp/System/Core/TypeDeduction.hxx"
#include <type_traits>

namespace Arp { namespace System { namespace Rsc { namespace Services
{

// forwards
template<int N>
class RscString;
template<int N>
class SecureString;
class RscSecurityToken;
class IRscSerializable;
class RscVersion;
class RscGuid;

enum class RscType : uint8
{
    None            = 0xFF,
    End             = 0,
    Null            = 0,
    Void            = 1,
    Bool            = 2,
    Char            = 3,
    Int8            = 4,
    Uint8           = 5,
    Int16           = 6,
    Uint16          = 7,
    Int32           = 8,
    Uint32          = 9,
    Int64           = 10,
    Uint64          = 11,
    Real32          = 12,
    Real64          = 13,
    Struct          = 18,
    String          = 19,
    Utf8String      = 19,
    Array           = 20,
    DateTime        = 23,
    Version         = 24,
    Guid            = 25,
    AnsiString      = 26,
    Object          = 28,
    Utf16String     = 30,
    Stream          = 34,
    Enumerator      = 35,
    SecureString    = 36,
    Enum            = 37,
    Dictionary      = 38,
    SecurityToken   = 39,
    Exception       = 40,
    IecTime         = 41,
    IecTime64       = 42,
    IecDate         = 43,
    IecDate64       = 44,
    IecDateTime     = 45,
    IecDateTime64   = 46,
    IecTimeOfDay    = 47,
    IecTimeOfDay64  = 48,
};

struct RscArrayInformation
{
    RscArrayInformation(void) = default;
    RscArrayInformation(size_t size, RscType elementType, size_t dimensions = 1, size_t fieldCount = 0)
        : Size(size)
        , ElementType(elementType)
        , Dimensions(dimensions)
        , FieldCount(fieldCount)
    {}

    size_t Size = 0;

    size_t Dimensions = 1;

    RscType ElementType = RscType::None;

    size_t FieldCount = 0;
};

struct RscStructInformation
{
    RscStructInformation(size_t fieldCount) : FieldCount(fieldCount) {}

    size_t FieldCount = 0;
};

// global function GetRscType to determine RscType value by type
template<class T, bool isSerializable = std::is_base_of<IRscSerializable, T>::value>
struct StructInfo
{
    size_t FieldCount = 0;
};

template<class T>
struct StructInfo<T, true>
{
    size_t FieldCount = T::GetFieldCount();
};

template<class T>
inline 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_class<T>::value ? RscType::Struct :
               (
                   std::is_array<T>::value ? RscType::Array : RscType::None
               )
           );
}

template<>
inline constexpr RscType GetRscType<boolean>(void)
{
    return RscType::Bool;
}

template<>
inline constexpr RscType GetRscType<char8>(void)
{
    return RscType::Uint8;
}

template<>
inline constexpr RscType GetRscType<uint8>(void)
{
    return RscType::Uint8;
}

template<>
inline constexpr RscType GetRscType<int8>(void)
{
    return RscType::Int8;
}

template<>
inline constexpr RscType GetRscType<uint16>(void)
{
    return RscType::Uint16;
}

template<>
inline constexpr RscType GetRscType<int16>(void)
{
    return RscType::Int16;
}

template<>
inline constexpr RscType GetRscType<uint32>(void)
{
    return RscType::Uint32;
}

template<>
inline constexpr RscType GetRscType<int32>(void)
{
    return RscType::Int32;
}

template<>
inline constexpr RscType GetRscType<uint64>(void)
{
    return RscType::Uint64;
}

template<>
inline constexpr RscType GetRscType<int64>(void)
{
    return RscType::Int64;
}

template<>
inline constexpr RscType GetRscType<float32>(void)
{
    return RscType::Real32;
}

template<>
inline constexpr RscType GetRscType<float64>(void)
{
    return RscType::Real64;
}

template<>
inline constexpr RscType GetRscType<char*>(void)
{
    return RscType::Utf8String;
}

//template<>
//inline constexpr RscType GetRscType<IecString>(void) { return RscType::Utf8String; }
//
//template<>
//inline RscType GetRscType<StaticString<>>(void) { return RscType::Utf8String; }

template<>
inline constexpr RscType GetRscType<String>(void)
{
    return RscType::Utf8String;
}

template<>
inline constexpr RscType GetRscType<DateTime>(void)
{
    return RscType::DateTime;
}

template<>
inline constexpr RscType GetRscType<RscVersion>(void)
{
    return RscType::Version;
}

template<>
inline constexpr RscType GetRscType<RscGuid>(void)
{
    return RscType::Guid;
}

template<>
inline constexpr RscType GetRscType<RscSecurityToken>(void)
{
    return RscType::SecurityToken;
}

template<class T>
inline constexpr RscType GetRscTypeFrom(const T& /*value*/)
{
    return GetRscType<T>();
}

template<int N>
inline constexpr RscType GetRscTypeFrom(const char(&)[N])
{
    return RscType::Utf8String;
}

template<int N>
inline constexpr RscType GetRscTypeFrom(const RscString<N>&)
{
    return RscType::Utf8String;
}

template<int N>
inline constexpr RscType GetRscTypeFrom(const SecureString<N>&)
{
    return RscType::SecureString;
}

template<>
inline constexpr RscType GetRscTypeFrom(const String&)
{
    return RscType::Utf8String;
}

template<>
inline constexpr RscType GetRscTypeFrom(const DateTime&)
{
    return RscType::DateTime;
}

template<>
inline constexpr RscType GetRscTypeFrom(const RscVersion&)
{
    return RscType::Version;
}

template<>
inline constexpr RscType GetRscTypeFrom(const RscGuid&)
{
    return RscType::Guid;
}

template<>
inline constexpr RscType GetRscTypeFrom(const RscSecurityToken&)
{
    return RscType::SecurityToken;
}

inline constexpr bool IsPrimitiveRscType(RscType type)
{
    return (type >= RscType::Bool && type <= RscType::Real64) || (type >= RscType::IecTime && type <= RscType::IecTimeOfDay64);
}

inline std::ostream& operator<<(std::ostream& os, const RscType rhs)
{
    os << Enum<RscType>(rhs);
    return os;
}

}}}} // end of namespace Arp::System::Rsc::Services