DataTypeEnum.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/DataType.hpp"
#include "Arp/System/Rsc/Services/RscType.hpp"
 
namespace Arp { namespace Plc { namespace Commons
{
using Arp::System::Rsc::Services::RscType;
 
class DataTypeEnum
{
public: // construction/destruction
    DataTypeEnum(DataType dataType);
    DataTypeEnum(const DataTypeEnum& arg) = default;
    DataTypeEnum(DataTypeEnum&& arg) = default;
    DataTypeEnum& operator=(const DataTypeEnum& arg) = default;
    ~DataTypeEnum(void) = default;
 
public: // operators
    operator DataType(void)const;
    bool operator==(DataType rhs)const;
 
public: // setter operations
    void    SetFlags(DataType flags);
    void    ResetFlags(DataType flags);
    void    ResetIndirection();
 
public: // getter operations
    DataType        GetValue(void)const;
    bool            IsSet(DataType flag)const;
    bool            IsAnySet(DataType flags)const;
    bool            IsPrimitive(void)const;
    bool            IsElementary(bool useBaseType = true)const;
    bool            IsComplex(bool useBaseType = true)const;
    bool            IsPointer(void)const;
    bool            IsReference(void)const;
    bool            IsIndirect(void)const;
    bool            IsArray(void)const;
    bool            IsEnum(void)const;
    bool            IsString(void)const;
    bool            Is8BitString()const;
    bool            IsWideString()const;
    bool            IsIecObject(void)const;
    bool            HasChilds(void)const;
    DataTypeEnum    GetBaseDataType(void)const;
    size_t          GetSize(void)const;
    size_t          GetBaseSize(void)const;
    size_t          GetDataAlignment(void)const;
    bool            IsEmpty(void)const;
    RscType         GetRscType()const;
 
private: // fields
    DataType value = DataType::None;
};
 
// inline methods of class DataTypeEnum
 
inline DataTypeEnum::DataTypeEnum(DataType dataType)
    : value(dataType)
{
}
 
inline DataTypeEnum::operator DataType()const
{
    return this->value;
}
 
inline bool DataTypeEnum::operator==(DataType rhs)const
{
    return this->value == rhs;
}
 
inline DataType DataTypeEnum::GetValue()const
{
    return this->value;
}
 
inline bool DataTypeEnum::IsSet(DataType flag)const
{
    return (this->value & flag) == flag;
}
 
inline bool DataTypeEnum::IsAnySet(DataType flags)const
{
    return (this->value & flags) != DataType::None;
}
 
inline bool DataTypeEnum::IsPrimitive()const
{
    DataType baseDataType = this->GetBaseDataType();
    if ((baseDataType != DataType::None) && (baseDataType <= DataType::Primitive))
    {
        return true;
    }
    // else
    return false;
}
 
inline bool DataTypeEnum::IsElementary(bool useBaseType)const
{
    if (!useBaseType)
    {
        if (this->IsAnySet(DataType::Pointer | DataType::Enum | DataType::Array | DataType::Reference))
        {
            return true;
        }
    }
    DataType baseType = this->GetBaseDataType();
    return  (baseType > DataType::Primitive) && (baseType <= DataType::Elementary);
}
 
inline bool DataTypeEnum::IsComplex(bool useBaseType)const
{
    if (!useBaseType)
    {
        if (this->IsAnySet(DataType::Pointer | DataType::Enum | DataType::Array | DataType::Reference))
        {
            return false;
        }
    }
    DataType baseType = this->GetBaseDataType();
    return (baseType > DataType::Elementary) && (baseType <= DataType::Complex);
}
 
inline bool DataTypeEnum::IsPointer()const
{
    return this->IsSet(DataType::Pointer);
}
 
inline bool DataTypeEnum::IsReference()const
{
    return this->IsSet(DataType::Reference);
}
 
inline bool DataTypeEnum::IsIndirect()const
{
    return this->IsPointer() ||  this->IsReference();
}
 
inline bool DataTypeEnum::IsArray()const
{
    return this->IsSet(DataType::Array);
}
 
inline bool DataTypeEnum::IsEnum()const
{
    return this->IsSet(DataType::Enum);
}
 
inline bool DataTypeEnum::IsString()const
{
    return this->Is8BitString() || this->IsWideString();
}
 
inline bool DataTypeEnum::Is8BitString()const
{
    DataType baseType = this->GetBaseDataType();
    return (baseType == DataType::String) ||
           (baseType == DataType::IecString) ||
           (baseType == DataType::StaticString);
}
 
inline bool DataTypeEnum::IsWideString()const
{
    DataType baseType = this->GetBaseDataType();
    return (baseType == DataType::IecWString) ||
           (baseType == DataType::StaticWString);
}
 
inline bool DataTypeEnum::IsIecObject()const
{
    DataType baseType = this->GetBaseDataType();
    const bool isIecObjectType =
        (baseType == DataType::FunctionBlock) ||
        (baseType == DataType::Program) ||
        (baseType == DataType::Class) ||
        (baseType == DataType::Component);
    return this->IsArray() || isIecObjectType;
}
 
inline bool DataTypeEnum::HasChilds()const
{
    if (this->IsAnySet(DataType::Enum))
    {
        return false;
    }
    // else
    DataType baseType = this->GetBaseDataType();
    return (baseType > DataType::Elementary) && (baseType <= DataType::Complex);
}
 
inline DataTypeEnum DataTypeEnum::GetBaseDataType()const
{
    return DataType::BaseTypeMask & this->value;
}
 
inline bool DataTypeEnum::IsEmpty()const
{
    return this->value == DataType::None;
}
 
inline void DataTypeEnum::SetFlags(DataType flags)
{
    this->value = (this->value | flags);
}
 
inline void DataTypeEnum::ResetFlags(DataType flags)
{
    this->value = (this->value & ~flags);
}
 
}}} // end of namespace Arp::Plc::Commons