BaseIO.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <any>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
 
#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 RecordingObjects;
class BaseIO;
}  // namespace AQNWB::IO
 
namespace AQNWB::IO
{

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,  
  };

  // cppcheck-suppress noExplicitConstructor
  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 a single scalar with BaseDataType values
  using BaseDataVariant = AQNWB::Types::ScalarDataVariant;
 
  // Variant data type for representing any 1D vector with BaseDataType values
  using BaseDataVectorVariant = AQNWB::Types::VectorDataVariant;

  static BaseDataVectorVariant createEmptyVectorVariant(
      const BaseDataType& dataType)
  {
    switch (dataType.type) {
      case T_U8:
        return std::vector<uint8_t> {};
      case T_U16:
        return std::vector<uint16_t> {};
      case T_U32:
        return std::vector<uint32_t> {};
      case T_U64:
        return std::vector<uint64_t> {};
      case T_I8:
        return std::vector<int8_t> {};
      case T_I16:
        return std::vector<int16_t> {};
      case T_I32:
        return std::vector<int32_t> {};
      case T_I64:
        return std::vector<int64_t> {};
      case T_F32:
        return std::vector<float> {};
      case T_F64:
        return std::vector<double> {};
      case T_STR:
      case V_STR:
        return std::vector<std::string> {};
    }
    return std::monostate {};
  }

  bool isCompatibleCellValue(const Types::CellValue& value) const
  {
    const BaseDataVectorVariant expectedValues =
        createEmptyVectorVariant(*this);
    if (std::holds_alternative<std::monostate>(expectedValues)) {
      return false;
    }
 
    const SizeType expectedTypeIndex = expectedValues.index();
    return std::visit([expectedTypeIndex](const auto& values)
                      { return values.index() == expectedTypeIndex; },
                      value.value);
  }

  bool isCompatibleVector(const BaseDataVectorVariant& buffer) const
  {
    const BaseDataVectorVariant expectedBuffer =
        createEmptyVectorVariant(*this);
    return !std::holds_alternative<std::monostate>(expectedBuffer)
        && buffer.index() == expectedBuffer.index();
  }

  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 BaseArrayDataSetConfig
{
public:
  virtual ~BaseArrayDataSetConfig() = default;

  virtual bool isLink() const { return false; }

  virtual Status getProperties(const BaseIO* io,
                               SizeArray& shape,
                               SizeArray& chunking,
                               BaseDataType& dataType) const = 0;
};

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

  virtual ~ArrayDataSetConfig() override = default;

  inline BaseDataType getType() const { return m_type; }

  inline const SizeArray& getShape() const { return m_shape; }

  inline const SizeArray& getChunking() const { return m_chunking; }

  Status getProperties(const BaseIO* io,
                       SizeArray& shape,
                       SizeArray& chunking,
                       BaseDataType& dataType) const override
  {
    (void)io;  // Unused parameter (not needed for ArrayDataSetConfig)
    shape = m_shape;
    chunking = m_chunking;
    dataType = m_type;
    return Status::Success;
  }
 
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 LinkArrayDataSetConfig : public BaseArrayDataSetConfig
{
public:
  explicit LinkArrayDataSetConfig(const std::string& targetPath);

  virtual ~LinkArrayDataSetConfig() override = default;

  inline const std::string& getTargetPath() const { return m_targetPath; }

  inline bool isLink() const override { return true; }

  bool targetExists(const BaseIO& io) const;

  SizeArray getTargetShape(const BaseIO& io) const;

  SizeArray getTargetChunking(const BaseIO& io) const;

  BaseDataType getTargetDataType(const BaseIO& io) const;

  Status validateTarget(
      const BaseIO& io,
      const std::vector<BaseDataType>& allowedTypes = {},
      const std::vector<SizeType>& allowedDimensionalities = {},
      const std::vector<std::string>& requiredAttributes = {}) const;

  Status getProperties(const BaseIO* io,
                       SizeArray& shape,
                       SizeArray& chunking,
                       BaseDataType& dataType) const override
  {
    if (!io) {
      return Status::Failure;
    }
    try {
      shape = getTargetShape(*io);
      chunking = getTargetChunking(*io);
      dataType = getTargetDataType(*io);
    } catch (const std::runtime_error&) {
      return Status::Failure;
    }
    return Status::Success;
  }
 
private:
  // The path to the target dataset to link to
  std::string m_targetPath;
};

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 std::string findObject(const std::string& name,
                                 const std::string& starting_path = "/") const;

  std::string getFullTypeName(const std::string& path) const;

  virtual DataBlockGeneric readDataset(const std::string& dataPath,
                                       const SizeArray& start = {},
                                       const SizeArray& count = {},
                                       const SizeArray& stride = {},
                                       const SizeArray& 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();

  virtual Status stopRecording();

  virtual bool canModifyObjects() { return true; }

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

  std::shared_ptr<BaseRecordingData> getDataSet(const std::string& path,
                                                bool reset = false);

  void clearRecordingDataCache();

  const std::unordered_map<std::string, std::shared_ptr<BaseRecordingData>>&
  getRecordingDataCache() const;

  virtual SizeArray getStorageObjectShape(const std::string& path) const = 0;

  virtual SizeArray getStorageObjectChunking(const std::string& path) const = 0;

  virtual BaseDataType getStorageObjectDataType(
      const std::string& path) const = 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; }

  inline std::shared_ptr<RecordingObjects> getRecordingObjects() const
  {
    return m_recording_objects;
  }
 
protected:
  const std::string m_filename;

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

  bool m_readyToOpen;

  bool m_opened;

  virtual std::shared_ptr<BaseRecordingData> getDataSetImpl(
      const std::string& path) = 0;

  std::shared_ptr<RecordingObjects> m_recording_objects;

  std::unordered_map<std::string, std::shared_ptr<BaseRecordingData>>
      m_recordingDataCache;
};

class BaseRecordingData
{
public:
  BaseRecordingData();

  BaseRecordingData(const BaseRecordingData&) = delete;

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

  virtual ~BaseRecordingData();

  Status writeDataBlock(const SizeArray& dataShape,
                        const BaseDataType& type,
                        const void* data);

  virtual Status writeDataBlock(const SizeArray& dataShape,
                                const SizeArray& positionOffset,
                                const BaseDataType& type,
                                const void* data) = 0;

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

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

  inline const SizeArray& getShape() const { return m_shape; }

  inline const SizeArray& getPosition() const { return m_position; }
 
protected:
  SizeArray m_shape;

  SizeArray m_position;
};
 
}  // namespace AQNWB::IO