dd_predefined_datatypes.h

Go to the documentation of this file.

 
#ifndef DD_PREDEFINED_DATATYPES_H_INCLUDED
#define DD_PREDEFINED_DATATYPES_H_INCLUDED
 
#include <a_util/preprocessor/detail/disable_warnings.h>
#include <ddl/dd/datamodel/datamodel_types.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/utilities/std_to_string.h>
 
#include <limits>
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace ddl {

template <typename T>
class DataType : public dd::datamodel::DataType {
public:
    DataType(const std::string&)
    {
        static_assert(std::is_arithmetic<T>::value,
                      "To use this type, only primitive types are allowed");
    }

    DataType()
    {
        static_assert(std::is_arithmetic<T>::value,
                      "To use this type, only primitive types are allowed");
    }
};
 
} // namespace ddl
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))

#define DDL_DATA_TYPE_INT(type, default_name)                                                      \
    namespace ddl {                                                                                \
    template <>                                                                                    \
    class DataType<type> : public dd::datamodel::DataType {                                        \
    public:                                                                                        \
        DataType(const std::string& name)                                                          \
            : dd::datamodel::DataType(name,                                                        \
                                      sizeof(type) * 8,                                            \
                                      std::string("Predefined DataType for ") + name,              \
                                      1,                                                           \
                                      "",                                                          \
                                      std::to_string((std::numeric_limits<type>::min)()),          \
                                      std::to_string((std::numeric_limits<type>::max)()),          \
                                      alignof(type))                                               \
        {                                                                                          \
        }                                                                                          \
        DataType() : DataType(default_name)                                                        \
        {                                                                                          \
        }                                                                                          \
    };                                                                                             \
    } /* namespace ddl */                                                                          \
    static_assert(true, "Simply to make sure a closing semicolon ';' is used for the macro")

DDL_DATA_TYPE_INT(uint8_t, "tUInt8");
DDL_DATA_TYPE_INT(uint16_t, "tUInt16");
DDL_DATA_TYPE_INT(uint32_t, "tUInt32");
DDL_DATA_TYPE_INT(uint64_t, "tUInt64");
 
DDL_DATA_TYPE_INT(int8_t, "tInt8");
DDL_DATA_TYPE_INT(int16_t, "tInt16");
DDL_DATA_TYPE_INT(int32_t, "tInt32");
DDL_DATA_TYPE_INT(int64_t, "tInt64");
 
namespace ddl {

template <>
class DataType<bool> : public dd::datamodel::DataType {
public:
    DataType(const std::string& name)
        : dd::datamodel::DataType(name,
                                  sizeof(bool) * 8,
                                  std::string("Predefined DataType for ") + name,
                                  1,
                                  {},
                                  {},
                                  {},
                                  alignof(bool))
    {
    }

    DataType() : DataType("tBool")
    {
    }
};

template <>
class DataType<char> : public dd::datamodel::DataType {
public:
    DataType(const std::string& name)
        : dd::datamodel::DataType(name,
                                  sizeof(char) * 8,
                                  std::string("Predefined DataType for ") + name,
                                  1,
                                  {},
                                  {},
                                  {},
                                  alignof(char))
    {
    }

    DataType() : DataType("tChar")
    {
    }
};

template <>
class DataType<float> : public dd::datamodel::DataType {
public:
    DataType(const std::string& name)
        : dd::datamodel::DataType(name,
                                  sizeof(float) * 8,
                                  std::string("Predefined DataType for ") + name,
                                  1,
                                  {},
                                  {},
                                  {},
                                  alignof(float))
    {
    }

    DataType() : DataType("tFloat32")
    {
    }
};

template <>
class DataType<double> : public dd::datamodel::DataType {
public:
    DataType(const std::string& name)
        : dd::datamodel::DataType(name,
                                  sizeof(double) * 8,
                                  std::string("Predefined DataType for ") + name,
                                  1,
                                  {},
                                  {},
                                  {},
                                  alignof(double))
    {
    }

    DataType() : DataType("tFloat64")
    {
    }
};

class PredefinedDataTypes {
private:
    PredefinedDataTypes();
    ~PredefinedDataTypes();
 
public:
    static const PredefinedDataTypes& getInstance();
    std::shared_ptr<dd::datamodel::DataType> getPredefinedType(const std::string& name) const;
    dd::OptionalSize getDefaultAlignment(const std::string& name) const;
    std::vector<std::string> getAliasTypes(const std::string& name) const;
    std::vector<std::shared_ptr<dd::datamodel::DataType>> getPredefinedTypes() const;
 
private:
    struct PredefInfo {
        std::shared_ptr<dd::datamodel::DataType> _type;
        std::vector<std::string> _aliases;
    };
    const std::unordered_map<std::string, PredefInfo> _defined_types;
};
 
} // namespace ddl
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
 
#endif // DD_PREDEFINED_DATATYPES_H_INCLUDED