DynamicTable.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <string>
 
#include "Utils.hpp"
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "io/RecordingObjects.hpp"
#include "nwb/hdmf/base/Container.hpp"
#include "nwb/hdmf/table/ElementIdentifiers.hpp"
#include "nwb/hdmf/table/VectorData.hpp"
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{
class DynamicTable : public Container
{
public:
  // Register the TimeSeries as a subclass of Container
  REGISTER_SUBCLASS(DynamicTable,
                    Container,
                    AQNWB::SPEC::HDMF_COMMON::namespaceName)
 
protected:
  DynamicTable(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
public:
  virtual ~DynamicTable();

  Status initialize(const std::string& description);

  Status finalize() override;

  Status addColumn(const std::shared_ptr<VectorData>& vectorData,
                   const std::vector<std::string>& values);

  Status addReferenceColumn(const std::string& name,
                            const std::string& colDescription,
                            const std::vector<std::string>& dataset);

  Status setRowIDs(const std::shared_ptr<ElementIdentifiers>& elementIDs,
                   const std::vector<int>& values);

  virtual void setColNames(const std::vector<std::string>& newColNames)
  {
    m_colNames = newColNames;
  }

  template<typename DTYPE = std::any>
  std::shared_ptr<VectorDataTyped<DTYPE>> readColumn(const std::string& colName)
  {
    std::string columnPath = AQNWB::mergePaths(m_path, colName);
    auto ioPtr = getIO();
    if (ioPtr != nullptr) {
      if (ioPtr->objectExists(columnPath)) {
        if (ioPtr->getStorageObjectType(columnPath)
            == StorageObjectType::Dataset)
        {
          return VectorDataTyped<DTYPE>::create(columnPath, ioPtr);
        }
      }
    } else {
      std::cerr << "IO object has been deleted. Can't read column: " << colName
                << " in DynamicTable: " << m_path << std::endl;
    }
    return nullptr;
  }
 
  DEFINE_ATTRIBUTE_FIELD(readColNames,
                         std::string,
                         "colnames",
                         The names of the columns in the table)
 
  DEFINE_ATTRIBUTE_FIELD(readDescription,
                         std::string,
                         "description",
                         Description of what is in this dynamic table)
 
  DEFINE_REGISTERED_FIELD(
      readIdColumn,
      ElementIdentifiers,
      "id",
      "unique identifiers for the rows of this dynamic table")
 
protected:
  SizeType addColumnName(const std::string& colName);

  std::vector<std::string> m_colNames;

  std::unique_ptr<IO::RecordingObjects> m_recordingColumns;

  std::shared_ptr<ElementIdentifiers> m_rowElementIdentifiers;
};
}  // namespace AQNWB::NWB