Types.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace AQNWB
{
 
// Forward declaration of Channel
class Channel;

namespace Types
{
enum Status
{
  Success = 1,
  Failure = -1
};

inline Status operator&&(Status lhs, Status rhs)
{
  return (lhs == Success && rhs == Success) ? Success : Failure;
}

inline Status operator||(Status lhs, Status rhs)
{
  return (lhs == Success || rhs == Success) ? Success : Failure;
}

enum StorageObjectType
{
  Group = 0,
  Dataset = 1,
  Attribute = 2,
  Undefined = -1
};

inline std::string storageObjectTypeToString(StorageObjectType type)
{
  switch (type) {
    case Group:
      return "Group";
    case Dataset:
      return "Dataset";
    case Attribute:
      return "Attribute";
    case Undefined:
      return "Undefined";
    default:
      return "Unknown";
  }
}

template<StorageObjectType T>
struct IsDataStorageObjectType
    : std::integral_constant<bool, (T == Dataset || T == Attribute)>
{
};

using SizeType = size_t;

inline constexpr SizeType SizeTypeNotSet =
    (std::numeric_limits<SizeType>::max)();

using SizeArray = std::vector<SizeType>;

using ChannelVector = std::vector<Channel>;

using ScalarDataVariant = std::variant<std::monostate,
                                       uint8_t,
                                       uint16_t,
                                       uint32_t,
                                       uint64_t,
                                       int8_t,
                                       int16_t,
                                       int32_t,
                                       int64_t,
                                       float,
                                       double,
                                       std::string>;

using VectorDataVariant = std::variant<std::monostate,
                                       std::vector<uint8_t>,
                                       std::vector<uint16_t>,
                                       std::vector<uint32_t>,
                                       std::vector<uint64_t>,
                                       std::vector<int8_t>,
                                       std::vector<int16_t>,
                                       std::vector<int32_t>,
                                       std::vector<int64_t>,
                                       std::vector<float>,
                                       std::vector<double>,
                                       std::vector<std::string>>;

struct NamespaceInfo
{
  std::string name;  
  std::string version;  

  std::vector<std::pair<std::string_view, std::string_view>>
      specVariables;  
};

struct CellValue
{
  std::variant<ScalarDataVariant, VectorDataVariant> value;
 
  CellValue() = default;

  template<typename T,
           typename =
               std::enable_if_t<std::is_constructible_v<ScalarDataVariant, T&&>
                                && !std::is_same_v<std::decay_t<T>, CellValue>>>
  // cppcheck-suppress noExplicitConstructor
  CellValue(T&& val)
      : value(ScalarDataVariant(std::forward<T>(val)))
  {
  }

  template<typename T,
           typename = std::enable_if_t<
               std::is_constructible_v<VectorDataVariant, T&&>>,
           typename = void>
  // cppcheck-suppress noExplicitConstructor
  CellValue(T&& val)
      : value(VectorDataVariant(std::forward<T>(val)))
  {
  }

  // cppcheck-suppress noExplicitConstructor
  CellValue(const char* val)
      : value(ScalarDataVariant(std::string(val)))
  {
  }

  template<typename T>
  bool holds_alternative() const
  {
    bool result = false;
    if constexpr (std::is_constructible_v<ScalarDataVariant, T>) {
      if (std::holds_alternative<ScalarDataVariant>(value)) {
        result = result
            || std::holds_alternative<T>(std::get<ScalarDataVariant>(value));
      }
    }
    if constexpr (std::is_constructible_v<VectorDataVariant, T>) {
      if (std::holds_alternative<VectorDataVariant>(value)) {
        result = result
            || std::holds_alternative<T>(std::get<VectorDataVariant>(value));
      }
    }
    return result;
  }

  template<typename T>
  const T& get() const
  {
    if constexpr (std::is_constructible_v<VectorDataVariant, T>) {
      return std::get<T>(std::get<VectorDataVariant>(value));
    } else {
      return std::get<T>(std::get<ScalarDataVariant>(value));
    }
  }

  template<typename T,
           typename = std::enable_if_t<
               std::is_constructible_v<ScalarDataVariant, T>
               || std::is_constructible_v<VectorDataVariant, T>>>
  operator T() const
  {
    return get<T>();
  }

  std::string toString() const
  {
    return std::visit(
        [](auto&& arg) -> std::string
        {
          using T = std::decay_t<decltype(arg)>;
          if constexpr (std::is_same_v<T, ScalarDataVariant>) {
            return std::visit(
                [](auto&& scalarArg) -> std::string
                {
                  using ScalarT = std::decay_t<decltype(scalarArg)>;
                  if constexpr (std::is_same_v<ScalarT, std::monostate>) {
                    return "null";
                  } else if constexpr (std::is_same_v<ScalarT, std::string>) {
                    return scalarArg;
                  } else {
                    return std::to_string(scalarArg);
                  }
                },
                arg);
          } else if constexpr (std::is_same_v<T, VectorDataVariant>) {
            return std::visit(
                [](auto&& vectorArg) -> std::string
                {
                  using VectorT = std::decay_t<decltype(vectorArg)>;
                  if constexpr (std::is_same_v<VectorT, std::monostate>) {
                    return "[]";
                  } else {
                    std::string res = "[";
                    for (size_t i = 0; i < vectorArg.size(); ++i) {
                      if constexpr (std::is_same_v<VectorT,
                                                   std::vector<std::string>>) {
                        res += vectorArg[i];
                      } else {
                        res += std::to_string(vectorArg[i]);
                      }
                      if (i < vectorArg.size() - 1) {
                        res += ", ";
                      }
                    }
                    res += "]";
                    return res;
                  }
                },
                arg);
          } else {
            return "Unknown";
          }
        },
        value);
  }
};

using RowData = std::unordered_map<std::string, CellValue>;
 
}  // namespace Types
}  // namespace AQNWB