ReadIO.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <typeindex>
#include <vector>
 
#include <boost/multi_array.hpp>  // TODO move this and function def to the cpp file
 
#include "BaseIO.hpp"
#include "Types.hpp"
 
using StorageObjectType = AQNWB::Types::StorageObjectType;
using SizeType = AQNWB::Types::SizeType;

namespace AQNWB::IO
{

class DataBlockGeneric
{
public:
  std::any data;
  std::vector<SizeType> shape;

  std::type_index typeIndex = typeid(void);

  IO::BaseDataType baseDataType;

  DataBlockGeneric() = default;

  DataBlockGeneric(const std::any& inData,
                   const std::vector<SizeType>& inShape,
                   const std::type_index& inTypeIndex,
                   const IO::BaseDataType baseDataType)
      : data(inData)
      , shape(inShape)
      , typeIndex(inTypeIndex)
      , baseDataType(baseDataType)
  {
  }

  BaseDataType::BaseDataVectorVariant as_variant() const
  {
    try {
      switch (baseDataType.type) {
        case BaseDataType::T_U8:
          return std::any_cast<std::vector<uint8_t>>(data);
        case BaseDataType::T_U16:
          return std::any_cast<std::vector<uint16_t>>(data);
        case BaseDataType::T_U32:
          return std::any_cast<std::vector<uint32_t>>(data);
        case BaseDataType::T_U64:
          return std::any_cast<std::vector<uint64_t>>(data);
        case BaseDataType::T_I8:
          return std::any_cast<std::vector<int8_t>>(data);
        case BaseDataType::T_I16:
          return std::any_cast<std::vector<int16_t>>(data);
        case BaseDataType::T_I32:
          return std::any_cast<std::vector<int32_t>>(data);
        case BaseDataType::T_I64:
          return std::any_cast<std::vector<int64_t>>(data);
        case BaseDataType::T_F32:
          return std::any_cast<std::vector<float>>(data);
        case BaseDataType::T_F64:
          return std::any_cast<std::vector<double>>(data);
        case BaseDataType::T_STR:
          return std::any_cast<std::vector<std::string>>(data);
        default:
          return std::monostate {};
      }
    } catch (const std::bad_any_cast&) {
      // If the actual type stored in `data` does not match the expected type
      // based on `baseDataType`, a `std::bad_any_cast` exception will be
      // thrown. In this case, we catch the exception and return
      // `std::monostate` to indicate that the conversion failed.
      return std::monostate {};
    }
  }
};

template<typename DTYPE>
class DataBlock
{
public:
  std::vector<DTYPE> data;
  std::vector<SizeType> shape;
  const std::type_index typeIndex = typeid(DTYPE);

  DataBlock(const std::vector<DTYPE>& inData,
            const std::vector<SizeType>& inShape)
      : data(inData)
      , shape(inShape)
  {
  }

  template<std::size_t NDIMS>
  inline boost::const_multi_array_ref<DTYPE, NDIMS> as_multi_array() const
  {
    if (shape.size() != NDIMS) {
      throw std::invalid_argument(
          "Shape size does not match the number of dimensions.");
    }
 
    // Calculate the total number of elements expected
    SizeType expected_size = 1;
    for (SizeType dim : shape) {
      expected_size *= dim;
    }
 
    if (data.size() != expected_size) {
      throw std::invalid_argument("Data size does not match the shape.");
    }
 
    // Convert the shape vector to a boost::array
    boost::array<std::size_t, NDIMS> boost_shape;
    std::copy(shape.begin(), shape.end(), boost_shape.begin());
 
    // Construct and return the boost::const_multi_array_ref
    return boost::const_multi_array_ref<DTYPE, NDIMS>(data.data(), boost_shape);
  }

  inline static DataBlock<DTYPE> fromGeneric(
      const DataBlockGeneric& genericData)
  {
    auto result = DataBlock<DTYPE>(
        std::any_cast<std::vector<DTYPE>>(genericData.data), genericData.shape);
    return result;
  }

