ObjectPath.hpp

#pragma once
#include <score/model/path/ObjectIdentifier.hpp>
#include <score/tools/SafeCast.hpp>
 
#include <QObject>
#include <QPointer>
#include <QString>
 
#include <score_lib_base_export.h>
 
#include <initializer_list>
#include <type_traits>
#include <vector>
namespace score
{
struct DocumentContext;
}
class QObject;
 
class SCORE_LIB_BASE_EXPORT ObjectPath
{
  friend ObjectIdentifierVector::iterator begin(ObjectPath& path) noexcept
  {
    return path.m_objectIdentifiers.begin();
  }
 
  friend ObjectIdentifierVector::iterator end(ObjectPath& path) noexcept
  {
    return path.m_objectIdentifiers.end();
  }
 
  friend bool operator==(const ObjectPath& lhs, const ObjectPath& rhs) noexcept
  {
    return lhs.m_objectIdentifiers == rhs.m_objectIdentifiers;
  }
 
  friend bool operator!=(const ObjectPath& lhs, const ObjectPath& rhs) noexcept
  {
    return lhs.m_objectIdentifiers != rhs.m_objectIdentifiers;
  }
 
public:
  ObjectPath() noexcept { }
  ~ObjectPath() noexcept = default;
  QString toString() const noexcept;
 
  explicit ObjectPath(std::vector<ObjectIdentifier> vec) noexcept
      : m_objectIdentifiers{std::move(vec)}
  {
  }
 
  ObjectPath(std::initializer_list<ObjectIdentifier> lst) noexcept
      : m_objectIdentifiers(lst)
  {
  }
 
  ObjectPath(const ObjectPath& obj) noexcept
      : m_objectIdentifiers{obj.m_objectIdentifiers}
  {
  }
 
  ObjectPath(ObjectPath&& obj) noexcept
      : m_objectIdentifiers{std::move(obj.m_objectIdentifiers)}
  {
  }
 
  ObjectPath& operator=(ObjectPath&& obj) noexcept
  {
    m_objectIdentifiers = std::move(obj.m_objectIdentifiers);
    m_cache.clear();
    return *this;
  }
 
  ObjectPath& operator=(const ObjectPath& obj) noexcept
  {
    m_objectIdentifiers = obj.m_objectIdentifiers;
    m_cache.clear();
    return *this;
  }
 
  static ObjectPath
  pathBetweenObjects(const QObject* const parent_obj, const QObject* target_object);
 
  template <class T>
  T& find(const score::DocumentContext& ctx) const
  {
    // First see if the pointer is still loaded in the cache.
    if(!m_cache.isNull())
    {
      return *safe_cast<T*>(m_cache.data());
    }
    else // Load it by hand
    {
      auto ptr = safe_cast<typename std::remove_const<T>::type*>(find_impl(ctx));
      m_cache = ptr;
      return *ptr;
    }
  }
 
  template <class T>
  T* try_find(const score::DocumentContext& ctx) const noexcept
  {
    try
    {
      if(!m_cache.isNull())
      {
        return safe_cast<T*>(m_cache.data());
      }
      else // Load it by hand
      {
        auto ptr
            = static_cast<typename std::remove_const<T>::type*>(find_impl_unsafe(ctx));
        m_cache = ptr;
        return ptr;
      }
    }
    catch(...)
    {
      return nullptr;
    }
  }
 
  const ObjectIdentifierVector& vec() const noexcept { return m_objectIdentifiers; }
 
  ObjectIdentifierVector& vec() noexcept { return m_objectIdentifiers; }
 
  void resetCache() const noexcept { m_cache = {}; }
 
private:
  // Throws
  QObject* find_impl(const score::DocumentContext& ctx) const;
 
  // Returns nullptr
  QObject* find_impl_unsafe(const score::DocumentContext& ctx) const noexcept;
 
  ObjectIdentifierVector m_objectIdentifiers;
  mutable QPointer<QObject> m_cache;
};
 
SCORE_LIB_BASE_EXPORT void
replacePathPart(const ObjectPath& src, const ObjectPath& target, ObjectPath& toChange);
inline uint qHash(const ObjectPath& obj, uint seed)
{
  return qHash(obj.toString(), seed);
}
 
namespace std
{
template <>
struct SCORE_LIB_BASE_EXPORT hash<ObjectIdentifier>
{
  std::size_t operator()(const ObjectIdentifier& path) const;
};
template <>
struct SCORE_LIB_BASE_EXPORT hash<ObjectPath>
{
  std::size_t operator()(const ObjectPath& path) const;
};
}