From 04dab0bb9591ce63698e1b3191a3be5364f20dcf Mon Sep 17 00:00:00 2001
From: Claudius Holeksa <mail@keldu.de>
Date: Sun, 5 Dec 2021 16:17:23 +0100
Subject: [PATCH] executed format

---
 schema/kelgin_schema_compile      |  8 ------
 source/kelgin/async.h             |  4 +--
 source/kelgin/async.tmpl.h        |  2 +-
 source/kelgin/common.h            |  4 +--
 source/kelgin/json.h              |  4 ++-
 source/kelgin/message.h           | 46 +++++++++++++++++--------------
 source/kelgin/message_container.h | 40 ++++++++++++++-------------
 source/kelgin/schema.h            | 19 ++++---------
 source/kelgin/string_literal.h    |  4 +--
 9 files changed, 62 insertions(+), 69 deletions(-)
 delete mode 100755 schema/kelgin_schema_compile

diff --git a/schema/kelgin_schema_compile b/schema/kelgin_schema_compile
deleted file mode 100755
index 4aedca6..0000000
--- a/schema/kelgin_schema_compile
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-
-
-
-
-
-if __name__ == "__main__":
-    print("Schema compiler: Not working");
diff --git a/source/kelgin/async.h b/source/kelgin/async.h
index 2e2cf47..af69cfc 100644
--- a/source/kelgin/async.h
+++ b/source/kelgin/async.h
@@ -183,7 +183,7 @@ public:
 	 * Useful for resource lifetime control.
 	 */
 	template <typename... Args>
