added DType class

core/src/DType.cpp

@@ -0,0 +1,128 @@
+
+#include "aare/DType.hpp"
+#include <fmt/format.h>
+
+namespace aare {
+
+DType::DType(const std::type_info &t) {
+    if (t == typeid(int8_t))
+        m_type = TypeIndex::INT8;
+    else if (t == typeid(uint8_t))
+        m_type = TypeIndex::UINT8;
+    else if (t == typeid(int16_t))
+        m_type = TypeIndex::INT16;
+    else if (t == typeid(uint16_t))
+        m_type = TypeIndex::UINT16;
+    else if (t == typeid(int32_t))
+        m_type = TypeIndex::INT32;
+    else if (t == typeid(uint32_t))
+        m_type = TypeIndex::UINT32;
+    else if (t == typeid(int64_t))
+        m_type = TypeIndex::INT64;
+    else if (t == typeid(long))
+        m_type = TypeIndex::INT64;
+    else if (t == typeid(uint64_t))
+        m_type = TypeIndex::UINT64;
+    else if (t == typeid(float))
+        m_type = TypeIndex::FLOAT;
+    else if (t == typeid(double))
+        m_type = TypeIndex::DOUBLE;
+    else
+        throw std::runtime_error(
+            "Could not construct data type. Type not supported.");
+}
+
+DType::DType(DType::TypeIndex ti):m_type(ti){}
+
+DType::DType(std::string_view sv) {
+
+    // Check if the file is using our native endianess
+    if (auto pos = sv.find_first_of("<>"); pos != std::string_view::npos) {
+        const auto endianess = [](const char c) {
+            if (c == '<')
+                return endian::little;
+            return endian::big;
+        }(sv[pos]);
+        if (endianess != endian::native) {
+            throw std::runtime_error("Non native endianess not supported");
+        }
+    }
+
+    // we are done with the endianess so we can remove the prefix
+    sv.remove_prefix(std::min(sv.find_first_not_of("<>"), sv.size()));
+
+    if (sv == "i1")
+        m_type = TypeIndex::INT8;
+    else if (sv == "u1")
+        m_type = TypeIndex::UINT8;
+    else if (sv == "i2")
+        m_type = TypeIndex::INT16;
+    else if (sv == "u2")
+        m_type = TypeIndex::UINT16;
+    else if (sv == "i4")
+        m_type = TypeIndex::INT32;
+    else if (sv == "u4")
+        m_type = TypeIndex::UINT32;
+    else if (sv == "i8")
+        m_type = TypeIndex::INT64;
+    else if (sv == "u8")
+        m_type = TypeIndex::UINT64;
+    else if (sv == "f4")
+        m_type = TypeIndex::FLOAT;
+    else if (sv == "f8")
+        m_type = TypeIndex::DOUBLE;
+    else
+        throw std::runtime_error(
+            "Could not construct data type. Type no supported.");
+}
+
+std::string DType::str() const {
+
+    char ec;
+    if (endian::native == endian::little)
+        ec = '<';
+    else
+        ec = '>';
+
+    switch (m_type) {
+    case TypeIndex::INT8:
+        return fmt::format("{}i1", ec);
+    case TypeIndex::UINT8:
+        return fmt::format("{}u1", ec);
+    case TypeIndex::INT16:
+        return fmt::format("{}i2", ec);
+    case TypeIndex::UINT16:
+        return fmt::format("{}u2", ec);
+    case TypeIndex::INT32:
+        return fmt::format("{}i4", ec);
+    case TypeIndex::UINT32:
+        return fmt::format("{}u4", ec);
+    case TypeIndex::INT64:
+        return fmt::format("{}i8", ec);
+    case TypeIndex::UINT64:
+        return fmt::format("{}u8", ec);
+    case TypeIndex::FLOAT:
+        return "f4";
+    case TypeIndex::DOUBLE:
+        return "f8";
+    case TypeIndex::ERROR:
+        return "ERROR";
+    }
+    return {};
+}
+
+bool DType::operator==(const DType &other) const noexcept {
+    return m_type == other.m_type;
+}
+bool DType::operator!=(const DType &other) const noexcept {
+    return !(*this == other);
+}
+
+bool DType::operator==(const std::type_info &t) const {
+    return DType(t) == *this;
+}
+bool DType::operator!=(const std::type_info &t) const {
+    return DType(t) != *this;
+}
+
+} // namespace pl