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>;
 
 
struct HANDLER_CONTEXT
{
 std::string ClientName;
};
 
 
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 )( RequestType&,
 const HANDLER_CONTEXT& ) )
 {
 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
 {
 RequestType cmd;
 ApiResponse envelope;
 
 if( !tryUnpack( aRequest, envelope, cmd ) )
 return envelope;
 
 HANDLER_CONTEXT ctx;
 ctx.ClientName = aRequest.header().client_name();
 
 HANDLER_RESULT<ResponseType> response =
 std::invoke( aHandler, static_cast<HandlerType*>( this ), cmd, 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