FocusNode.h

#pragma once
 
#include <QCborMap>
 
#include <knowCore/ValueList.h>
 
#include <kDB/Repository/Connection.h>
#include <kDB/Repository/Transaction.h>
 
#include "FocusNodeDeclaration.h"
 
namespace kDB::Repository::RDF
{
  class FocusNode
  {
    friend class FocusNodeCollection;
  public:
    FocusNode();
    FocusNode(const FocusNode& _rhs);
    FocusNode& operator=(const FocusNode& _rhs);
    FocusNode(const kDB::Repository::Connection& _connection, const knowCore::Uri& _graph,
              const knowCore::Uri& _object_uri, const FocusNodeDeclaration& _declaration);
    ~FocusNode();
    bool operator==(const FocusNode& _rhs) const;
    cres_qresult<bool> exists() const;
    bool isValid() const;
    FocusNodeDeclaration declaration() const;
    knowCore::Uri uri() const;
    knowCore::Uri graph() const;
    kDB::Repository::Connection connection() const;
    cres_qresult<bool> hasProperty(const knowCore::Uri& _property,
                                   const Transaction& _transaction = Transaction()) const;
    cres_qresult<knowCore::Value> property(const knowCore::Uri& _property,
                                           const Transaction& _transaction = Transaction()) const;
    template<typename _T_>
      requires(not std::is_base_of_v<knowCore::Value, _T_>)
    cres_qresult<_T_> property(const knowCore::Uri& _property) const;
    cres_qresult<void> setProperty(const knowCore::Uri& _property, const knowCore::Value& _value,
                                   const Transaction& _transaction = Transaction()) const;
    cres_qresult<void> addPropertyToList(const knowCore::Uri& _property,
                                         const knowCore::Value& _value,
                                         const Transaction& _transaction = Transaction()) const;
    cres_qresult<void>
      removePropertyFromList(const knowCore::Uri& _property, const knowCore::Value& _value,
                             const Transaction& _transaction = Transaction()) const;
    cres_qresult<knowCore::ValueList> propertyList(const knowCore::Uri& _property,
                                                   const Transaction& _transaction
                                                   = Transaction()) const;
 
    cres_qresult<void> setPropertyInMap(const knowCore::Uri& _property, const knowCore::Uri& _key,
                                        const knowCore::Value& _value,
                                        const Transaction& _transaction = Transaction()) const;
    cres_qresult<knowCore::ValueHash> propertyMap(const knowCore::Uri& _property,
                                                  const Transaction& _transaction
                                                  = Transaction()) const;
    cres_qresult<knowCore::Value>
      propertyMapValue(const knowCore::Uri& _property, const knowCore::Uri& _key,
                       const Transaction& _transaction = Transaction()) const;
 
    template<typename _T_>
      requires(not std::is_base_of_v<knowCore::Value, _T_>)
    cres_qresult<void> setProperty(const knowCore::Uri& _property, const _T_& _value,
                                   const Transaction& _transaction = Transaction()) const
    {
      return setProperty(_property, knowCore::Value::fromValue(_value), _transaction);
    }
    cres_qresult<QCborMap> toCborMap() const;
    static cres_qresult<FocusNode> fromCborMap(const kDB::Repository::Connection& _connection,
                                               const knowCore::Uri& _graph, const QCborMap& _map);
  private:
    cres_qresult<void> setProperty(const knowCore::Uri& _property, const knowCore::Value& _value,
                                   const Transaction& _transaction,
                                   bool _allow_constant_changes) const;
    cres_qresult<void> addPropertyToList(const knowCore::Uri& _property,
                                         const knowCore::Value& _value,
                                         const Transaction& _transaction,
                                         bool _allow_constant_changes) const;
    cres_qresult<void> setPropertyInMap(const knowCore::Uri& _property, const knowCore::Uri& _key,
                                        const knowCore::Value& _value,
                                        const Transaction& _transaction,
                                        bool _allow_constant_changes) const;
 
    static cres_qresult<FocusNode> create(const kDB::Repository::QueryConnectionInfo& _connection,
                                          const knowCore::Uri& _graph_uri,
                                          const knowCore::Uri& _typeUri,
                                          const knowCore::ValueHash& _properties,
                                          const knowCore::Uri& _focusNodeUri);
  private:
    struct Private;
    QExplicitlySharedDataPointer<Private> d;
  };
  template<typename _T_>
    requires(not std::is_base_of_v<knowCore::Value, _T_>)
  inline cres_qresult<_T_> FocusNode::property(const knowCore::Uri& _property) const
  {
    cres_try(knowCore::Value value, property(_property));
    return value.value<_T_>();
  }
 
