VectorData.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
#include "Types.hpp"
#include "Utils.hpp"
#include "io/ReadIO.hpp"
#include "nwb/hdmf/base/Data.hpp"
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{
 
using CellValue = AQNWB::Types::CellValue;

class VectorData : public Data
{
public:
  struct DataSpec : public Data::DataSpec<VectorData>
  {
    DataSpec(const std::string& datasetName,
             const IO::ArrayDataSetConfig& dataConfig,
             const std::string& columnDescription);
 
    virtual ~DataSpec() = default;
 
    std::string description;
 
    Status initialize(Data& data) const override;
  };
 
  REGISTER_SUBCLASS(VectorData, Data, AQNWB::SPEC::HDMF_COMMON::namespaceName)
 
protected:
  VectorData(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
public:
  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);

  static std::shared_ptr<DataSpec> createDataSpec(
      const std::string& name,
      const IO::ArrayDataSetConfig& dataConfig,
      const std::string& description);

  Status initialize(const IO::BaseArrayDataSetConfig& dataConfig,
                    const std::string& description);

  virtual Status appendData(const AQNWB::Types::CellValue& cellValue,
                            size_t& elementsAppended);

  virtual Status appendBuffer(
      const IO::BaseDataType::BaseDataVectorVariant& buffer);
 
  DEFINE_ATTRIBUTE_FIELD(readDescription,
                         std::string,
                         "description",
                         Description of what these vectors represent)
};

template<typename DTYPE = std::any>
class VectorDataTyped : public VectorData
{
  friend class AQNWB::NWB::RegisteredType; /* base can call constructor */
 
protected:
  VectorDataTyped(const std::string& path, std::shared_ptr<IO::BaseIO> io)
      : VectorData(path, io)
  {
  }
 
  using VectorData::VectorData; /* inherit from immediate base */
 
public:
  static std::shared_ptr<VectorDataTyped> create(
      const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io);

  virtual ~VectorDataTyped() override {}

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