ddenum.h

Go to the documentation of this file.

 
#ifndef DDENUM_H_INCLUDED
#define DDENUM_H_INCLUDED
 
#include <ddl/dd/dd.h>
#include <ddl/dd/dddatatype.h>
#include <ddl/utilities/std_to_string.h>
 
namespace ddl {
 
class DDEnum {
public:
    DDEnum() = delete;
    DDEnum(DDEnum&&);
    DDEnum& operator=(DDEnum&&);
    DDEnum(const DDEnum& other);
    DDEnum& operator=(const DDEnum& other);
    DDEnum(const std::string& name,
           const dd::DataType& data_type,
           const std::vector<dd::EnumType::Element>& elements = {});
 
    DDEnum(const std::string& name,
           const DDDataType& data_type,
           const std::vector<dd::EnumType::Element>& elements = {});
 
    DDEnum& addElement(const dd::EnumType::Element& element);
    DDEnum& addElement(const std::string& name, int64_t value);
    DDEnum& addElements(const std::vector<dd::EnumType::Element>& elements);
 
    const dd::EnumType& getEnumType() const;
    const dd::DataDefinition& getDD() const;
 
    size_t getTypeByteSize() const;
 
    size_t getAlignment() const;
 
private:
    dd::DataDefinition _dd;
    // the enumtype
    std::shared_ptr<dd::EnumType> _enum_type;
};
 
template <typename EnumDataType, typename Enable = void>
class DDEnumGenerator : public DDEnum {
public:
    DDEnumGenerator(const std::string& name,
                    const std::vector<std::pair<std::string, EnumDataType>> elements = {})
        : DDEnum(name, DataType<typename std::underlying_type<EnumDataType>::type>())
    {
        for (const auto& elem: elements) {
            DDEnum::addElement(dd::EnumType::Element(
                elem.first,
                std::to_string(
                    static_cast<typename std::underlying_type<EnumDataType>::type>(elem.second))));
        }
    }
 
    DDEnumGenerator& addElement(const std::string& name, EnumDataType value)
    {
        DDEnum::addElement(dd::EnumType::Element(
            name,
            std::to_string(static_cast<typename std::underlying_type<EnumDataType>::type>(value))));
        return *this;
    }
};
 
template <typename EnumDataType>
class DDEnumGenerator<EnumDataType,
                      typename std::enable_if<std::is_arithmetic<EnumDataType>::value>::type>
    : public DDEnum {
public:
    DDEnumGenerator(const std::string& name,
                    const std::vector<std::pair<std::string, EnumDataType>> elements = {})
        : DDEnum(name, DataType<EnumDataType>())
    {
        for (const auto& elem: elements) {
            DDEnum::addElement(dd::EnumType::Element(elem.first, std::to_string(elem.second)));
        }
    }
};
 
} // namespace ddl
 
#endif // DDENUM_H_INCLUDED