DataTypeDeductionBase.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeDeduction.hxx"
#include "Arp/Plc/Commons/DataType.hpp"
#include "Arp/Plc/Commons/PlcTypes.h"
#include "Arp/Plc/Commons/Esm/IProgram.hpp"
namespace Arp { namespace Plc { namespace Commons { namespace Meta { namespace TypeSystem
{
 
using Arp::Plc::Commons::Esm::IProgram;
 
// helper types to determine element type of arrays
template<class T, bool IsArray = std::is_array<T>::value>
struct array_element_type
{
    using type = T; // primary template, none array
};
 
template<class T>
struct array_element_type<T, true>
{
    using type = typename std::remove_reference<decltype(*std::begin(std::declval<T&>()))>;
};
 
// global function GetDataType<T>() to determine DataType value by type
template<class T>
inline DataType GetDataType(void)
{
    if (std::is_enum<T>::value)
    {
        return DataType::Enum | GetDataType<typename underlying_enum_type<T>::type>();
    }
    else if (std::is_class<T>::value)
    {
        return DataType::Struct;
    }
    else if (std::is_array<T>::value)
    {
        return DataType::Array | GetDataType<typename array_element_type<T>::type>();
    }
    else if (std::is_pointer<T>::value)
    {
        return DataType::Pointer | GetDataType<typename std::remove_pointer<T>::type>();
    }
    else
    {
        return DataType::None; // this should never be returned here
    }
}
 
template<>
inline DataType GetDataType<Bit>()
{
    return DataType::Bit;
}
 
template<>
inline DataType GetDataType<boolean>()
{
    return DataType::Boolean;
}
 
template<>
inline DataType GetDataType<char8>()
{
    return DataType::Char8;
}
 
//template<>
//inline DataType GetDataType<Char16>(void) { return DataType::Char16; }
//
template<>
inline DataType GetDataType<uint8>()
{
    return DataType::UInt8;
}
 
template<>
inline DataType GetDataType<int8>(void)
{
    return DataType::Int8;
}
 
template<>
inline DataType GetDataType<uint16>(void)
{
    return DataType::UInt16;
}
 
template<>
inline DataType GetDataType<int16>(void)
{
    return DataType::Int16;
}
 
template<>
inline DataType GetDataType<uint32>(void)
{
    return DataType::UInt32;
}
 
template<>
inline DataType GetDataType<int32>(void)
{
    return DataType::Int32;
}
 
template<>
inline DataType GetDataType<uint64>(void)
{
    return DataType::UInt64;
}
 
template<>
inline DataType GetDataType<int64>(void)
{
    return DataType::Int64;
}
 
template<>
inline DataType GetDataType<float32>(void)
{
    return DataType::Float32;
}
 
template<>
inline DataType GetDataType<float64>(void)
{
    return DataType::Float64;
}
 
template<>
inline DataType GetDataType<DateTime>(void)
{
    return DataType::DateTime;
}
 
template<>
inline DataType GetDataType<String>(void)
{
    return DataType::String;
}
 
template<>
inline DataType GetDataType<IProgram>(void)
{
    return DataType::Program;
}
 
class DataTypeDeductionBase
{
protected: // typedefs/usings
    using Base = DataTypeDeductionBase;
 
protected: // construction
    DataTypeDeductionBase(DataType value) : Value(value) {}
    DataTypeDeductionBase(const DataTypeDeductionBase& arg) = default;
    DataTypeDeductionBase(DataTypeDeductionBase&& arg) = default;
    DataTypeDeductionBase& operator=(const DataTypeDeductionBase& arg) = default;
    DataTypeDeductionBase& operator=(DataTypeDeductionBase&& arg) = default;
    ~DataTypeDeductionBase(void) = default;
 
public: // operators
    operator DataType(void)const;
 
public: // fields
    DataType Value = DataType::None;
};
 
// inline methods of class DataTypeDeductionBase
inline DataTypeDeductionBase::operator DataType()const
{
    return this->Value;
}
 
}}}}} // end of namespace Arp::Plc::Commons::Meta::TypeSystem