BaseIO.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
 
#include <boost/multi_array.hpp>  // TODO move this and function def to the cpp file
 
#include "Types.hpp"
 
#define DEFAULT_STR_SIZE 256
#define DEFAULT_ARRAY_SIZE 1
 
using StorageObjectType = AQNWB::Types::StorageObjectType;
using Status = AQNWB::Types::Status;
using SizeArray = AQNWB::Types::SizeArray;
using SizeType = AQNWB::Types::SizeType;

namespace AQNWB::IO
{
 
class BaseRecordingData;

class BaseDataType
{
public:
  enum Type
  {
    T_U8,  
    T_U16,  
    T_U32,  
    T_U64,  
    T_I8,  
    T_I16,  
    T_I32,  
    T_I64,  
    T_F32,  
    T_F64,  
    T_STR,  
    V_STR,  
  };

  BaseDataType(Type t = T_I32, SizeType s = 1);
 
  Type type;  
  SizeType typeSize;  
 
  // handy accessors
  static const BaseDataType U8;  
  static const BaseDataType U16;  
  static const BaseDataType U32;  
  static const BaseDataType U64;  
  static const BaseDataType I8;  
  static const BaseDataType I16;  
  static const BaseDataType I32;  
  static const BaseDataType I64;  
  static const BaseDataType F32;  
  static const BaseDataType F64;  
  static const BaseDataType DSTR;  
  static BaseDataType STR(
      SizeType size);  
 
  // Define the equality operator
  bool operator==(const BaseDataType& other) const
  {
    return type == other.type && typeSize == other.typeSize;
  }
 
  // Variant data type for representing any 1D vector with BaseDataType values
  using BaseDataVectorVariant = 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>>;

  static BaseDataType fromTypeId(const std::type_index& typeIndex)
  {
    if (typeIndex == typeid(uint8_t)) {
      return BaseDataType(U8);
    } else if (typeIndex == typeid(uint16_t)) {
      return BaseDataType(U16);
    } else if (typeIndex == typeid(uint32_t)) {
      return BaseDataType(U32);
    } else if (typeIndex == typeid(uint64_t)) {
      return BaseDataType(U64);
    } else if (typeIndex == typeid(int8_t)) {
      return BaseDataType(I8);
    } else if (typeIndex == typeid(int16_t)) {
      return BaseDataType(I16);
    } else if (typeIndex == typeid(int32_t)) {
      return BaseDataType(I32);
    } else if (typeIndex == typeid(int64_t)) {
      return BaseDataType(I64);
    } else if (typeIndex == typeid(float)) {
      return BaseDataType(F32);
    } else if (typeIndex == typeid(double)) {
      return BaseDataType(F64);
    } else {
      throw std::runtime_error("Unsupported data type");
    }
  }
};
 
class DataBlockGeneric;

enum class SearchMode
{
  STOP_ON_TYPE = 1,
  CONTINUE_ON_TYPE = 2,
};

enum class FileMode
{
  Overwrite,

  ReadWrite,

  ReadOnly
};

class ArrayDataSetConfig
{
public:
  ArrayDataSetConfig(const BaseDataType& type,
                     const SizeArray& shape,
                     const SizeArray& chunking);

  virtual ~ArrayDataSetConfig() = default;

  inline BaseDataType getType() const { return m_type; }

  inline SizeArray getShape() const { return m_shape; }

  inline SizeArray getChunking() const { return m_chunking; }
 
protected:
  // The data type of the dataset
  BaseDataType m_type;
  // The shape of the dataset
  SizeArray m_shape;
  // The chunking of the dataset
  SizeArray m_chunking;
};

class BaseIO
{
public:
  BaseIO(const std::string& filename);

  BaseIO(const BaseIO&) = delete;

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

  virtual ~BaseIO();

  virtual std::string getFileName() const { return m_filename; }

  virtual StorageObjectType getStorageObjectType(std::string path) const = 0;

  virtual Status open() = 0;

  virtual Status open(FileMode mode) = 0;

  virtual Status close() = 0;

  virtual Status flush() = 0;

