DynamicTable.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <optional>
#include <string>
#include <unordered_map>
 
#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 MeaningsTable;
}  // namespace AQNWB::NWB
 
namespace AQNWB::NWB
{
class DynamicTable : public Container
{
public:
  using DataSpec = Data::DataSpecBase;
  using DataSpecPtr = std::shared_ptr<DataSpec>;
 
public:
  using CellValue = AQNWB::NWB::CellValue;
  using RowData = std::unordered_map<std::string, CellValue>;
 
  // 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:
  ~DynamicTable() override;

  Status initialize(const std::string& description,
                    const std::vector<DataSpecPtr>& dataSpecs = {});

  virtual Status validateDataSpecs(
      const std::vector<DataSpecPtr>& dataSpecs) const;

  static std::vector<DataSpecPtr> createDefaultDataSpecs(
      const SizeType rowChunkSize = 100);

  Status finalize() override;

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

  Status addColumn(const DataSpecPtr& dataSpec);

  Status addColumn(const std::shared_ptr<VectorData>& vectorData);

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

  Status addRow(const AQNWB::Types::RowData& row,
                const std::optional<int>& rowId = std::nullopt);

  Status addRows(const std::vector<AQNWB::Types::RowData>& rows,
                 const std::vector<int>& rowIds = {});

  SizeType getNumberOfRows() const;

  std::vector<AQNWB::Types::RowData> readRows(
      SizeType start = 0,
      SizeType count = Types::SizeTypeNotSet,
      const std::vector<std::string>& colNames = {},
      bool includeId = true);

  std::string toString(SizeType start = 0,
                       SizeType count = Types::SizeTypeNotSet,
                       const std::vector<std::string>& colNames = {},
                       bool includeId = true);

  Status setRowIDs(const std::vector<int>& values);

  virtual void setColNames(const std::vector<std::string>& newColNames);

  std::shared_ptr<MeaningsTable> createMeaningsTable(
      const std::string& columnName, const SizeType rowChunkSize = 100);

  template<typename T>
  struct ColumnReturnType
  {
    using type =
        typename std::conditional<std::is_base_of<VectorData, T>::value,
                                  T,
                                  VectorDataTyped<T>>::type;
  };

  template<typename T>
  struct IsVectorDataTyped : std::false_type
  {
  };
 
  template<typename DTYPE>
  struct IsVectorDataTyped<VectorDataTyped<DTYPE>> : std::true_type
  {
  };

  template<typename T = std::any>
  std::shared_ptr<typename ColumnReturnType<T>::type> readColumn(
      const std::string& colName)
  {
    using ReturnType = typename ColumnReturnType<T>::type;
    std::string columnPath = AQNWB::mergePaths(m_path, colName);
    auto ioPtr = getIO();
    if (ioPtr != nullptr) {
      if (ioPtr->objectExists(columnPath)) {
        if (ioPtr->getStorageObjectType(columnPath)
            == StorageObjectType::Dataset)
        {
          if constexpr (std::is_base_of<VectorData, T>::value
                        && !IsVectorDataTyped<ReturnType>::value)
          {
            // Resolve the concrete on-disk registered type before caching it.
            auto column = RegisteredType::create(columnPath, ioPtr);
            return std::dynamic_pointer_cast<ReturnType>(column);
          } else {
            return ReturnType::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")
 
  
  std::shared_ptr<MeaningsTable> readMeaningsTable(
      const std::string& objectName) const;

  std::shared_ptr<MeaningsTable> createMeaningsTableInstance(
      const std::string& objectName) const;
 
protected:
  SizeType addColumnName(const std::string& colName);

 
  Status flushColNames();

  struct ConfiguredColumn
  {
    std::string name;  
    IO::BaseDataType dataType;  
    std::shared_ptr<VectorData>
        column;  
  };

  std::shared_ptr<VectorData> getConfiguredColumn(
      const std::string& name) const;

  SizeType registerColumn(const std::shared_ptr<VectorData>& column);

  void clearColumns();

  Status configureDataObjects(const std::vector<DataSpecPtr>& dataSpecs);

  Status configureDataObject(const DataSpec& dataSpec);

  Status ensureConfiguredColumnsLoaded();

  Status loadConfiguredColumnsFromFile();

  template<typename RequiredDataSpec>
  Status checkRequiredColumnSpec(const std::string& requiredName,
                                 const std::vector<DataSpecPtr>& dataSpecs,
                                 const std::optional<IO::BaseDataType>&
                                     expectedDataType = std::nullopt) const
  {
    bool found = false;
    for (const auto& spec : dataSpecs) {
      if (!spec || spec->name != requiredName) {
        continue;
      }
 
      found = true;
      if (!std::dynamic_pointer_cast<RequiredDataSpec>(spec)) {
        std::cerr << "DynamicTable::checkRequiredColumnSpec: required column '"
                  << requiredName
                  << "' does not use the required concrete DataSpec type."
                  << std::endl;
        return Status::Failure;
      }
      if (spec->getShape().size() != 1) {
        std::cerr << "DynamicTable::checkRequiredColumnSpec: required column '"
                  << requiredName << "' must be one-dimensional." << std::endl;
        return Status::Failure;
      }
      if (expectedDataType.has_value()
          && !(spec->getType() == expectedDataType.value()))
      {
        std::cerr << "DynamicTable::checkRequiredColumnSpec: required column '"
                  << requiredName << "' has an invalid data type." << std::endl;
        return Status::Failure;
      }
    }
 
    if (!found) {
      std::cerr << "DynamicTable::checkRequiredColumnSpec: required column '"
                << requiredName << "' not found." << std::endl;
      return Status::Failure;
    }
    return Status::Success;
  }

  Status writeColumnBuffer(
      const ConfiguredColumn& configuredColumn,
      const IO::BaseDataType::BaseDataVectorVariant& buffer,
      SizeType rowCount);

  std::vector<int> generateRowIDs(SizeType rowCount);

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

  std::shared_ptr<ElementIdentifiers> m_rowElementIdentifiers;

  std::vector<ConfiguredColumn> m_configuredColumns;

  std::unordered_map<std::string, SizeType> m_configuredColumnIndices;
};
}  // namespace AQNWB::NWB