BaseIO.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#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);  
};
 
class DataBlockGeneric;

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

enum class FileMode
{
  Overwrite,

  ReadWrite,

  ReadOnly
};

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) 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 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) = 0;

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

  virtual Status createAttribute(const std::vector<const char*>& data,
                                 const std::string& path,
                                 const std::string& name,
                                 const SizeType& maxSize) = 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 BaseDataType& type,
      const SizeArray& size,
      const SizeArray& chunking,
      const std::string& path) = 0;

  virtual std::unique_ptr<BaseRecordingData> getDataSet(
      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 nDimensions; }

  inline const std::vector<SizeType>& getSize() const { return size; }

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

  std::vector<SizeType> position;

  SizeType nDimensions;
};
 
}  // namespace AQNWB::IO