functional_method.h

Go to the documentation of this file.

/*
 * Copyright 2023 MusicScience37 (Kenta Kabashima)
 *
 * 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 <exception>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <msgpack.hpp>
 
#include "msgpack_rpc/logging/logger.h"
#include "msgpack_rpc/messages/message_serializer.h"
#include "msgpack_rpc/messages/method_name.h"
#include "msgpack_rpc/messages/method_name_view.h"
#include "msgpack_rpc/messages/parsed_notification.h"
#include "msgpack_rpc/messages/parsed_request.h"
#include "msgpack_rpc/messages/serialized_message.h"
#include "msgpack_rpc/methods/i_method.h"
#include "msgpack_rpc/methods/method_exception.h"
#include "msgpack_rpc/util/format_msgpack_object.h"
 
namespace msgpack_rpc::methods {

template <typename Signature, typename Function, typename /*for SFINAE*/ = void>
class FunctionalMethod;

template <typename Function, typename Result, typename... Parameters>
class FunctionalMethod<Result(Parameters...), Function,
    std::enable_if_t<!std::is_same_v<Result, void>>>
    final : public IMethod {
public:
    template <typename InputFunction>
    FunctionalMethod(messages::MethodName name, InputFunction&& function,
        std::shared_ptr<logging::Logger> logger)
        : name_(std::move(name)),
          function_(std::forward<InputFunction>(function)),
          logger_(std::move(logger)) {}

    [[nodiscard]] messages::MethodNameView name() const noexcept override {
        return name_;
    }

    [[nodiscard]] messages::SerializedMessage call(
        const messages::ParsedRequest& request) override {
        try {
            return messages::MessageSerializer::serialize_successful_response(
                request.id(),
                invoke_with_tuple(
                    request.parameters().as<std::decay_t<Parameters>...>()));
        } catch (const MethodException& exception) {
            return messages::MessageSerializer::serialize_error_response(
                request.id(), exception.object());
        }
    }

    void notify(const messages::ParsedNotification& notification) override {
        try {
            std::apply(function_,
                notification.parameters().as<std::decay_t<Parameters>...>());
        } catch (const MethodException& e) {
            MSGPACK_RPC_DEBUG(logger_,
                "Method {} threw an exception with a custom object: {}", name_,
                util::format_msgpack_object(e.object()));
        } catch (const std::exception& e) {
            MSGPACK_RPC_DEBUG(
                logger_, "Method {} threw an exception: {}", name_, e.what());
        }
    }
 
private:
    template <typename ParameterTuple>
    decltype(auto) invoke_with_tuple(ParameterTuple&& parameter_tuple) {
        try {
            return std::apply(
                function_, std::forward<ParameterTuple>(parameter_tuple));
        } catch (const MethodException& e) {
            MSGPACK_RPC_DEBUG(logger_,
                "Method {} threw an exception with a custom object: {}", name_,
                util::format_msgpack_object(e.object()));
            throw;
        } catch (const std::exception& e) {
            MSGPACK_RPC_DEBUG(
                logger_, "Method {} threw an exception: {}", name_, e.what());
            throw MethodException(e.what());
        }
    }

    messages::MethodName name_;

    std::decay_t<Function> function_;

    std::shared_ptr<logging::Logger> logger_;
};

template <typename Function, typename... Parameters>
class FunctionalMethod<void(Parameters...), Function> final : public IMethod {
public:
    template <typename InputFunction>
    FunctionalMethod(messages::MethodNameView name, InputFunction&& function,
        std::shared_ptr<logging::Logger> logger)
        : name_(name),
          function_(std::forward<InputFunction>(function)),
          logger_(std::move(logger)) {}

    [[nodiscard]] messages::MethodNameView name() const noexcept override {
        return name_;
    }

    [[nodiscard]] messages::SerializedMessage call(
        const messages::ParsedRequest& request) override {
        try {
            std::apply(function_,
                request.parameters().as<std::decay_t<Parameters>...>());
        } catch (const MethodException& e) {
            MSGPACK_RPC_DEBUG(logger_,
                "Method {} threw an exception with a custom object: {}", name_,
                util::format_msgpack_object(e.object()));
            return messages::MessageSerializer::serialize_error_response(
                request.id(), e.object());
        } catch (const std::exception& e) {
            MSGPACK_RPC_DEBUG(
                logger_, "Method {} threw an exception: {}", name_, e.what());
            return messages::MessageSerializer::serialize_error_response(
                request.id(), e.what());
        }
        return messages::MessageSerializer::serialize_successful_response(
            request.id(), msgpack::type::nil_t());
    }

    void notify(const messages::ParsedNotification& notification) override {
        try {
            std::apply(function_,
                notification.parameters().as<std::decay_t<Parameters>...>());
        } catch (const MethodException& e) {
            MSGPACK_RPC_DEBUG(logger_,
                "Method {} threw an exception with a custom object: {}", name_,
                util::format_msgpack_object(e.object()));
        } catch (const std::exception& e) {
            MSGPACK_RPC_DEBUG(
                logger_, "Method {} threw an exception: {}", name_, e.what());
        }
    }
 
private:
    messages::MethodName name_;

    std::decay_t<Function> function_;

    std::shared_ptr<logging::Logger> logger_;
};

template <typename Signature, typename Function>
[[nodiscard]] inline std::unique_ptr<FunctionalMethod<Signature, Function>>
create_functional_method(
    // NOLINTNEXTLINE(performance-unnecessary-value-param) : false positive
    messages::MethodName name, Function&& function,
    std::shared_ptr<logging::Logger> logger) {
    return std::make_unique<
        FunctionalMethod<Signature, std::decay_t<Function>>>(
        std::move(name), std::forward<Function>(function), std::move(logger));
}
 
}  // namespace msgpack_rpc::methods