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<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<IO::BaseIO> getIO() const { return m_io; }

  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<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<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<IO::ReadDataWrapper<SOT, VTYPE>> readField(
      const std::string& fieldPath) const
  {
    return std::make_unique<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 IO::SearchMode& search_mode = 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<IO::BaseIO>)> factoryFunction,
      const std::string& typeName,
      const std::string& typeNamespace);

  std::string m_path;

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

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

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

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

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

 * Doxygen but the version generated by its on PREDEFINED expansion.
 *
 * @param name The name of the function to generate.
 * @param registeredType The specific subclass of registered type to use
 * @param fieldPath The path to the field.
 * @param description A detailed description of the field.
 */
#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