Handle.hpp

#pragma once
 
#include "data/cassandra/Error.hpp"
#include "data/cassandra/Types.hpp"
#include "data/cassandra/impl/Batch.hpp"
#include "data/cassandra/impl/Cluster.hpp"
#include "data/cassandra/impl/Future.hpp"
#include "data/cassandra/impl/ManagedObject.hpp"
#include "data/cassandra/impl/Result.hpp"
#include "data/cassandra/impl/Session.hpp"
#include "data/cassandra/impl/Statement.hpp"
 
#include <cassandra.h>
 
#include <functional>
#include <string_view>
#include <vector>

namespace data::cassandra {

class Handle {
    impl::Cluster cluster_;
    impl::Session session_;
 
public:
    using ResultOrErrorType = ResultOrError;
    using MaybeErrorType = MaybeError;
    using FutureWithCallbackType = FutureWithCallback;
    using FutureType = Future;
    using StatementType = Statement;
    using PreparedStatementType = PreparedStatement;
    using ResultType = Result;

    explicit Handle(Settings clusterSettings = Settings::defaultSettings());

    explicit Handle(std::string_view contactPoints);

    ~Handle();

    Handle(Handle&&) = default;

    [[nodiscard]] FutureType
    asyncConnect() const;

    [[nodiscard]] MaybeErrorType
    connect() const;

    [[nodiscard]] FutureType
    asyncConnect(std::string_view keyspace) const;

    [[nodiscard]] MaybeErrorType
    connect(std::string_view keyspace) const;

    [[nodiscard]] FutureType
    asyncDisconnect() const;

    [[maybe_unused]] MaybeErrorType
    disconnect() const;

    [[nodiscard]] FutureType
    asyncReconnect(std::string_view keyspace) const;

    [[nodiscard]] MaybeErrorType
    reconnect(std::string_view keyspace) const;

    template <typename... Args>
    [[nodiscard]] FutureType
    asyncExecute(std::string_view query, Args&&... args) const
    {
        auto statement = StatementType{query, std::forward<Args>(args)...};
        return cass_session_execute(session_, statement);
    }

    template <typename... Args>
    [[maybe_unused]] ResultOrErrorType
    execute(std::string_view query, Args&&... args) const
    {
        return asyncExecute<Args...>(query, std::forward<Args>(args)...).get();
    }

    [[nodiscard]] std::vector<FutureType>
    asyncExecuteEach(std::vector<StatementType> const& statements) const;

    [[maybe_unused]] MaybeErrorType
    executeEach(std::vector<StatementType> const& statements) const;

    template <typename... Args>
    [[nodiscard]] FutureType
    asyncExecute(PreparedStatementType const& statement, Args&&... args) const
    {
        auto bound = statement.bind<Args...>(std::forward<Args>(args)...);
        return cass_session_execute(session_, bound);
    }

    template <typename... Args>
    [[maybe_unused]] ResultOrErrorType
    execute(PreparedStatementType const& statement, Args&&... args) const
    {
        return asyncExecute<Args...>(statement, std::forward<Args>(args)...).get();
    }

    [[nodiscard]] FutureType
    asyncExecute(StatementType const& statement) const;

    [[nodiscard]] FutureWithCallbackType
    asyncExecute(StatementType const& statement, std::function<void(ResultOrErrorType)>&& cb) const;

    [[maybe_unused]] ResultOrErrorType
    execute(StatementType const& statement) const;

    [[nodiscard]] FutureType
    asyncExecute(std::vector<StatementType> const& statements) const;

    [[maybe_unused]] MaybeErrorType
    execute(std::vector<StatementType> const& statements) const;

    [[nodiscard]] FutureWithCallbackType
    asyncExecute(
        std::vector<StatementType> const& statements,
        std::function<void(ResultOrErrorType)>&& cb
    ) const;

    [[nodiscard]] PreparedStatementType
    prepare(std::string_view query) const;
};

template <typename... Types>
[[nodiscard]] impl::ResultExtractor<Types...>
extract(Handle::ResultType const& result)
{
    return {result};
}
 
}  // namespace data::cassandra