forstio
/
forstio
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

executed format

This commit is contained in:
Claudius Holeksa 2021-12-05 16:17:23 +01:00
parent 7dbbfc1d7f
commit 04dab0bb95
9 changed files with 62 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
schema/kelgin_schema_compile
View File

@ -1,8 +0,0 @@
#!/usr/bin/env python3
if __name__ == "__main__":
print("Schema compiler: Not working");

4
source/kelgin/async.h
View File

@ -183,7 +183,7 @@ public:
* Useful for resource lifetime control. * Useful for resource lifetime control.
*/ */
template <typename... Args> template <typename... Args>
[[nodiscard]] Conveyor<T> attach(Args &&... args); [[nodiscard]] Conveyor<T> attach(Args &&...args);
/** @todo implement /** @todo implement
* This method limits the total amount of passed elements * This method limits the total amount of passed elements
@ -601,7 +601,7 @@ private:
std::tuple<Args...> attached_data; std::tuple<Args...> attached_data;
public: public:
AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&... args) AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&...args)
: AttachConveyorNodeBase(std::move(dep)), attached_data{ : AttachConveyorNodeBase(std::move(dep)), attached_data{
std::move(args...)} {} std::move(args...)} {}
}; };

2
source/kelgin/async.tmpl.h
View File

@ -73,7 +73,7 @@ template <typename T> Conveyor<T> Conveyor<T>::buffer(size_t size) {
template <typename T> template <typename T>
template <typename... Args> template <typename... Args>
Conveyor<T> Conveyor<T>::attach(Args &&... args) { Conveyor<T> Conveyor<T>::attach(Args &&...args) {
Own<AttachConveyorNode<Args...>> attach_node = Own<AttachConveyorNode<Args...>> attach_node =
heap<AttachConveyorNode<Args...>>(std::move(node), std::move(args...)); heap<AttachConveyorNode<Args...>>(std::move(node), std::move(args...));
return Conveyor<T>{std::move(attach_node), storage}; return Conveyor<T>{std::move(attach_node), storage};

4
source/kelgin/common.h
View File

@ -39,11 +39,11 @@ template <typename T> using Our = std::shared_ptr<T>;
template <typename T> using Lent = std::weak_ptr<T>; template <typename T> using Lent = std::weak_ptr<T>;
template <typename T, class... Args> Own<T> heap(Args &&... args) { template <typename T, class... Args> Own<T> heap(Args &&...args) {
return Own<T>(new T(std::forward<Args>(args)...)); return Own<T>(new T(std::forward<Args>(args)...));
} }
template <typename T, class... Args> Our<T> share(Args &&... args) { template <typename T, class... Args> Our<T> share(Args &&...args) {
return std::make_shared<T>(std::forward<Args>(args)...); return std::make_shared<T>(std::forward<Args>(args)...);
} }

4
source/kelgin/json.h
View File

@ -835,7 +835,9 @@ Error JsonCodec::decodeValue(Own<DynamicMessage> &message, Buffer &buffer,
decodeNull(buffer); decodeNull(buffer);
message = std::move(msg_null); message = std::move(msg_null);
} break; } break;
default: { return criticalError("Cannot identify next JSON value"); } default: {
return criticalError("Cannot identify next JSON value");
}
} }
skipWhitespace(buffer); skipWhitespace(buffer);

46
source/kelgin/message.h
View File

@ -2,9 +2,9 @@
#include <cstdint> #include <cstdint>
#include <tuple> #include <tuple>
#include <type_traits>
#include <variant> #include <variant>
#include <vector> #include <vector>
#include <type_traits>
#include "common.h" #include "common.h"
@ -29,21 +29,21 @@ public:
}; };
/* /*
* Representing all message types * Representing all message types
* Description which type to use happens through the use of the schema classes in schema.h * Description which type to use happens through the use of the schema classes
* The message classes are a container class which either contains singular types or has * in schema.h The message classes are a container class which either contains
* some form of encoding in a buffer present * singular types or has some form of encoding in a buffer present
*/ */
template <class... V, StringLiteral... Keys, class Container> template <class... V, StringLiteral... Keys, class Container>
class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
: public MessageBase { : public MessageBase {
private: private:
using SchemaType = schema::Struct<schema::NamedMember<V,Keys>...>; using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
using MessageType = using MessageType = Message<SchemaType, Container>;
Message<SchemaType, Container>;
Container container; Container container;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>, "Container should have same Schema as Message"); static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same Schema as Message");
friend class Builder; friend class Builder;
friend class Reader; friend class Reader;
@ -59,13 +59,15 @@ public:
Reader asReader() { return Reader{MessageType & message}; } Reader asReader() { return Reader{MessageType & message}; }
template<size_t i> template <size_t i> typename Container::Element<i>::Builder init() {
typename Container::Element<i>::Builder init(){ return typename Container::Element<i>::Builder{
return typename Container::Element<i>::Builder{message.container.get<i>()}; message.container.get<i>()};
} }
template<StringLiteral Literal> typename Container::Element<i>::Builder init(){ template <StringLiteral Literal>
constexpr size_t i = MessageParameterPackIndex<Literal, Keys...>::Value; typename Container::Element<i>::Builder init() {
constexpr size_t i =
MessageParameterPackIndex<Literal, Keys...>::Value;
return init<i>(); return init<i>();
} }
@ -80,25 +82,27 @@ public:
Builder asBuilder() { return Builder{MessageType & message}; } Builder asBuilder() { return Builder{MessageType & message}; }
template<size_t i> template <size_t i> typename Container::Element<i>::Reader get() {
typename Container::Element<i>::Reader get(){ return typename Container::Element<i>::Reader{
return typename Container::Element<i>::Reader{message.container.get<i>()}; message.container.get<i>()};
} }
template<StringLiteral Literal> typename Container::Element<i>::Reader get(){ template <StringLiteral Literal>
constexpr size_t i = MessageParameterPackIndex<Literal, Keys...>::Value; typename Container::Element<i>::Reader get() {
constexpr size_t i =
MessageParameterPackIndex<Literal, Keys...>::Value;
return get<i>(); return get<i>();
} }
}; };
}; };
template<class T, size_t N, class Container> template <class T, size_t N, class Container>
class Message<schema::Primitive<T,N>, Container> final : public MessageBase { class Message<schema::Primitive<T, N>, Container> final : public MessageBase {
private: private:
Container container; Container container;
public:
public:
}; };
class MessageReader { class MessageReader {

40
source/kelgin/message_container.h
View File

@ -3,44 +3,46 @@
#include "schema.h" #include "schema.h"
namespace gin { namespace gin {
template<class T> template <class T> class MessageContainer;
class MessageContainer;
template <class T, class Container> class Message; template <class T, class Container> class Message;
template <size_t N, class... T> struct MessageParameterPackType ; template <size_t N, class... T> struct MessageParameterPackType;
template <class TN, class... T> struct MessageParameterPackType <0, TN, T...> { template <class TN, class... T> struct MessageParameterPackType<0, TN, T...> {
using Type = T; using Type = T;
}; };
template <size_t N, class TN, class... T> struct MessageParameterPackType <N, TN, T...> { template <size_t N, class TN, class... T>
using Type = typename MessageParameterPackType<N-1, T...>::Type; struct MessageParameterPackType<N, TN, T...> {
using Type = typename MessageParameterPackType<N - 1, T...>::Type;
}; };
template<class T, class... TL> struct MessageParameterPackIndex; template <class T, class... TL> struct MessageParameterPackIndex;
template<class T, class... TL> struct MessageParameterPackIndex<T,T, TL...> { template <class T, class... TL> struct MessageParameterPackIndex<T, T, TL...> {
static constexpr size_t Value = 0u; static constexpr size_t Value = 0u;
}; };
template<class T, class TL0, class... TL> struct MessageParameterPackIndex<T, TL0, TL...> { template <class T, class TL0, class... TL>
static constexpr size_t Value = 1u + MessageParameterPackIndex<T, TL...>::Value; struct MessageParameterPackIndex<T, TL0, TL...> {
static constexpr size_t Value =
1u + MessageParameterPackIndex<T, TL...>::Value;
}; };
template<class... V, class... K> class MessageContainer<schema::Struct<schema::NamedMember<V,K>...>> { template <class... V, class... K>
class MessageContainer<schema::Struct<schema::NamedMember<V, K>...>> {
private: private:
using ValueType = std::tuple<Message<V, MessageContainer<V>>...>; using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
ValueType values; ValueType values;
public: public:
using SchemaType = schema::Struct<schema::NamedMember<V,K>...>; using SchemaType = schema::Struct<schema::NamedMember<V, K>...>;
template<size_t i> template <size_t i>
using Element = MessageParameterPackType<N, Message<V,MessageContainer<V>>...>; using Element =
MessageParameterPackType<N, Message<V, MessageContainer<V>>...>;
template<size_t i> template <size_t i> Element<i> &get() { return std::get<i>(values); }
Element<i>& get(){
return std::get<i>(values);
}
}; };
} } // namespace gin

19
source/kelgin/schema.h
View File

@ -23,19 +23,12 @@ struct SignedIntegral {};
struct UnsignedIntegral {}; struct UnsignedIntegral {};
struct FloatingPoint {}; struct FloatingPoint {};
template<class T, size_t N> template <class T, size_t N> struct Primitive {
struct Primitive { static_assert(((std::is_same_v<T, SignedIntegral> ||
static_assert( std::is_same_v<T, UnsignedIntegral>)&&(N == 1 || N == 2 ||
( N == 4 || N == 8)) ||
(std::is_same_v<T, SignedIntegral> || std::is_same_v<T,UnsignedIntegral>) && (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
(N == 1 || N == 2 || N == 4 || N == 8) "Primitive Type is not supported");
)||
(
std::is_same_v<T,FloatingPoint> &&
(N==4 || N == 8)
),
"Primitive Type is not supported"
);
}; };
using Int8 = Primitive<SignedIntegral, 1>; using Int8 = Primitive<SignedIntegral, 1>;

4
source/kelgin/string_literal.h
View File

@ -12,7 +12,7 @@ namespace gin {
template <template CharT, size_t N> class StringLiteral { template <template CharT, size_t N> class StringLiteral {
public: public:
constexpr StringLiteral(const CharT (&input)[N]) noexcept { constexpr StringLiteral(const CharT (&input)[N]) noexcept {
for(size_t i = 0; i < N ; ++i){ for (size_t i = 0; i < N; ++i) {
data[i] = input[i]; data[i] = input[i];
} }
} }
@ -26,6 +26,6 @@ public:
template <typename T, T... Chars> template <typename T, T... Chars>
constexpr gin::StringLiteral<T, sizeof...(Chars)> operator""_key() { constexpr gin::StringLiteral<T, sizeof...(Chars)> operator""_key() {
return gin::StringLiteral<T,sizeof...(Chars)+1u>{Chars..., '\0'}; return gin::StringLiteral<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
} }
} // namespace gin } // namespace gin