RegisteredType.hpp

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
#include "Types.hpp"
#include "Utils.hpp"
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
 
namespace AQNWB
{
namespace NWB
{

constexpr auto AttributeField = AQNWB::Types::StorageObjectType::Attribute;

constexpr auto DatasetField = AQNWB::Types::StorageObjectType::Dataset;

class RegisteredType
{
public:
  RegisteredType(const std::string& path,
                 std::shared_ptr<AQNWB::IO::BaseIO> io);

  virtual ~RegisteredType();

  inline std::string getPath() const { return m_path; }

  inline std::string getName() const
  {
    return std::filesystem::path(m_path).filename().string();
  }

  inline std::shared_ptr<AQNWB::IO::BaseIO> getIO() const { return m_io; }

  inline void clearRecordingDataCache() { this->m_recordingDataCache.clear(); }

  inline const std::unordered_map<std::string,
                                  std::shared_ptr<IO::BaseRecordingData>>&
  getCacheRecordingData() const
  {
    return this->m_recordingDataCache;
  }

  static std::unordered_set<std::string>& getRegistry();

  static std::unordered_map<
      std::string,
      std::pair<std::function<std::unique_ptr<RegisteredType>(
                    const std::string&, std::shared_ptr<AQNWB::IO::BaseIO>)>,
                std::pair<std::string, std::string>>>&
  getFactoryMap();

  static std::shared_ptr<RegisteredType> create(
      const std::string& fullClassName,
      const std::string& path,
      std::shared_ptr<IO::BaseIO> io,
      bool fallbackToBase = false);

  static std::shared_ptr<AQNWB::NWB::RegisteredType> create(
      const std::string& path,
      std::shared_ptr<IO::BaseIO> io,
      bool fallbackToBase = false);

  template<typename T>
  static inline std::shared_ptr<T> create(const std::string& path,
                                          std::shared_ptr<AQNWB::IO::BaseIO> io)
  {
    static_assert(std::is_base_of<RegisteredType, T>::value,
                  "T must be a derived class of RegisteredType");
    return std::shared_ptr<T>(new T(path, io));
  }

  virtual std::string getTypeName() const;

  virtual std::string getNamespace() const;

  inline std::string getFullTypeName() const
  {
    return (getNamespace() + "::" + getTypeName());
  }

  template<StorageObjectType SOT,
           typename VTYPE,
           typename std::enable_if<Types::IsDataStorageObjectType<SOT>::value,
                                   int>::type = 0>
  inline std::unique_ptr<AQNWB::IO::ReadDataWrapper<SOT, VTYPE>> readField(
      const std::string& fieldPath) const
  {
    return std::make_unique<AQNWB::IO::ReadDataWrapper<SOT, VTYPE>>(
        m_io, AQNWB::mergePaths(m_path, fieldPath));
  }

  inline std::shared_ptr<AQNWB::NWB::RegisteredType> readField(
      const std::string& fieldPath) const
  {
    return this->create(AQNWB::mergePaths(m_path, fieldPath), m_io);
  }

  virtual std::unordered_map<std::string, std::string> findOwnedTypes(
      const std::unordered_set<std::string>& types = {},
      const AQNWB::IO::SearchMode& search_mode =
          AQNWB::IO::SearchMode::STOP_ON_TYPE) const;
 
protected:
  static const std::string m_defaultUnregisteredGroupTypeClass;

  static const std::string m_defaultUnregisteredDatasetTypeClass;

  static void registerSubclass(
      const std::string& fullClassName,
      std::function<std::unique_ptr<RegisteredType>(
          const std::string&, std::shared_ptr<AQNWB::IO::BaseIO>)>
          factoryFunction,
      const std::string& typeName,
      const std::string& typeNamespace);

  std::string m_path;

  std::shared_ptr<IO::BaseIO> m_io;