-	[[nodiscard]] Conveyor<T> attach(Args &&... args);
+	[[nodiscard]] Conveyor<T> attach(Args &&...args);
 
 	/** @todo implement
 	 * This method limits the total amount of passed elements
@@ -601,7 +601,7 @@ private:
 	std::tuple<Args...> attached_data;
 
 public:
-	AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&... args)
+	AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&...args)
 		: AttachConveyorNodeBase(std::move(dep)), attached_data{
 													  std::move(args...)} {}
 };
diff --git a/source/kelgin/async.tmpl.h b/source/kelgin/async.tmpl.h
index 292a38d..67312e5 100644
--- a/source/kelgin/async.tmpl.h
+++ b/source/kelgin/async.tmpl.h
@@ -73,7 +73,7 @@ template <typename T> Conveyor<T> Conveyor<T>::buffer(size_t size) {
 
 template <typename T>
 template <typename... Args>
-Conveyor<T> Conveyor<T>::attach(Args &&... args) {
+Conveyor<T> Conveyor<T>::attach(Args &&...args) {
 	Own<AttachConveyorNode<Args...>> attach_node =
 		heap<AttachConveyorNode<Args...>>(std::move(node), std::move(args...));
 	return Conveyor<T>{std::move(attach_node), storage};
diff --git a/source/kelgin/common.h b/source/kelgin/common.h
index 58d4d2b..3939076 100644
--- a/source/kelgin/common.h
+++ b/source/kelgin/common.h
@@ -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, 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)...));
 }
 
-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)...);
 }
 
diff --git a/source/kelgin/json.h b/source/kelgin/json.h
index edb5b6f..189a491 100644
--- a/source/kelgin/json.h
+++ b/source/kelgin/json.h
@@ -835,7 +835,9 @@ Error JsonCodec::decodeValue(Own<DynamicMessage> &message, Buffer &buffer,
 		decodeNull(buffer);
 		message = std::move(msg_null);
 	} break;
-	default: { return criticalError("Cannot identify next JSON value"); }
+	default: {
+		return criticalError("Cannot identify next JSON value");
+	}
 	}
 
 	skipWhitespace(buffer);
diff --git a/source/kelgin/message.h b/source/kelgin/message.h
index 65330e1..2f2bb24 100644
--- a/source/kelgin/message.h
+++ b/source/kelgin/message.h
@@ -2,9 +2,9 @@
 
 #include <cstdint>
 #include <tuple>
+#include <type_traits>
 #include <variant>
 #include <vector>
-#include <type_traits>
 
 #include "common.h"
 
@@ -29,21 +29,21 @@ public:
 };
 /*
  * Representing all message types
- * Description which type to use happens through the use of the schema classes in schema.h
- * The message classes are a container class which either contains singular types or has
- * some form of encoding in a buffer present
+ * Description which type to use happens through the use of the schema classes
+ * in schema.h The message classes are a container class which either contains
+ * singular types or has some form of encoding in a buffer present
  */
 
 template <class... V, StringLiteral... Keys, class Container>
 class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
 	: public MessageBase {
 private:
-	using SchemaType = schema::Struct<schema::NamedMember<V,Keys>...>;
-	using MessageType =
-		Message<SchemaType, Container>;
+	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
+	using MessageType = Message<SchemaType, 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 Reader;
@@ -59,13 +59,15 @@ public:
 
 		Reader asReader() { return Reader{MessageType & message}; }
 
-		template<size_t i>
-		typename Container::Element<i>::Builder init(){
-			return typename Container::Element<i>::Builder{message.container.get<i>()};
+		template <size_t i> typename Container::Element<i>::Builder init() {
+			return typename Container::Element<i>::Builder{
+				message.container.get<i>()};
 		}
 
-		template<StringLiteral Literal> typename Container::Element<i>::Builder init(){
-			constexpr size_t i = MessageParameterPackIndex<Literal, Keys...>::Value;
+		template <StringLiteral Literal>
+		typename Container::Element<i>::Builder init() {
+			constexpr size_t i =
+				MessageParameterPackIndex<Literal, Keys...>::Value;
 
 			return init<i>();
 		}
@@ -80,25 +82,27 @@ public:
 
 		Builder asBuilder() { return Builder{MessageType & message}; }
 
-		template<size_t i>
-		typename Container::Element<i>::Reader get(){
-			return typename Container::Element<i>::Reader{message.container.get<i>()};
+		template <size_t i> typename Container::Element<i>::Reader get() {
+			return typename Container::Element<i>::Reader{
+				message.container.get<i>()};
 		}
 
-		template<StringLiteral Literal> typename Container::Element<i>::Reader get(){
-			constexpr size_t i = MessageParameterPackIndex<Literal, Keys...>::Value;
+		template <StringLiteral Literal>
+		typename Container::Element<i>::Reader get() {
+			constexpr size_t i =
+				MessageParameterPackIndex<Literal, Keys...>::Value;
 
 			return get<i>();
 		}
 	};
 };
 
-template<class T, size_t N, class Container>
-class Message<schema::Primitive<T,N>, Container> final : public MessageBase {
+template <class T, size_t N, class Container>
+class Message<schema::Primitive<T, N>, Container> final : public MessageBase {
 private:
 	Container container;
-public:
 
+public:
 };
 
 class MessageReader {
diff --git a/source/kelgin/message_container.h b/source/kelgin/message_container.h
index f6a2b73..fd2b53c 100644
--- a/source/kelgin/message_container.h
+++ b/source/kelgin/message_container.h
@@ -3,44 +3,46 @@
 #include "schema.h"
 
 namespace gin {
-template<class T>
-class MessageContainer;
+template <class T> class MessageContainer;
 
 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;
 };
 
-template <size_t N, class TN, class... T> struct MessageParameterPackType <N, TN, T...> {
-	using Type = typename MessageParameterPackType<N-1, T...>::Type;
+template <size_t N, class TN, class... T>
+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;
 };
 
-template<class T, class TL0, class... TL> struct MessageParameterPackIndex<T, TL0, TL...> {
-	static constexpr size_t Value = 1u + MessageParameterPackIndex<T, TL...>::Value;
+template <class T, class TL0, class... TL>
+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:
 	using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
 	ValueType values;
+
 public:
-	using SchemaType = schema::Struct<schema::NamedMember<V,K>...>;
+	using SchemaType = schema::Struct<schema::NamedMember<V, K>...>;
 
-	template<size_t i>
-	using Element = MessageParameterPackType<N, Message<V,MessageContainer<V>>...>;
+	template <size_t i>
+	using Element =
+		MessageParameterPackType<N, Message<V, MessageContainer<V>>...>;
 
-	template<size_t i>
-	Element<i>& get(){
-		return std::get<i>(values);
-	}
+	template <size_t i> Element<i> &get() { return std::get<i>(values); }
 };
-}
+} // namespace gin
diff --git a/source/kelgin/schema.h b/source/kelgin/schema.h
index 897b3b7..559c991 100644
--- a/source/kelgin/schema.h
+++ b/source/kelgin/schema.h
@@ -23,19 +23,12 @@ struct SignedIntegral {};
 struct UnsignedIntegral {};
 struct FloatingPoint {};
 
-template<class T, size_t N>
-struct Primitive {
-	static_assert(
-		(
-			(std::is_same_v<T, SignedIntegral> || std::is_same_v<T,UnsignedIntegral>) &&
-			(N == 1 || N == 2 || N == 4 || N == 8)
-		)||
-		(
-			std::is_same_v<T,FloatingPoint> &&
-			(N==4 || N == 8)
-		),
-		"Primitive Type is not supported"
-	);
+template <class T, size_t N> struct Primitive {
+	static_assert(((std::is_same_v<T, SignedIntegral> ||
+					std::is_same_v<T, UnsignedIntegral>)&&(N == 1 || N == 2 ||
+														   N == 4 || N == 8)) ||
+					  (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
+				  "Primitive Type is not supported");
 };
 
 using Int8 = Primitive<SignedIntegral, 1>;
diff --git a/source/kelgin/string_literal.h b/source/kelgin/string_literal.h
index e017ca6..2979ce2 100644
--- a/source/kelgin/string_literal.h
+++ b/source/kelgin/string_literal.h
@@ -12,7 +12,7 @@ namespace gin {
 template <template CharT, size_t N> class StringLiteral {
 public:
 	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];
 		}
 	}
@@ -26,6 +26,6 @@ public:
 
 template <typename T, T... Chars>
 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