BaseIO.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
#include "Types.hpp"
 
#define DEFAULT_STR_SIZE 256
#define DEFAULT_ARRAY_SIZE 1
 
using Status = AQNWB::Types::Status;
using SizeArray = AQNWB::Types::SizeArray;
using SizeType = AQNWB::Types::SizeType;
 
namespace AQNWB
{
 
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 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 Status open() = 0;
 
  virtual Status open(bool newfile) = 0;
 
  virtual Status close() = 0;
 
  virtual Status flush() = 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;
 
  virtual bool objectExists(const std::string& path) = 0;
 
  Status createCommonNWBAttributes(const std::string& path,
                                   const std::string& objectNamespace,
                                   const std::string& neurodataType = "",
                                   const std::string& description = "");
 
  Status createDataAttributes(const std::string& path,
                              const float& conversion,
                              const float& resolution,
                              const std::string& unit);
 
  Status createTimestampsAttributes(const std::string& path);
 
  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;
 
protected:
  std::vector<SizeType> size;
 
  std::vector<SizeType> position;
 
  SizeType nDimensions;
};
 
}  // namespace AQNWB