apm.hpp

Go to the documentation of this file.

// Copyright 2009-present MongoDB, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <mongocxx/options/apm-fwd.hpp> // IWYU pragma: export
 
//
 
#include <mongocxx/v1/apm.hpp> // IWYU pragma: export
 
#include <functional>
#include <utility>
 
#include <mongocxx/events/command_failed_event.hpp>
#include <mongocxx/events/command_started_event.hpp>
#include <mongocxx/events/command_succeeded_event.hpp>
#include <mongocxx/events/heartbeat_failed_event.hpp>
#include <mongocxx/events/heartbeat_started_event.hpp>
#include <mongocxx/events/heartbeat_succeeded_event.hpp>
#include <mongocxx/events/server_changed_event.hpp>
#include <mongocxx/events/server_closed_event.hpp>
#include <mongocxx/events/server_opening_event.hpp>
#include <mongocxx/events/topology_changed_event.hpp>
#include <mongocxx/events/topology_closed_event.hpp>
#include <mongocxx/events/topology_opening_event.hpp>
 
#include <mongocxx/config/prelude.hpp>
 
namespace mongocxx {
namespace v_noabi {
namespace options {

class apm {
   public:
    apm() = default;

    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() apm(v1::apm other);

    explicit operator v1::apm() const {
        v1::apm ret;
 
        ret.on_command_started(_command_started);
        ret.on_command_failed(_command_failed);
        ret.on_command_succeeded(_command_succeeded);
        ret.on_server_closed(_server_closed);
        ret.on_server_description_changed(_server_changed);
        ret.on_server_opening(_server_opening);
        ret.on_topology_closed(_topology_closed);
        ret.on_topology_description_changed(_topology_changed);
        ret.on_topology_opening(_topology_opening);
        ret.on_server_heartbeat_started(_heartbeat_started);
        ret.on_server_heartbeat_failed(_heartbeat_failed);
        ret.on_server_heartbeat_succeeded(_heartbeat_succeeded);
 
        return ret;
    }

    apm& on_command_started(
        std::function<void MONGOCXX_ABI_CDECL(events::command_started_event const&)> command_started) {
        _command_started = std::move(command_started);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::command_started_event const&)> const& command_started() const {
        return _command_started;
    }

    apm& on_command_failed(std::function<void MONGOCXX_ABI_CDECL(events::command_failed_event const&)> command_failed) {
        _command_failed = std::move(command_failed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::command_failed_event const&)> const& command_failed() const {
        return _command_failed;
    }

    apm& on_command_succeeded(
        std::function<void MONGOCXX_ABI_CDECL(events::command_succeeded_event const&)> command_succeeded) {
        _command_succeeded = std::move(command_succeeded);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::command_succeeded_event const&)> const& command_succeeded() const {
        return _command_succeeded;
    }

    apm& on_server_opening(std::function<void MONGOCXX_ABI_CDECL(events::server_opening_event const&)> server_opening) {
        _server_opening = std::move(server_opening);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::server_opening_event const&)> const& server_opening() const {
        return _server_opening;
    }

    apm& on_server_closed(std::function<void MONGOCXX_ABI_CDECL(events::server_closed_event const&)> server_closed) {
        _server_closed = std::move(server_closed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::server_closed_event const&)> const& server_closed() const {
        return _server_closed;
    }

    apm& on_server_changed(std::function<void MONGOCXX_ABI_CDECL(events::server_changed_event const&)> server_changed) {
        _server_changed = std::move(server_changed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::server_changed_event const&)> const& server_changed() const {
        return _server_changed;
    }

    apm& on_topology_opening(
        std::function<void MONGOCXX_ABI_CDECL(events::topology_opening_event const&)> topology_opening) {
        _topology_opening = std::move(topology_opening);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::topology_opening_event const&)> const& topology_opening() const {
        return _topology_opening;
    }

    apm& on_topology_closed(
        std::function<void MONGOCXX_ABI_CDECL(events::topology_closed_event const&)> topology_closed) {
        _topology_closed = std::move(topology_closed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::topology_closed_event const&)> const& topology_closed() const {
        return _topology_closed;
    }

    apm& on_topology_changed(
        std::function<void MONGOCXX_ABI_CDECL(events::topology_changed_event const&)> topology_changed) {
        _topology_changed = std::move(topology_changed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::topology_changed_event const&)> const& topology_changed() const {
        return _topology_changed;
    }

    apm& on_heartbeat_started(
        std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_started_event const&)> heartbeat_started) {
        _heartbeat_started = std::move(heartbeat_started);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_started_event const&)> const& heartbeat_started() const {
        return _heartbeat_started;
    }

    apm& on_heartbeat_failed(
        std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_failed_event const&)> heartbeat_failed) {
        _heartbeat_failed = std::move(heartbeat_failed);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_failed_event const&)> const& heartbeat_failed() const {
        return _heartbeat_failed;
    }

    apm& on_heartbeat_succeeded(
        std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_succeeded_event const&)> heartbeat_succeeded) {
        _heartbeat_succeeded = std::move(heartbeat_succeeded);
        return *this;
    }

    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_succeeded_event const&)> const& heartbeat_succeeded()
        const {
        return _heartbeat_succeeded;
    }
 
   private:
    std::function<void MONGOCXX_ABI_CDECL(events::command_started_event const&)> _command_started;
    std::function<void MONGOCXX_ABI_CDECL(events::command_failed_event const&)> _command_failed;
    std::function<void MONGOCXX_ABI_CDECL(events::command_succeeded_event const&)> _command_succeeded;
    std::function<void MONGOCXX_ABI_CDECL(events::server_closed_event const&)> _server_closed;
    std::function<void MONGOCXX_ABI_CDECL(events::server_changed_event const&)> _server_changed;
    std::function<void MONGOCXX_ABI_CDECL(events::server_opening_event const&)> _server_opening;
    std::function<void MONGOCXX_ABI_CDECL(events::topology_closed_event const&)> _topology_closed;
    std::function<void MONGOCXX_ABI_CDECL(events::topology_changed_event const&)> _topology_changed;
    std::function<void MONGOCXX_ABI_CDECL(events::topology_opening_event const&)> _topology_opening;
    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_started_event const&)> _heartbeat_started;
    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_failed_event const&)> _heartbeat_failed;
    std::function<void MONGOCXX_ABI_CDECL(events::heartbeat_succeeded_event const&)> _heartbeat_succeeded;
};
 
} // namespace options
} // namespace v_noabi
} // namespace mongocxx
 
namespace mongocxx {
namespace v_noabi {

inline v_noabi::options::apm from_v1(v1::apm v) {
    return {std::move(v)};
}

inline v1::apm to_v1(v_noabi::options::apm const& v) {
    return v1::apm{v};
}
 
} // namespace v_noabi
} // namespace mongocxx
 
#include <mongocxx/config/postlude.hpp>