RscType.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeDeduction.hxx"
#include "Arp/System/Core/Enum.hxx"
#include <type_traits>
 
// forwards
namespace Arp { namespace System { namespace Security
{
class SecurityToken;
}}}
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
// usings
using SecurityToken = Arp::System::Security::SecurityToken;
 
// forwards
template<int N>
class RscString;
template<int N>
class SecureString;
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>
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<>
constexpr RscType GetRscType<boolean>()
{
    return RscType::Bool;
}
 
template<>
constexpr RscType GetRscType<char8>()
{
    return RscType::Uint8;
}
 
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<char*>()
{
    return RscType::Utf8String;
}
 
template<>
constexpr RscType GetRscType<String>()
{
    return RscType::Utf8String;
}
 
template<>
constexpr RscType GetRscType<DateTime>()
{
    return RscType::DateTime;
}
 
template<>
constexpr RscType GetRscType<RscVersion>()
{
    return RscType::Version;
}
 
template<>
constexpr RscType GetRscType<RscGuid>()
{
    return RscType::Guid;
}
 
template<>
constexpr RscType GetRscType<SecurityToken>()
{
    return RscType::SecurityToken;
}
 
template<class T>
constexpr RscType GetRscTypeFrom(const T& /*value*/)
{
    return GetRscType<T>();
}
 
template<int N>
constexpr RscType GetRscTypeFrom(const char(&)[N])
{
    return RscType::Utf8String;
}
 
template<int N>
constexpr RscType GetRscTypeFrom(const RscString<N>&)
{
    return RscType::Utf8String;
}
 
template<int N>
constexpr RscType GetRscTypeFrom(const SecureString<N>&)
{
    return RscType::SecureString;
}
 
template<>
constexpr RscType GetRscTypeFrom(const String&)
{
    return RscType::Utf8String;
}
 
template<>
constexpr RscType GetRscTypeFrom(const DateTime&)
{
    return RscType::DateTime;
}
 
template<>
constexpr RscType GetRscTypeFrom(const RscVersion&)
{
    return RscType::Version;
}
 
template<>
constexpr RscType GetRscTypeFrom(const RscGuid&)
{
    return RscType::Guid;
}
 
template<>
constexpr RscType GetRscTypeFrom(const SecurityToken&)
{
    return RscType::SecurityToken;
}
 
constexpr bool IsPrimitiveRscType(RscType type)
{
    return (type >= RscType::Bool && type <= RscType::Real64) || (type >= RscType::IecTime && type <= RscType::IecTimeOfDay64);
}
 
// global stream operators of enum LogLevel for logging and parsing
ARP_CXX_SYMBOL_EXPORT std::ostream& operator<<(std::ostream& os, const RscType value);
ARP_CXX_SYMBOL_EXPORT std::istream& operator>>(std::istream& is, RscType& value);
 
}}}} // end of namespace Arp::System::Rsc::Services