VectorIndex.hpp

Go to the documentation of this file.

#pragma once
 
// Common STL includes
#include <memory>
#include <optional>
#include <string>
#include <vector>
// Base AqNWB includes for IO and RegisteredType
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "nwb/RegisteredType.hpp"
// Include for parent type
#include "nwb/hdmf/table/VectorData.hpp"
// Includes for types that are referenced and used
#include "nwb/hdmf/base/Data.hpp"
#include "nwb/hdmf/table/VectorData.hpp"
// Include for the namespace schema header
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{

class VectorIndex : public AQNWB::NWB::VectorData
{
protected:
  VectorIndex(const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io);
 
public:
  struct DataSpec : public Data::DataSpec<VectorIndex>
  {
    DataSpec(const std::string& datasetName,
             const IO::ArrayDataSetConfig& dataConfig,
             const std::string& columnDescription,
             const std::string& columnTargetPath)
        : Data::DataSpec<VectorIndex>(datasetName, dataConfig)
        , description(columnDescription)
        , targetPath(columnTargetPath)
    {
    }
 
    virtual ~DataSpec() = default;
 
    std::string description;
    std::string targetPath;
 
    Status initialize(Data& data) const override
    {
      auto* vectorIndex = dynamic_cast<VectorIndex*>(&data);
      if (!vectorIndex) {
        std::cerr << "VectorIndex::DataSpec::initialize received incompatible "
                     "VectorIndex object"
                  << std::endl;
        return Status::Failure;
      }
      return vectorIndex->initialize(
          static_cast<const IO::ArrayDataSetConfig&>(*this),
          description,
          targetPath);
    }
  };

  virtual ~VectorIndex() override {}

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

  Status appendData(const AQNWB::Types::CellValue& targetValues,
                    size_t& elementsAppended) override;

  std::shared_ptr<VectorData> getTargetColumn();

  std::vector<AQNWB::Types::CellValue> readIndexedCellValues(
      SizeType start = 0, SizeType count = AQNWB::Types::SizeTypeNotSet);
 
  // Define read methods
  DEFINE_REFERENCED_REGISTERED_FIELD(
      readTarget,
      VectorData,
      "target",
      "Reference to the target dataset that this index applies to.")
 
  DEFINE_ATTRIBUTE_FIELD(readDescription,
                         std::string,
                         "description",
                         "Description of what these vectors represent.")
 
  DEFINE_DATASET_FIELD(
      readData,
      recordData,
      uint32_t,
      "",
      "Used with VectorData to encode a ragged array. An array of indices into "
      "the first dimension of the target VectorData - and forming a map "
      "between the rows of a DynamicTable and the indices of the VectorData. "
      "The name of the VectorIndex is expected to be the name of the target "
      "VectorData object followed by _index.")
 
  REGISTER_SUBCLASS(VectorIndex,
                    VectorData,
                    AQNWB::SPEC::HDMF_COMMON::namespaceName)
 
private:
  uint64_t m_currentIndex = 0;

  bool m_currentIndexInitialized = false;

  std::shared_ptr<VectorData> m_targetColumn;

  IO::BaseDataType m_dataType;

  bool m_dataTypeInitialized = false;

  Status initializeAppendState();

  uint64_t extractIndexValue(const AQNWB::Types::CellValue& cell) const;

  AQNWB::Types::CellValue combineCellsToVector(
      const std::vector<AQNWB::Types::CellValue>& cells,
      size_t offset,
      size_t count) const;
};
 
}  // namespace AQNWB::NWB