api_handler.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2023 Jon Evans <[email protected]>
 * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef KICAD_API_HANDLER_H
#define KICAD_API_HANDLER_H
 
#include <functional>
#include <optional>
 
#include <fmt/format.h>
#include <tl/expected.hpp>
 
#include <wx/debug.h>
#include <wx/string.h>
 
#include <google/protobuf/message.h>
 
#include <kicommon.h>
#include <api/common/envelope.pb.h>
#include <core/typeinfo.h>
 
using kiapi::common::ApiRequest, kiapi::common::ApiResponse;
using kiapi::common::ApiResponseStatus, kiapi::common::ApiStatusCode;
 
typedef tl::expected<ApiResponse, ApiResponseStatus> API_RESULT;
 
template <typename T>
using HANDLER_RESULT = tl::expected<T, ApiResponseStatus>;
 
 
template <typename RequestMessageType>
struct HANDLER_CONTEXT
{
    std::string ClientName;
    RequestMessageType Request;
};
 
 
class KICOMMON_API API_HANDLER
{
public:
    API_HANDLER() {}
 
    virtual ~API_HANDLER() {}
 
    API_RESULT Handle( ApiRequest& aMsg );
 
protected:
 
    typedef std::function<HANDLER_RESULT<ApiResponse>( ApiRequest& )> REQUEST_HANDLER;
 
    template <class RequestType, class ResponseType, class HandlerType>
    void registerHandler( HANDLER_RESULT<ResponseType> ( HandlerType::*aHandler )(
            const HANDLER_CONTEXT<RequestType>& ) )
    {
        std::string typeName = RequestType().GetTypeName();
 
        wxASSERT_MSG( !m_handlers.count( typeName ),
                      wxString::Format( "Duplicate API handler for type %s", typeName ) );
 
        m_handlers[typeName] =
                [this, aHandler]( ApiRequest& aRequest ) -> API_RESULT
                {
                    HANDLER_CONTEXT<RequestType> ctx;
                    ApiResponse envelope;
 
                    if( !tryUnpack( aRequest, envelope, ctx.Request ) )
                        return envelope;
 
                    ctx.ClientName = aRequest.header().client_name();
 
                    HANDLER_RESULT<ResponseType> response =
                            std::invoke( aHandler, static_cast<HandlerType*>( this ), ctx );
 
                    if( response.has_value() )
                    {
                        envelope.mutable_status()->set_status( ApiStatusCode::AS_OK );
                        envelope.mutable_message()->PackFrom( *response );
                        return envelope;
                    }
                    else
                    {
                        return tl::unexpected( response.error() );
                    }
                };
    }
 
    std::map<std::string, REQUEST_HANDLER> m_handlers;
 
    static const wxString m_defaultCommitMessage;
 
private:
 
    template<typename MessageType>
    bool tryUnpack( ApiRequest& aRequest, ApiResponse& aReply, MessageType& aDest )
    {
        if( !aRequest.message().UnpackTo( &aDest ) )
        {
            std::string msg = fmt::format( "could not unpack message of type {} from request",
                                           aDest.GetTypeName() );
            aReply.mutable_status()->set_status( ApiStatusCode::AS_BAD_REQUEST );
            aReply.mutable_status()->set_error_message( msg );
            return false;
        }
 
        return true;
    }
};
 
#endif //KICAD_API_HANDLER_H