Connection.h

#ifndef _KDB_REPOSITORY_CONNECTION_H_
#define _KDB_REPOSITORY_CONNECTION_H_
 
#include <QString>
#include <QSharedPointer>
 
#include <kDB/Forward.h>
#include <knowCore/ValueHash.h>
#include <knowCore/WeakReference.h>
 
#include "RDFEnvironment.h"
 
class QUuid;
 
namespace Cyqlops::Crypto
{
  class RSAAlgorithm;
}
 
namespace kDB
{
  namespace Repository
  {
    class Connection
    {
      template<typename _T_>
      friend class knowCore::WeakReference;
      friend class ConnectionHandle;
      friend class GraphsManager;
      friend class QueryConnectionInfo;
      friend class SPARQLQuery;
      friend class SPARQLFunctionsManager;
      friend class Transaction;
      friend class TriplesStore;
      friend class TriplesView;
      friend class DatabaseInterface::PostgreSQL::BinaryMarshalsRegistry;
      friend class DatabaseInterface::PostgreSQL::RDFValueBinaryMarshal;
      friend class DatabaseInterface::PostgreSQL::RDFTermBinaryMarshal;
      friend class DatabaseInterface::PostgreSQL::SQLCopyData;
      friend class DatabaseInterface::PostgreSQL::SQLInterface;
      friend class DatabaseInterface::PostgreSQL::SQLQueryExecutor;
      friend class DatabaseInterface::PostgreSQL::SQLResult;
      friend class SPARQLExecution::QueryExecutorVisitor;
      friend class SPARQLExecution::SPARQLAlgebraToPostgresSQL;
      friend struct SPARQLExecution::SPARQLAlgebraToPostgresSQLVisitor;
      Connection(const QString& _host, int _port, const QString& _database = "kDB");
    public:
      static Connection create(const QString& _host, int _port, const QString& _database = "kDB");
      Connection();
      template<typename _T_> requires std::same_as<_T_, Connection>
      Connection(const knowCore::WeakReference<_T_>& _d);
      Connection(const Connection& _rhs);
      Connection& operator=(const Connection& _rhs);
      ~Connection();
      bool operator==(const Connection& _rhs) const { return d == _rhs.d; }
      bool operator!=(const Connection& _rhs) const { return d != _rhs.d; }
      bool isValid() const;
      void disconnect();
      knowCore::ReturnVoid connect(bool _initialise_database = false);
      bool isConnected() const;
      GraphsManager* graphsManager() const;
      NotificationsManager* notificationsManager();
      SPARQLFunctionsManager* sparqlFunctionsManager() const;
      knowCore::ReturnVoid executeQueryFromFile(const QString& _fileName) const;
      knowCore::ReturnVoid executeQuery(const QString& _query) const;
      TriplesStore defaultTripleStore() const;
      TriplesStore infoTripleStore() const;
      QUuid serverUuid() const;
      knowCore::Uri serverUri() const;
      Cyqlops::Crypto::RSAAlgorithm rsaAlgorithm() const;
      quint64 oid(const QString& _type) const;
      knowCore::ReturnVoid enableExtension(const QString& _extension);
      bool isExtensionEnabled(const QString& _extension) const;
      QUuid connectionUuid() const;
      QUuid executeDisconnection(const std::function<void()>& _function) const;
      void removeExecuteDisconnection(const QUuid& _uuid) const;
      QUuid executeConnection(const std::function<void(const Connection&)>& _function) const;
      void removeExecuteConnection(const QUuid& _uuid) const;
      knowDBC::Query createSQLQuery(const QString& _query = QString(), const knowCore::ValueHash& _bindings = knowCore::ValueHash(), const knowCore::ValueHash& _options = knowCore::ValueHash()) const;
      knowDBC::Query createSPARQLQuery(const RDFEnvironment& _environment = RDFEnvironment(), const QString& _query = QString(), const knowCore::ValueHash& _bindings = knowCore::ValueHash(), const knowCore::ValueHash& _options = knowCore::ValueHash()) const;
      template<typename _T_>
      _T_* extensionObject() const;
      template<typename _T_>
      void createExtensionObject();
      krQuery::Engine* krQueryEngine() const;
    private:
      void increaseSelfPCount();
      void decreaseSelfPCount();
      QObject* extensionObject(const std::type_index& _index) const;
      void createExtensionObject(QObject* _object, const std::type_index& _index);
      struct Private;
      QSharedPointer<Private> d;
    };
    template<typename _T_> requires std::same_as<_T_, Connection>
    Connection::Connection(const knowCore::WeakReference<_T_>& _d) : d(_d.d)
    {
      increaseSelfPCount();
    }
    template<typename _T_>
    _T_* Connection::extensionObject() const
    {
      return static_cast<_T_*>(extensionObject(typeid(_T_)));
    }
    template<typename _T_>
    void Connection::createExtensionObject()
    {
      createExtensionObject(new _T_(*this), typeid(_T_));
    }
 
  }
}
 
#endif