Data.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#include "io/BaseIO.hpp"
#include "nwb/RegisteredType.hpp"
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{
class Data : public RegisteredType
{
public:
  // Register the Data class with the type registry
  REGISTER_SUBCLASS(Data, "hdmf-common")
 
  
  Data(const std::string& path, std::shared_ptr<IO::BaseIO> io);

  virtual ~Data() override {}

  Status initialize(const IO::ArrayDataSetConfig& dataConfig)
  {
    auto dataset = m_io->createArrayDataSet(dataConfig, this->m_path);
    if (dataset == nullptr) {
      return Status::Failure;
    }
    // setup common attributes
    Status commonAttrsStatus = m_io->createCommonNWBAttributes(
        m_path, this->getNamespace(), this->getTypeName());
    return commonAttrsStatus;
  }

  inline bool isInitialized() { return this->readData()->exists(); }
 
  // Define the data fields to expose for lazy read access
  DEFINE_DATASET_FIELD(readData, recordData, std::any, "", The main data)
 
  DEFINE_ATTRIBUTE_FIELD(readNeurodataType,
                         std::string,
                         "neurodata_type",
                         The name of the type)
 
  DEFINE_ATTRIBUTE_FIELD(readNamespace,
                         std::string,
                         "namespace",
                         The name of the namespace)
};

template<typename DTYPE = std::any>
class DataTyped : public Data
{
public:
  DataTyped(const std::string& path, std::shared_ptr<IO::BaseIO> io)
      : Data(path, io)
  {
  }

  virtual ~DataTyped() override {}

  static std::shared_ptr<DataTyped<DTYPE>> fromData(const Data& data)
  {
    return std::make_shared<DataTyped<DTYPE>>(data.getPath(), data.getIO());
  }
 
  // Define the data fields to expose for lazy read access
  DEFINE_DATASET_FIELD(readData, recordData, DTYPE, "", The main data)
 
  using RegisteredType::m_io;
  using RegisteredType::m_path;
};
}  // namespace AQNWB::NWB