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 std::enable_shared_from_this<RegisteredType>
{
public:
  virtual ~RegisteredType();

  inline const 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
  {
    auto ioPtr = m_io.lock();
    return ioPtr;
  }

  SizeType getRecordingObjectIndex() const;

  inline bool isRegisteredRecordingObject() const
  {
    return isValidIndex(getRecordingObjectIndex());
  }

  SizeType registerRecordingObject();

  virtual AQNWB::Types::Status finalize();

  [[deprecated(
      "The cache is owned by the I/O so there should be no need to access it "
      "via RegisteredType. Use getIO()->getRecordingDataCache() instead.")]]
  inline const std::unordered_map<std::string,
                                  std::shared_ptr<IO::BaseRecordingData>>&
  getCacheRecordingData() const
  {
    if (auto io = getIO()) {
      return io->getRecordingDataCache();
    }
    throw std::runtime_error(
        "RegisteredType::getCacheRecordingData: IO object is not available");
  }

  [[deprecated(
      "The cache is owned by the I/O so there should be no need to access it "
      "via RegisteredType. Use getIO()->clearRecordingDataCache() instead.")]]
  inline virtual void clearRecordingDataCache()
  {
    if (auto io = getIO()) {
      io->clearRecordingDataCache();
    }
  }

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

  static std::unordered_map<
      std::string,
      std::pair<std::function<std::shared_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");
    auto existing = getExistingRecordingObject(path, io);
    if (existing) {
      auto casted = std::dynamic_pointer_cast<T>(existing);
      if (casted) {
        return casted;
      }
      std::cerr << "RegisteredType::create: cached object at path " << path
                << " has type " << existing->getFullTypeName()
                << ", which does not match the requested type." << std::endl;
      return nullptr;
    }
    auto result = std::shared_ptr<T>(new T(path, io));
    result->registerRecordingObject();
    return result;
  }

  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
  {
    auto ioPtr = getIO();
    if (!ioPtr) {
      std::cerr << "IO object has been deleted. Can't read field: " << fieldPath
                << std::endl;
      return nullptr;
    }
    return std::make_unique<AQNWB::IO::ReadDataWrapper<SOT, VTYPE>>(
        ioPtr, AQNWB::mergePaths(m_path, fieldPath));
  }

  inline std::shared_ptr<AQNWB::NWB::RegisteredType> readField(
      const std::string& fieldPath) const
  {
    auto ioPtr = getIO();
    if (!ioPtr) {
      std::cerr << "IO object has been deleted. Can't read field: " << fieldPath
                << std::endl;
      return nullptr;
    }
    return this->create(AQNWB::mergePaths(m_path, fieldPath), ioPtr);
  }

  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;

  virtual std::string findOwnedObject(const std::string& name) const;
 
protected:
  static std::shared_ptr<RegisteredType> getExistingRecordingObject(
      const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io);

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

  static const std::string m_defaultUnregisteredGroupTypeClass;

  static const std::string m_defaultUnregisteredDatasetTypeClass;

  static void registerSubclass(
      const std::string& fullClassName,
      std::function<std::shared_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::weak_ptr<IO::BaseIO> m_io;
};

#define REGISTER_SUBCLASS_WITH_TYPENAME(T, BASE, NAMESPACE_VAR, TYPENAME) \
  friend class AQNWB::NWB::RegisteredType; /* base can call constructor */ \
protected: \
  using BASE::BASE; /* inherit from immediate base */ \
