Data.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <memory>
 
#include "Types.hpp"
#include "io/BaseIO.hpp"
#include "nwb/RegisteredType.hpp"
#include "spec/hdmf_common.hpp"
 
namespace AQNWB::NWB
{
 
using CellValue = AQNWB::Types::CellValue;

class Data : public RegisteredType
{
public:
  struct DataSpecBase : public IO::ArrayDataSetConfig
  {
    DataSpecBase(const std::string& datasetName,
                 const IO::ArrayDataSetConfig& dataConfig)
        : IO::ArrayDataSetConfig(dataConfig)
        , name(datasetName)
    {
    }
 
    virtual ~DataSpecBase() = default;

    virtual std::shared_ptr<Data> create(
        const std::string& path, std::shared_ptr<IO::BaseIO> io) const = 0;

    virtual Status initialize(Data& data) const = 0;

    std::string name;
  };

  template<typename DataT>
  struct DataSpec : public DataSpecBase
  {
    DataSpec(const std::string& datasetName,
             const IO::ArrayDataSetConfig& dataConfig)
        : DataSpecBase(datasetName, dataConfig)
    {
    }

    std::shared_ptr<Data> create(const std::string& path,
                                 std::shared_ptr<IO::BaseIO> io) const override
    {
      return DataT::create(path, io);
    }
  };
 
  // Register the Data class with the type registry
  REGISTER_SUBCLASS(Data, RegisteredType, "hdmf-common")
 
protected:
  Data(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
public:
  virtual ~Data() override {}

  Status initialize(const IO::BaseArrayDataSetConfig& dataConfig);

  inline bool isInitialized() { return this->readData()->exists(); }

  virtual std::vector<AQNWB::Types::CellValue> readCellValues(
      const SizeArray& start = {},
      const SizeArray& count = {},
      const SizeArray& stride = {},
      const SizeArray& block = {});
 
  // Define the data fields to expose for lazy read access
  DEFINE_DATASET_FIELD(readData, recordData, std::any, "", The main data)
 
  DEFINE_ATTRIBUTE_FIELD(readNeurodataType,
                         std::string,
                         "neurodata_type",
                         The name of the type)
 
  DEFINE_ATTRIBUTE_FIELD(readNamespace,
                         std::string,
                         "namespace",
                         The name of the namespace)
};

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

  virtual ~DataTyped() override {}

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