  template<typename _TDerive_>
  class FocusNodeWrapper
  {
  protected:
    FocusNodeWrapper() {}
    FocusNodeWrapper(const FocusNodeWrapper& _rhs) : m_focus_node(_rhs.m_focus_node) {}
  public:
    _TDerive_& operator=(const _TDerive_& _rhs)
    {
      m_focus_node = _rhs.m_focus_node;
      return static_cast<_TDerive_&>(*this);
    }
 
    bool operator==(const FocusNodeWrapper& _rhs) const
    {
      return m_focus_node == _rhs.m_focus_node;
    }
  protected:
    void setFocusNode(const FocusNode& _fn) { m_focus_node = _fn; }
    const FocusNode& focusNodeRef() const { return m_focus_node; }
    FocusNode& focusNodeRef() { return m_focus_node; }
  public:
    cres_qresult<bool> exists() const { return m_focus_node.exists(); }
    knowCore::Uri graph() const { return m_focus_node.graph(); }
    knowCore::Uri uri() const { return m_focus_node.uri(); }
    knowCore::Uri type() const { return m_focus_node.declaration().type(); }
    kDB::Repository::Connection connection() const { return m_focus_node.connection(); }
    cres_qresult<bool> hasProperty(const knowCore::Uri& _property) const
    {
      return m_focus_node.hasProperty(_property);
    }
    cres_qresult<knowCore::Value> property(const knowCore::Uri& _property) const
    {
      return m_focus_node.property(_property);
    }
    template<typename _T_>
      requires(not std::is_base_of_v<knowCore::Value, _T_>)
    cres_qresult<_T_> property(const knowCore::Uri& _property) const
    {
      return m_focus_node.property<_T_>(_property);
    }
    cres_qresult<void> setProperty(const knowCore::Uri& _property,
                                   const knowCore::Value& _value) const
    {
      return m_focus_node.setProperty(_property, _value);
    }
    template<typename _T_>
      requires(not std::is_base_of_v<knowCore::Value, _T_>)
    cres_qresult<void> setProperty(const knowCore::Uri& _property, const _T_& _value) const
    {
      return m_focus_node.setProperty(_property, _value);
    }
    cres_qresult<void> addPropertyToList(const knowCore::Uri& _property,
                                         const knowCore::Value& _value,
                                         const Transaction& _transaction = Transaction()) const
    {
      return m_focus_node.addPropertyToList(_property, _value, _transaction);
    }
    cres_qresult<void> removePropertyFromList(const knowCore::Uri& _property,
                                              const knowCore::Value& _value,
                                              const Transaction& _transaction = Transaction()) const
    {
      return m_focus_node.removePropertyFromList(_property, _value, _transaction);
    }
    cres_qresult<knowCore::ValueList> propertyList(const knowCore::Uri& _property,
                                                   const Transaction& _transaction
                                                   = Transaction()) const
    {
      return m_focus_node.propertyList(_property, _transaction);
    }
 
    cres_qresult<void> setPropertyInMap(const knowCore::Uri& _property, const knowCore::Uri& _key,
                                        const knowCore::Value& _value,
                                        const Transaction& _transaction = Transaction()) const
    {
      return m_focus_node.setPropertyInMap(_property, _key, _value, _transaction);
    }
    cres_qresult<knowCore::ValueHash> propertyMap(const knowCore::Uri& _property,
                                                  const Transaction& _transaction
                                                  = Transaction()) const
    {
      return m_focus_node.propertyMap(_property, _transaction);
    }
    cres_qresult<knowCore::Value>
      propertyMapValue(const knowCore::Uri& _property, const knowCore::Uri& _key,
                       const Transaction& _transaction = Transaction()) const
    {
      return m_focus_node.propertyMapValue(_property, _key, _transaction);
    }
    cres_qresult<QCborMap> toCborMap() const { return m_focus_node.toCborMap(); }
  private:
    FocusNode m_focus_node;
  };
} // namespace kDB::Repository::RDF