  std::unordered_map<std::string, std::shared_ptr<IO::BaseRecordingData>>
      m_recordingDataCache;
};

#define REGISTER_SUBCLASS_WITH_TYPENAME(T, NAMESPACE_VAR, TYPENAME) \
  static bool registerSubclass() \
  { \
    AQNWB::NWB::RegisteredType::registerSubclass( \
        std::string(NAMESPACE_VAR) + "::" + #T, \
        [](const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io) \
            -> std::unique_ptr<AQNWB::NWB::RegisteredType> \
        { return std::make_unique<T>(path, io); }, \
        TYPENAME, \
        NAMESPACE_VAR); \
    return true; \
  } \
  static bool registered_; \
  virtual std::string getTypeName() const override \
  { \
    return TYPENAME; \
  } \
  virtual std::string getNamespace() const override \
  { \
    return NAMESPACE_VAR; \
  }

#define REGISTER_SUBCLASS(T, NAMESPACE) \
  REGISTER_SUBCLASS_WITH_TYPENAME(T, NAMESPACE, #T)

#define REGISTER_SUBCLASS_IMPL(T) bool T::registered_ = T::registerSubclass();

#define DEFINE_ATTRIBUTE_FIELD(name, default_type, fieldPath, description) \
 \
  template<typename VTYPE = default_type> \
  inline std::unique_ptr<AQNWB::IO::ReadDataWrapper<AttributeField, VTYPE>> \
  name() const \
  { \
    return std::make_unique< \
        AQNWB::IO::ReadDataWrapper<AttributeField, VTYPE>>( \
        m_io, AQNWB::mergePaths(m_path, fieldPath)); \
  }

#define DEFINE_DATASET_FIELD( \
    readName, writeName, default_type, fieldPath, description) \
 \
  template<typename VTYPE = default_type> \
  inline std::unique_ptr< \
      AQNWB::IO::ReadDataWrapper<AQNWB::NWB::DatasetField, VTYPE>> \
  readName() const \
  { \
    return std::make_unique< \
        AQNWB::IO::ReadDataWrapper<AQNWB::NWB::DatasetField, VTYPE>>( \
        m_io, AQNWB::mergePaths(m_path, fieldPath)); \
  } \
 \
  inline std::shared_ptr<AQNWB::IO::BaseRecordingData> writeName(bool reset = \
                                                                     false) \
  { \
    std::string fullPath = AQNWB::mergePaths(m_path, fieldPath); \
    if (!reset) { \
      /* Check if the dataset is already in the cache */ \
      auto it = m_recordingDataCache.find(fullPath); \
      if (it != m_recordingDataCache.end()) { \
        return it->second; \
      } \
    } \
    /* Get the dataset from IO and cache it */ \
    auto dataset = m_io->getDataSet(fullPath); \
    if (dataset) { \
      m_recordingDataCache[fullPath] = dataset; \
    } \
    return dataset; \
  }


#define DEFINE_REGISTERED_FIELD(name, registeredType, fieldPath, description) \
 \
  template<typename RTYPE = registeredType> \
  inline std::shared_ptr<RTYPE> name() const \
  { \
    std::string objectPath = AQNWB::mergePaths(m_path, fieldPath); \
    if (m_io->objectExists(objectPath)) { \
      return RegisteredType::create<RTYPE>(objectPath, m_io); \
    } \
    return nullptr; \
  }

#define DEFINE_REFERENCED_REGISTERED_FIELD( \
    name, registeredType, fieldPath, description) \
 \
  template<typename RTYPE = registeredType> \
  inline std::shared_ptr<RTYPE> name() const \
  { \
    try { \
      std::string attrPath = AQNWB::mergePaths(m_path, fieldPath); \
      std::string objectPath = m_io->readReferenceAttribute(attrPath); \
      if (m_io->objectExists(objectPath)) { \
        return RegisteredType::create<RTYPE>(objectPath, m_io); \
      } \
    } catch (const std::exception& e) { \
      return nullptr; \
    } \
    return nullptr; \
  }
 
}  // namespace NWB
}  // namespace AQNWB