  inline BaseDataType getBaseDataType() const
  {
    return BaseDataType::fromTypeId(typeIndex);
  }
};  // class DataBlock

template<StorageObjectType T>
struct isAllowedStorageObjectType : std::false_type
{
};

template<>
struct isAllowedStorageObjectType<StorageObjectType::Dataset> : std::true_type
{
};

template<>
struct isAllowedStorageObjectType<StorageObjectType::Attribute> : std::true_type
{
};

template<StorageObjectType OTYPE, typename VTYPE = std::any>
class ReadDataWrapper
{
  // Embedded traits for compile time checking of allowed OTYPE for the class
  // and methods
private:
  template<StorageObjectType U>
  struct isDataset
      : std::integral_constant<bool, (U == StorageObjectType::Dataset)>
  {
  };

  static_assert(isAllowedStorageObjectType<OTYPE>::value,
                "StorageObjectType not allowed for ReadDataWrapper");
 
  // Actual definition of the class
public:
  ReadDataWrapper(const std::shared_ptr<IO::BaseIO> io, const std::string& path)
      : m_io(io)
      , m_path(path)
  {
  }

  inline StorageObjectType getStorageObjectType() const { return OTYPE; }

  template<typename T>
  static constexpr bool isType()
  {
    return std::is_same_v<VTYPE, T>;
  }

  ReadDataWrapper(const ReadDataWrapper&) = delete;

  ReadDataWrapper& operator=(const ReadDataWrapper&) = delete;

  virtual ~ReadDataWrapper() {}

  inline std::string getPath() const { return m_path; }

  inline std::shared_ptr<IO::BaseIO> getIO() const { return m_io; }

  inline std::vector<SizeType> getShape() const
  {
    return m_io->getStorageObjectShape(m_path);
  }

  inline SizeType getNumDimensions() const { return this->getShape().size(); }

  inline bool exists() const
  {
    switch (OTYPE) {
      case StorageObjectType::Dataset: {
        return m_io->objectExists(m_path);
      }
      case StorageObjectType::Attribute: {
        return m_io->attributeExists(m_path);
      }
      default: {
        throw std::runtime_error("Unsupported StorageObjectType");
      }
    }
  }

  inline DataBlockGeneric valuesGeneric() const
  {
    switch (OTYPE) {
      case StorageObjectType::Dataset: {
        return m_io->readDataset(m_path);
      }
      case StorageObjectType::Attribute: {
        return m_io->readAttribute(m_path);
      }
      default: {
        throw std::runtime_error("Unsupported StorageObjectType");
      }
    }
  }

  template<StorageObjectType U = OTYPE,
           typename std::enable_if<isDataset<U>::value, int>::type = 0>
  inline DataBlockGeneric valuesGeneric(
      const std::vector<SizeType>& start,
      const std::vector<SizeType>& count = {},
      const std::vector<SizeType>& stride = {},
      const std::vector<SizeType>& block = {}) const
  {
    // The function is only enabled for datasets so we don't need to check
    // for attributes here.
    return m_io->readDataset(m_path, start, count, stride, block);
  }

  template<typename T = VTYPE>
  inline DataBlock<VTYPE> values() const
  {
    return DataBlock<T>::fromGeneric(this->valuesGeneric());
  }

  template<typename T = VTYPE,
           StorageObjectType U = OTYPE,
           typename std::enable_if<isDataset<U>::value, int>::type = 0>
  inline DataBlock<VTYPE> values(const std::vector<SizeType>& start,
                                 const std::vector<SizeType>& count = {},
                                 const std::vector<SizeType>& stride = {},
                                 const std::vector<SizeType>& block = {}) const
  {
    // The function is only enabled for datasets so we don't need to check
    // for attributes here.
    return DataBlock<VTYPE>::fromGeneric(
        this->valuesGeneric(start, count, stride, block));
  }
 
protected:
  const std::shared_ptr<IO::BaseIO> m_io;
  std::string m_path;
};  // ReadDataWrapper
 
}  // namespace AQNWB::IO