call_types.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_COMMON_CALL_TYPES_HPP
#define OCPP_COMMON_CALL_TYPES_HPP
 
#include <iostream>
#include <nlohmann/json_fwd.hpp>
#include <sstream>
#include <stdexcept>
 
#include <chrono>
#include <cstddef>
#include <iostream>
#include <string>
 
#include <ocpp/common/cistring.hpp>
 
using json = nlohmann::json;
 
namespace ocpp {
 
// The locations inside the message array
const auto MESSAGE_TYPE_ID = 0;
const auto MESSAGE_ID = 1;
const auto CALL_ACTION = 2;
const auto CALL_PAYLOAD = 3;
const auto CALLRESULT_PAYLOAD = 2;
const auto CALLERROR_ERROR_CODE = 2;
const auto CALLERROR_ERROR_DESCRIPTION = 3;
const auto CALLERROR_ERROR_DETAILS = 4;
 
class MessageId : public CiString<36> {
    using CiString::CiString;
};
 
bool operator<(const MessageId& lhs, const MessageId& rhs);
 
void to_json(json& j, const MessageId& k);
 
void from_json(const json& j, MessageId& k);
 
enum class MessageTypeId {
    CALL = 2,
    CALLRESULT = 3,
    CALLERROR = 4,
    UNKNOWN,
};
 
MessageId create_message_id();
 
template <class T> struct Call {
    T msg;
    MessageId uniqueId;
 
    Call() {
    }
 
    explicit Call(T msg) {
        this->msg = msg;
        this->uniqueId = create_message_id();
    }
 
    Call(T msg, MessageId uniqueId) {
        this->msg = msg;
        this->uniqueId = uniqueId;
    }
 
    friend void to_json(json& j, const Call& c) {
        j = json::array();
        j.push_back(MessageTypeId::CALL);
        j.push_back(c.uniqueId.get());
        j.push_back(c.msg.get_type());
        j.push_back(json(c.msg));
    }
 
    friend void from_json(const json& j, Call& c) {
        // the required parts of the message
        c.msg = j.at(CALL_PAYLOAD);
        c.uniqueId.set(j.at(MESSAGE_ID));
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Call& c) {
        os << json(c).dump(4);
        return os;
    }
};
 
template <class T> struct CallResult {
    T msg;
    MessageId uniqueId;
 
    CallResult() {
    }
 
    CallResult(T msg, MessageId uniqueId) {
        this->msg = msg;
        this->uniqueId = uniqueId;
    }
 
    friend void to_json(json& j, const CallResult& c) {
        j = json::array();
        j.push_back(MessageTypeId::CALLRESULT);
        j.push_back(c.uniqueId.get());
        j.push_back(json(c.msg));
    }
 
    friend void from_json(const json& j, CallResult& c) {
        // the required parts of the message
        c.msg = j.at(CALLRESULT_PAYLOAD);
        c.uniqueId.set(j.at(MESSAGE_ID));
    }
 
    friend std::ostream& operator<<(std::ostream& os, const CallResult& c) {
        os << json(c).dump(4);
        return os;
    }
};
 
struct CallError {
    MessageId uniqueId;
    std::string errorCode;
    std::string errorDescription;
    json errorDetails;
 
    CallError();
 
    CallError(const MessageId& uniqueId, const std::string& errorCode, const std::string& errorDescription,
              const json& errorDetails);
};
 
void to_json(json& j, const CallError& c);
 
void from_json(const json& j, CallError& c);
 
std::ostream& operator<<(std::ostream& os, const CallError& c);
 
} // namespace ocpp
 
#endif