  virtual bool objectExists(const std::string& path) const = 0;

  virtual bool attributeExists(const std::string& path) const = 0;

  virtual std::vector<std::pair<std::string, StorageObjectType>>
  getStorageObjects(const std::string& path,
                    const StorageObjectType& objectType =
                        StorageObjectType::Undefined) const = 0;

  virtual std::unordered_map<std::string, std::string> findTypes(
      const std::string& starting_path,
      const std::unordered_set<std::string>& types,
      SearchMode search_mode,
      bool exclude_starting_path = false) const;

  virtual DataBlockGeneric readDataset(
      const std::string& dataPath,
      const std::vector<SizeType>& start = {},
      const std::vector<SizeType>& count = {},
      const std::vector<SizeType>& stride = {},
      const std::vector<SizeType>& block = {}) = 0;

  virtual DataBlockGeneric readAttribute(const std::string& dataPath) const = 0;

  virtual std::string readReferenceAttribute(
      const std::string& dataPath) const = 0;

  virtual Status createAttribute(const BaseDataType& type,
                                 const void* data,
                                 const std::string& path,
                                 const std::string& name,
                                 const SizeType& size = 1) = 0;

  virtual Status createAttribute(const std::string& data,
                                 const std::string& path,
                                 const std::string& name,
                                 const bool overwrite = false) = 0;

  virtual Status createAttribute(const std::vector<std::string>& data,
                                 const std::string& path,
                                 const std::string& name,
                                 const bool overwrite = false) = 0;

  virtual Status createReferenceAttribute(const std::string& referencePath,
                                          const std::string& path,
                                          const std::string& name) = 0;

  virtual Status createGroup(const std::string& path) = 0;

  virtual Status createLink(const std::string& path,
                            const std::string& reference) = 0;

  virtual Status createStringDataSet(const std::string& path,
                                     const std::string& value) = 0;

  virtual Status createStringDataSet(
      const std::string& path, const std::vector<std::string>& values) = 0;

  virtual Status createReferenceDataSet(
      const std::string& path, const std::vector<std::string>& references) = 0;

  virtual Status startRecording() = 0;

  virtual Status stopRecording() = 0;

  virtual bool canModifyObjects() { return true; }

  virtual std::unique_ptr<BaseRecordingData> createArrayDataSet(
      const ArrayDataSetConfig& config, const std::string& path) = 0;

  virtual std::unique_ptr<BaseRecordingData> getDataSet(
      const std::string& path) = 0;

  virtual std::vector<SizeType> getStorageObjectShape(
      const std::string path) = 0;

  Status createCommonNWBAttributes(const std::string& path,
                                   const std::string& objectNamespace,
                                   const std::string& neurodataType = "");

  inline bool isOpen() const { return m_opened; }

  inline bool isReadyToOpen() const { return m_readyToOpen; }
 
protected:
  const std::string m_filename;

  virtual Status createGroupIfDoesNotExist(const std::string& path) = 0;

  bool m_readyToOpen;

  bool m_opened;
};

class BaseRecordingData
{
public:
  BaseRecordingData();

  BaseRecordingData(const BaseRecordingData&) = delete;

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

  virtual ~BaseRecordingData();

  Status writeDataBlock(const std::vector<SizeType>& dataShape,
                        const BaseDataType& type,
                        const void* data);

  virtual Status writeDataBlock(const std::vector<SizeType>& dataShape,
                                const std::vector<SizeType>& positionOffset,
                                const BaseDataType& type,
                                const void* data) = 0;

  virtual Status writeDataBlock(const std::vector<SizeType>& dataShape,
                                const std::vector<SizeType>& positionOffset,
                                const BaseDataType& type,
                                const std::vector<std::string>& data) = 0;

  inline SizeType getNumDimensions() const { return m_shape.size(); }

  inline const std::vector<SizeType>& getShape() const { return m_shape; }

  inline const std::vector<SizeType>& getPosition() const { return m_position; }
 
protected:
  std::vector<SizeType> m_shape;

  std::vector<SizeType> m_position;
};
 
}  // namespace AQNWB::IO