Connection.hpp

#ifndef _PRIVMXLIB_ENDPOINT_CORE_CONNECTION_HPP_
#define _PRIVMXLIB_ENDPOINT_CORE_CONNECTION_HPP_
 
#include <memory>
#include <optional>
#include <string>
 
#include "privmx/endpoint/core/ExtendedPointer.hpp"
#include "privmx/endpoint/core/Types.hpp"
#include "privmx/endpoint/core/UserVerifierInterface.hpp"
 
namespace privmx {
namespace endpoint {
namespace core {
 
class ConnectionImpl;

class Connection : public ExtendedPointer<ConnectionImpl> {
public:
    static Connection connect(
        const std::string& userPrivKey,
        const std::string& solutionId,
        const std::string& bridgeUrl,
        const PKIVerificationOptions& verificationOptions = PKIVerificationOptions()
    );

    static Connection connectPublic(
        const std::string& solutionId,
        const std::string& bridgeUrl,
        const PKIVerificationOptions& verificationOptions = PKIVerificationOptions()
    );

    Connection();
    Connection(const Connection& obj);
    Connection& operator=(const Connection& obj);
    Connection(Connection&& obj);
    ~Connection();

    int64_t getConnectionId();

    PagingList<Context> listContexts(const PagingQuery& pagingQuery);

    PagingList<UserInfo> listContextUsers(const std::string& contextId, const PagingQuery& pagingQuery);

    std::vector<std::string> subscribeFor(const std::vector<std::string>& subscriptionQueries);

    void unsubscribeFrom(const std::vector<std::string>& subscriptionIds);

    std::string buildSubscriptionQuery(
        EventType eventType,
        EventSelectorType selectorType,
        const std::string& selectorId
    );

    void disconnect();

    void setUserVerifier(std::shared_ptr<UserVerifierInterface> verifier);
 
private:
    void assertConnection(const std::shared_ptr<ConnectionImpl>& impl);
    Connection(const std::shared_ptr<ConnectionImpl>& impl);
    std::optional<int64_t> _connectionId;
};
 
} // namespace core
} // namespace endpoint
} // namespace privmx
 
#endif // _PRIVMXLIB_ENDPOINT_CORE_CONNECTION_HPP_