VectorData.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "Utils.hpp"
#include "io/ReadIO.hpp"
#include "nwb/hdmf/base/Data.hpp"
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{
class VectorData : public Data
{
public:
  REGISTER_SUBCLASS(VectorData, AQNWB::SPEC::HDMF_COMMON::namespaceName)
 
  
  VectorData(const std::string& path, std::shared_ptr<IO::BaseIO> io);

  virtual ~VectorData() override {}

  static std::shared_ptr<VectorData> createReferenceVectorData(
      const std::string& path,
      std::shared_ptr<IO::BaseIO> io,
      const std::string& description,
      const std::vector<std::string>& references)
  {
    Status dataStatus = io->createReferenceDataSet(path, references);
    if (dataStatus != Status::Success) {
      return nullptr;
    }
 
    auto vectorData = std::make_shared<VectorData>(path, io);
    Status commonAttrsStatus = io->createCommonNWBAttributes(
        path, vectorData->getNamespace(), vectorData->getTypeName());
    Status attrStatus = io->createAttribute(description, path, "description");
    if ((attrStatus && commonAttrsStatus) != Status::Success) {
      return nullptr;
    }
 
    return vectorData;
  }

  Status initialize(const IO::ArrayDataSetConfig& dataConfig,
                    const std::string& description)
  {
    Status dataStatus = Data::initialize(dataConfig);
    Status attrStatus =
        m_io->createAttribute(description, m_path, "description");
    return dataStatus && attrStatus;
  }
 
  DEFINE_ATTRIBUTE_FIELD(readDescription,
                         std::string,
                         "description",
                         Description of what these vectors represent)
};

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

  virtual ~VectorDataTyped() override {}

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