public: \
  static bool registerSubclass() \
  { \
    AQNWB::NWB::RegisteredType::registerSubclass( \
        std::string(NAMESPACE_VAR) + "::" + #T, \
        [](const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io) \
            -> std::shared_ptr<AQNWB::NWB::RegisteredType> \
        { return RegisteredType::create<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; \
  } \
  static std::shared_ptr<T> create(const std::string& path, \
                                   std::shared_ptr<AQNWB::IO::BaseIO> io) \
  { \
    return RegisteredType::create<T>(path, io); \
  }

#define REGISTER_SUBCLASS(T, BASE, NAMESPACE) \
  REGISTER_SUBCLASS_WITH_TYPENAME(T, BASE, 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<AQNWB::NWB::AttributeField, VTYPE>> \
  name() const \
  { \
    auto ioPtr = getIO(); \
    if (!ioPtr) { \
      std::cerr << "IO object has been deleted. Can't read field: " \
                << fieldPath << std::endl; \
      return nullptr; \
    } \
    return std::make_unique< \
        AQNWB::IO::ReadDataWrapper<AQNWB::NWB::AttributeField, VTYPE>>( \
        ioPtr, 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 \
  { \
    auto ioPtr = getIO(); \
    if (!ioPtr) { \
      std::cerr << "IO object has been deleted. Can't read field: " \
                << fieldPath << std::endl; \
      return nullptr; \
    } \
    return std::make_unique< \
        AQNWB::IO::ReadDataWrapper<AQNWB::NWB::DatasetField, VTYPE>>( \
        ioPtr, AQNWB::mergePaths(m_path, fieldPath)); \
  } \
 \
  inline std::shared_ptr<AQNWB::IO::BaseRecordingData> writeName(bool reset = \
                                                                     false) \
  { \
    std::string fullPath = AQNWB::mergePaths(m_path, fieldPath); \
    auto ioPtr = getIO(); \
    if (!ioPtr) { \
      std::cerr << "IO object has been deleted. Can't access: " << fullPath \
                << std::endl; \
      return nullptr; \
    } \
    return ioPtr->getDataSet(fullPath, reset); \
  }


#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); \
    auto ioPtr = getIO(); \
    if (ioPtr != nullptr) { \
      if (ioPtr->objectExists(objectPath)) { \
        return RTYPE::create(objectPath, ioPtr); \
      } \
    } \
    return nullptr; \
  }

#define DEFINE_UNNAMED_REGISTERED_FIELD( \
    readName, writeName, registeredType, fieldPrefixPath, description) \
 \
  template<typename RTYPE = registeredType> \
  inline std::shared_ptr<RTYPE> readName(const std::string& objectName) const \
  { \
    std::string prefixPath = AQNWB::mergePaths(m_path, fieldPrefixPath); \
    std::string objectPath = AQNWB::mergePaths(prefixPath, objectName); \
    auto ioPtr = getIO(); \
    if (!ioPtr) { \
      std::cerr << "IO object has been deleted. Can't read field: " \
                << objectPath << std::endl; \
      return nullptr; \
    } \
    if (ioPtr->objectExists(objectPath)) { \
      return RTYPE::create(objectPath, ioPtr); \
    } \
    return nullptr; \
  } \
 \
  template<typename RTYPE = registeredType> \
  inline std::shared_ptr<RTYPE> writeName(const std::string& objectName) const \
  { \
    std::string prefixPath = AQNWB::mergePaths(m_path, fieldPrefixPath); \
    std::string objectPath = AQNWB::mergePaths(prefixPath, objectName); \
    auto ioPtr = getIO(); \
    if (!ioPtr) { \
      std::cerr << "IO object has been deleted. Can't create field: " \
                << objectPath << std::endl; \
      return nullptr; \
    } \
    return RTYPE::create(objectPath, ioPtr); \
  }

#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); \
      auto ioPtr = getIO(); \
      if (ioPtr != nullptr) { \
        std::string objectPath = ioPtr->readReferenceAttribute(attrPath); \
        if (ioPtr->objectExists(objectPath)) { \
          return RTYPE::create(objectPath, ioPtr); \
        } \
      } \
    } catch (const std::exception& e) { \
      std::cerr << "WARNING Error occurred in " << #name << " " << e.what() \
                << std::endl; \
      return nullptr; \
    } \
    return nullptr; \
  }
 
}  // namespace NWB
}  // namespace AQNWB