mrpc/src/generators/cpp_s.rs

295 lines
9.6 KiB
Rust
Raw Normal View History

2023-09-27 17:51:03 +02:00
use std::io::Write;
use itertools::Itertools;
use crate::data::RPC;
use super::IndentedWriter;
fn field_ty_to_ty_str(ty: &crate::data::FieldTy, ignore_optional: bool) -> String {
use crate::data::Types;
let inner = match &ty.ty {
Types::String => "std::string",
Types::Bool => "bool",
Types::F32 => "std::float_t",
Types::F64 => "std::double_t",
Types::I8 => "std::int8_t",
Types::I16 => "std::int16_t",
Types::I32 => "std::int32_t",
Types::I64 => "std::int64_t",
Types::U8 => "std::uint8_t",
Types::U16 => "std::uint16_t",
Types::U32 => "std::uint32_t",
Types::U64 => "std::uint64_t",
Types::Named(name) => name
};
if ty.array {
format!("std::vector<{inner}>")
} else if ty.optional && !ignore_optional {
format!("std::optional<{inner}>")
} else {
inner.to_string()
}
}
fn method_signature(service_name: &String, m: &crate::data::MethodTy) -> String {
let mut ret = String::new();
let ret_type = m.ret.as_ref().map_or("void".to_string(), |ty| field_ty_to_ty_str(ty, false));
if m.ret_stream {
ret += "void";
} else {
ret += &ret_type;
}
ret += &format!(" {}_{}(", service_name, m.name);
ret += &m.args.iter()
.map(|arg| field_ty_to_ty_str(arg, false))
.chain(m.ret_stream.then(|| format!("std::shared_ptr<MRPCStream<{ret_type}>>")))
.map(|arg| arg + "&&")
.join(", ");
ret += ")";
ret
}
fn output_header(f: &mut IndentedWriter, rpc: &RPC) {
f.f.write_all(
b"#pragma once
#ifndef MRPC_GEN_H
#define MRPC_GEN_H
#include <unordered_map>
#include <memory>
#include <mutex>
#include <iosfwd>
#include <string>
#include <cstdint>
#include <crow.h>
#include <json.hpp>
namespace mrpc {\n").unwrap();
for e in &rpc.enums {
writeln!(f, "enum struct {} : std::uint64_t {{", e.name).unwrap();
if let Some((last, vals)) = e.values.split_last() {
for v in vals {
writeln!(f, "{} = {},", v.0, v.1).unwrap();
}
writeln!(f, "{} = {}", last.0, last.1).unwrap();
}
f.write_all(b"};\n\n").unwrap();
}
for s in &rpc.structs {
writeln!(f, "struct {};", s.name).unwrap();
writeln!(f, "void to_json(nlohmann::json&, const {}&);", s.name).unwrap();
writeln!(f, "void from_json(const nlohmann::json&, {}&);\n", s.name).unwrap();
}
f.f.write_all(b"\n").unwrap();
for s in &rpc.structs {
writeln!(f, "struct {} {{", s.name).unwrap();
for field in &s.fields {
writeln!(f, "{} {};", field_ty_to_ty_str(field, false), field.name).unwrap();
}
f.write_all(b"};\n\n").unwrap();
}
f.f.write_all(
b"struct MRPCStreamImpl {
virtual void close() noexcept final;
virtual void abort() noexcept final;
virtual bool is_open() noexcept final;
protected:
MRPCStreamImpl(crow::websocket::connection *conn, uint64_t id) : conn(conn), id(id) {}
crow::websocket::connection* conn;
std::uint64_t id;
};
template<class T>
struct MRPCStream final : MRPCStreamImpl {
MRPCStream(crow::websocket::connection *conn, uint64_t id) : MRPCStreamImpl(conn, id) {}
bool send(const T &v) noexcept {
if (!conn) return false;
try {
conn->send_text(nlohmann::json{{\"id\", id},{\"data\", v}}.dump());
} catch (const std::exception &_) {
abort();
return false;
}
return true;
}
};
struct MRPCServer {
virtual void install(crow::SimpleApp &app, std::string &&route) final;
private:\n").unwrap();
f.ident = 1;
for service in &rpc.services {
for method in &service.methods {
writeln!(f, "virtual {} = 0;", method_signature(&service.name, method)).unwrap();
}
}
f.f.write_all(b"
virtual void msg_handler(crow::websocket::connection&, const std::string&, bool) final;
std::mutex __streams_mutex;
std::unordered_multimap<crow::websocket::connection*, std::shared_ptr<MRPCStreamImpl>> __streams;
};
}
#endif // MRPC_GEN_H\n").unwrap();
}
fn output_struct_json_stuff(f: &mut IndentedWriter, s: &crate::data::StructTy) {
writeln!(f, "void to_json(json &j, const {} &v) {{", s.name).unwrap();
for field in &s.fields {
if field.optional {
writeln!(f, "json_set_opt(j, \"{0}\", v.{0});", field.name).unwrap();
} else {
writeln!(f, "j[\"{0}\"] = v.{0};", field.name).unwrap();
}
}
f.write_all(b"}\n\n").unwrap();
writeln!(f, "void from_json(const json &j, {} &v) {{", s.name).unwrap();
for field in &s.fields {
if field.optional {
writeln!(f, "v.{0} = json_get_opt<{1}>(j, \"{0}\");", field.name, field_ty_to_ty_str(field, true)).unwrap();
} else {
writeln!(f, "j.at(\"{0}\").get_to(v.{0});", field.name).unwrap();
}
}
f.write_all(b"}\n\n").unwrap();
}
fn output_cpp(f: &mut IndentedWriter, header_name: String, rpc: &RPC) {
writeln!(f, "#include \"{header_name}\"").unwrap();
f.f.write_all(
b"using json = nlohmann::json;
template<class T>
inline std::optional<T> json_get_opt(const json &j, std::string &&k) {
if (j.contains(k) && !j.at(k).is_null())
return j.at(k).get<T>();
else
return std::nullopt;
}
template<class T>
inline void json_set_opt(json &j, std::string &&k, const std::optional<T> &v) {
if (v.has_value())
j[k] = v.value();
else
j[k] = nullptr;
}
namespace mrpc {\n").unwrap();
for s in &rpc.structs {
output_struct_json_stuff(f, s);
}
f.f.write_all(
b"}
template<class T>
void send_msg(crow::websocket::connection &c, uint64_t id, const T &v) {
c.send_text(json{{\"id\", id},{\"data\", v}}.dump());
}
void mrpc::MRPCStreamImpl::close() noexcept {
if (conn != nullptr) {
send_msg(*conn, id, nullptr);
conn = nullptr;
}
}
void mrpc::MRPCStreamImpl::abort() noexcept { conn = nullptr; }
bool mrpc::MRPCStreamImpl::is_open() noexcept { return conn != nullptr; }
void mrpc::MRPCServer::install(crow::SimpleApp &app, std::string &&route) {
app.route_dynamic(std::move(route))
.websocket()
.onclose([&](crow::websocket::connection &c, const std::string&){
std::lock_guard guard{__streams_mutex};
auto range = __streams.equal_range(&c);
for (auto it = range.first; it != range.second; ++it)
it->second->abort();
__streams.erase(&c);
})
.onmessage([this](auto &&a, auto &&b, auto &&c) {
try { msg_handler(a, b, c); }
catch (const std::exception &_) {}
});
}
void mrpc::MRPCServer::msg_handler(crow::websocket::connection &__c, const std::string &__msg, bool) {
json __j = json::parse(__msg);
std::uint64_t __id = __j.at(\"id\");
std::string __service = __j.at(\"service\"), __method = __j.at(\"method\");
try {\n").unwrap();
f.ident = 2;
f.write_all(b"json __data = __j.at(\"data\");\n").unwrap();
let mut first_service = true;
for service in &rpc.services {
if first_service { first_service = false; }
else { f.write_all(b"else ").unwrap(); }
writeln!(f, "if (__service == \"{}\") {{", service.name).unwrap();
let mut first_method = true;
for method in &service.methods {
if first_method { first_method = false; }
else { f.write_all(b"else ").unwrap(); }
writeln!(f, "if (__method == \"{}\") {{", method.name).unwrap();
if method.ret_stream {
writeln!(f, "auto __stream = std::make_shared<MRPCStream<{}>>(&__c, __id);",
field_ty_to_ty_str(method.ret.as_ref().unwrap(), false)).unwrap();
f.write_all(b"{ std::lock_guard guard{__streams_mutex}; __streams.emplace(&__c, __stream); }\n").unwrap();
}
for arg in &method.args {
let ty = field_ty_to_ty_str(&arg, false);
if arg.optional {
writeln!(f, "{0} {1} = json_get_opt<{2}>(__data, \"{1}\");", ty, arg.name, field_ty_to_ty_str(arg, true)).unwrap();
} else {
writeln!(f, "{0} {1} = __data.at(\"{1}\");", ty, arg.name).unwrap();
}
}
let args = method.args.iter()
.map(|arg| format!("std::move({})", arg.name))
.chain(method.ret_stream.then_some(String::from("std::move(__stream)")))
.collect::<Vec<_>>();
if method.ret.is_none() || method.ret_stream {
writeln!(f, "{}_{}({});", service.name, method.name, args.join(", ")).unwrap();
} else {
writeln!(f, "auto __ret = {}_{}({});", service.name, method.name, args.join(", ")).unwrap();
f.write_all(b"send_msg(__c, __id, __ret);\n").unwrap();
}
f.write_all(b"} ").unwrap();
}
f.write_all(b"else { throw std::exception{}; }\n} ").unwrap();
}
f.f.write_all(b"else { throw std::exception{}; }
} catch (const std::exception &_) {
std::cerr << \"Got invalid request \" << __id << \" for \" << __service << \"::\" << __method << std::endl;
}
}\n\n").unwrap();
}
pub fn gen(file_base_name: &std::path::PathBuf, rpc: &RPC) {
output_header(&mut IndentedWriter::new(std::fs::File::create(file_base_name.with_extension("h")).unwrap()), rpc);
output_cpp(
&mut IndentedWriter::new(std::fs::File::create(file_base_name.with_extension("cpp")).unwrap()),
file_base_name.with_extension("h").file_name().unwrap().to_string_lossy().to_string(),
rpc
);
}