dd_common_types.h

Go to the documentation of this file.

 
#ifndef DD_TYPES_H_INCLUDED
#define DD_TYPES_H_INCLUDED
 
#include <a_util/preprocessor/deprecated.h>
#include <ddl/utilities/dd_access_optional.h>
 
#include <string>
#include <cstdint>
 
#define DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(alternative)                                       \
    DEV_ESSENTIAL_DEPRECATED("Please use ddl::dd::" #alternative                                   \
                             " directly, due to static intialization problem.")
 
namespace ddl {
 
namespace dd {
 
using OptionalSize = utility::Optional<size_t>;
 
enum TypeOfType : uint8_t {
    invalid_type,
    data_type,
    enum_type,
    struct_type,
    stream_meta_type
};
 
enum TypeOfUnit : uint8_t {
    invalid_unit,
    unit,
    base_unit
};
 
enum Alignment : size_t {
    e0 = 1, 
    e1 = 1, 
    e2 = 2,
    e4 = 4,
    e8 = 8,
    e16 = 16,
    e32 = 32,
    e64 = 64,
    e_invalid = 255
};
 
class AlignmentConversion {
public:
    static std::string toString(Alignment alignment);
    static Alignment fromString(const std::string& alignment,
                                const Alignment& default_val = Alignment::e_invalid);
};
 
class AlignmentValidation {
public:
    static bool isValid(size_t alignment);
};
 
enum ByteOrder {
    platform_not_supported = 0x00,
    plattform_little_endian_8 = 0x01,
    platform_big_endian_8 = 0x02,
    e_noe = platform_not_supported,
    e_le = plattform_little_endian_8,
    e_be = platform_big_endian_8
};
 
class ByteOrderConversion {
public:
    static std::string toString(ByteOrder byte_order);
    static ByteOrder fromString(const std::string& byte_order,
                                const ByteOrder& default_val = ByteOrder::platform_not_supported);
};
 
class ByteOrderDefault {
public:
    static ByteOrder getPlatformDefault();
};
 
class Version {
public:
    Version();
    Version(const std::string& version);
 
    Version(uint32_t major, uint32_t minor);
 
    uint32_t getMajor() const;
    uint32_t getMinor() const;
 
    std::string toString() const;
 
    bool isValidVersion() const;
 
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version::getLatestVersion())
    static const Version& getDefaultVersion()
    {
        return getLatestVersion();
    }
 
    static const Version& getLatestVersion();
 
    /* ignore patch version for all comparisons */
    bool operator==(const Version& other) const;
    bool operator!=(const Version& other) const;
    bool operator>(const Version& other) const;
    bool operator<(const Version& other) const;
    bool operator<=(const Version& other) const;
    bool operator>=(const Version& other) const;
 
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(0, 0))
    static const Version ddl_version_invalid;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(0, 0))
    static const Version ddl_version_notset;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(1, 0))
    static const Version ddl_version_10;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(1, 1))
    static const Version ddl_version_11;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(1, 2))
    static const Version ddl_version_12;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(2, 0))
    static const Version ddl_version_20;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(3, 0))
    static const Version ddl_version_30;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(4, 0))
    static const Version ddl_version_40;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version(4, 1))
    static const Version ddl_version_41;
    DEV_ESSENTIAL_DEPRECATED_STATIC_VERSION(Version::getLatestVersion())
    static const Version ddl_version_current;
 
private:
    uint32_t _major = {};
    uint32_t _minor = {};
};
 
class VersionConversion {
public:
    static std::string toString(const Version& version);
    static Version fromString(const std::string& version,
                              const Version& default_val = Version(0, 0));
};
 
class ArraySize {
public:
    ArraySize() = default;
    ArraySize(size_t array_size);
    ArraySize& operator=(size_t array_size);
    ArraySize(const std::string& array_size_element_name);
    ArraySize& operator=(const std::string& array_size_element_name);
    void setArraySizeValue(size_t array_size);
    size_t getArraySizeValue() const;
    void setArraySizeElementName(const std::string& array_size_element_name);
    const std::string& getArraySizeElementName() const;
    bool isDynamicArraySize() const;
 
    bool operator==(const ArraySize& other) const;
    bool operator!=(const ArraySize& other) const;
 
private:
    size_t _array_size = {1};
    std::string _array_size_element_name = {};
};
 
} // namespace dd
} // namespace ddl
 
#endif // DD_TYPES_H_INCLUDED