chore: apply clang-format

.clang-format

@@ -0,0 +1,108 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:   
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Middle
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
+...
+

include/reflection/forward.h

@@ -20,8 +20,10 @@ template <typename T> class Proxy;
 template <typename O, typename I> struct TypeConversion;
 
 template <typename Func> using Cache = std::map<std::string_view, Func>;
-template <typename Obj> using Accessor = std::function<Object(Obj &, std::string)>;
-template <typename Obj> using Getter = std::function<Object(Obj const &, std::string)>;
+template <typename Obj>
+using Accessor = std::function<Object(Obj &, std::string)>;
+template <typename Obj>
+using Getter = std::function<Object(Obj const &, std::string)>;
 }
 
 #define reflect(object) reflection::Object(object, #object)

include/reflection/object.h

@@ -17,9 +17,9 @@
 namespace reflection {
 class Object {
 public:
-  template <typename T> Object(T const &data, std::string name = "this");
-  template <typename T> Object(T &data, std::string name = "this");
-  template <typename T> Object(T &&data, std::string name = "this");
+  template <typename T> Object(T const & data, std::string name = "this");
+  template <typename T> Object(T & data, std::string name = "this");
+  template <typename T> Object(T && data, std::string name = "this");
   template <typename T> Object(Proxy<T> data, std::string name = "this");
 
   Object own() const { return clone_(*this); }
@@ -28,13 +28,15 @@ public:
     return std::string_view(name_).substr(name_.rfind('.') + 1);
   }
   std::string_view path() const { return name_; }
-  char const *type() const { return type_.name(); }
-  
+  char const * type() const { return type_.name(); }
+
   template <typename T> bool is_a() const { return type_ == typeid(T); }
 
   template <typename T> operator T &() const & { return cast<T &>(); }
-  template <typename T> operator T const &() const & { return cast<T const &>(); }
-  template <typename T> operator T () && {
+  template <typename T> operator T const &() const & {
+    return cast<T const &>();
+  }
+  template <typename T> operator T() && {
     return is_a<T>() ? std::move(cast<T &>()) : cast<T const &>();
   }
 
@@ -42,13 +44,13 @@ public:
   Object get(std::string_view id) const & { return (this->*get_)(id); }
   Object get(std::string_view id) && { return (this->*get_)(id).own(); }
 
-  template <typename C, typename =
-        std::enable_if_t<std::is_constructible_v<std::string_view,
-                                                 decltype(*std::begin(std::declval<C>()))>>>
-  Object get(C const &container) const {
+  template <typename C,
+            typename = std::enable_if_t<std::is_constructible_v<
+                std::string_view, decltype(*std::begin(std::declval<C>()))>>>
+  Object get(C const & container) const {
     return get(*this, std::begin(container), std::end(container));
   }
-  
+
 private:
   template <typename It> static Object get(Object o, It it, It const end) {
     for (; it != end; ++it) {
@@ -56,7 +58,7 @@ private:
     }
     return o;
   }
-    
+
   template <typename T> T cast() const {
     // Why can we decay this away?
     using V = std::remove_const_t<std::remove_reference_t<T>>;
@@ -65,27 +67,26 @@ private:
     // 2) We guard against using mutable-reference on immutable Object here
     if (std::is_same_v<T, V &> && const_) { throw std::bad_cast(); }
     // 3) Proxy always contains mutable data
-    if (proxy_) {
-      return T(*std::static_pointer_cast<Proxy<V>>(data_));
-    }
+    if (proxy_) { return T(*std::static_pointer_cast<Proxy<V>>(data_)); }
     // 4) The const will be re-added by type coercion
     return *std::static_pointer_cast<V>(data_);
   }
 
   template <typename T> Object getter(std::string_view id) const;
   template <typename T> Object accessor(std::string_view id) const;
-  template <typename T> static Object deep(Object const &obj) {
+  template <typename T> static Object deep(Object const & obj) {
     return Object(obj.cast<T>(), obj.name_);
   }
 
 private:
-  std::type_index type_; // 
-  std::string name_; // The property name as a dot-separated path
-  bool proxy_{false}; // Are we using a proxy class to store non-trivial setter behavior
+  std::type_index type_; //
+  std::string name_;     // The property name as a dot-separated path
+  bool proxy_{
+      false}; // Are we using a proxy class to store non-trivial setter behavior
   bool const_; // Is the object immutable (const-ref or rvalue)
   std::shared_ptr<void> data_;
   Object (Object::*get_)(std::string_view) const;
-  Object (*clone_)(Object const &) = [](Object const &obj) { return obj; };
+  Object (*clone_)(Object const &) = [](Object const & obj) { return obj; };
 };
 }
 
@@ -93,27 +94,34 @@ private:
 
 namespace reflection {
 template <typename T> Object Object::getter(std::string_view id) const {
-  return Reflection<T>::getter(id)(cast<T const &>(), name_ + "." + std::string(id));
+  return Reflection<T>::getter(id)(cast<T const &>(),
+                                   name_ + "." + std::string(id));
 }
 
 template <typename T> Object Object::accessor(std::string_view id) const {
-  return Reflection<T>::accessor(id)(cast<T &>(), name_ + "." + std::string(id));
+  return Reflection<T>::accessor(id)(cast<T &>(),
+                                     name_ + "." + std::string(id));
 }
 
-template <typename T> Object::Object(T const &data, std::string name)
+template <typename T>
+Object::Object(T const & data, std::string name)
     : type_(typeid(T)), name_(std::move(name)), const_(true),
-      data_(const_cast<T *>(&data), [](auto*){}), get_(&Object::getter<T>) {}
+      data_(const_cast<T *>(&data), [](auto *) {}), get_(&Object::getter<T>) {}
 
-template <typename T> Object::Object(T &data, std::string name)
-    : type_(typeid(T)), name_(std::move(name)), const_(false),  data_(&data, [](auto*){}),
-      get_(&Object::accessor<T>) {}
+template <typename T>
+Object::Object(T & data, std::string name)
+    : type_(typeid(T)), name_(std::move(name)), const_(false),
+      data_(&data, [](auto *) {}), get_(&Object::accessor<T>) {}
 
-template <typename T> Object::Object(T &&data, std::string name)
+template <typename T>
+Object::Object(T && data, std::string name)
     : type_(typeid(T)), name_(std::move(name)), const_(true),
       data_(std::make_shared<T>(std::move(data))), get_(&Object::getter<T>),
       clone_(&Object::deep<T>) {}
 
-template <typename T> Object::Object(Proxy<T> data, std::string name)
+template <typename T>
+Object::Object(Proxy<T> data, std::string name)
     : type_(typeid(T)), name_(std::move(name)), proxy_(true), const_(false),
-      data_(std::make_shared<Proxy<T>>(std::move(data))), get_(&Object::getter<T>) {}
+      data_(std::make_shared<Proxy<T>>(std::move(data))),
+      get_(&Object::getter<T>) {}
 }

include/reflection/proxy.h

@@ -15,8 +15,9 @@
 namespace reflection {
 template <typename T> class Proxy {
 public:
-  template <typename O> Proxy(O &obj, T (O::*get)() const, void (O::*set)(T))
-      : data_((obj.*get)()), set_([&obj, set](auto &v) { (obj.*set)(v); }) {}
+  template <typename O>
+  Proxy(O & obj, T (O::*get)() const, void (O::*set)(T))
+      : data_((obj.*get)()), set_([&obj, set](auto & v) { (obj.*set)(v); }) {}
 
   ~Proxy() { set_(data_); }
 
@@ -24,7 +25,6 @@ public:
 
 private:
   T data_;
-  std::function<void(T const&)> set_;
+  std::function<void(T const &)> set_;
 };
 }
-

include/reflection/reflection.h

@@ -10,8 +10,12 @@
 #include "reflection/object.h"
 #include "reflection/proxy.h"
 
-#define REFLECTION(expr) [=](Obj &obj, std::string name) { return Object(expr, std::move(name)); }
-#define CONST_REFLECTION(expr) [=](Obj const &obj, std::string name) { return Object(expr, std::move(name)); }
+#define REFLECTION(expr)                                                       \
+  [=](Obj & obj, std::string name) { return Object(expr, std::move(name)); }
+#define CONST_REFLECTION(expr)                                                 \
+  [=](Obj const & obj, std::string name) {                                     \
+    return Object(expr, std::move(name));                                      \
+  }
 
 namespace reflection {
 
@@ -22,7 +26,7 @@ constexpr auto is_final_reflection =
 template <typename Obj, typename> class Reflection {
 public:
   operator bool() const { return true; }
-  
+
   static Getter<Obj> getter(std::string_view id) {
     if (auto it = const_members_.find(id); it != const_members_.end()) {
       return it->second;
@@ -38,21 +42,21 @@ public:
   }
 
   template <typename T, typename V>
-  Reflection &bind(std::string_view id, T (Obj::*get)() const, void (Obj::*set)(V)) {
+  Reflection & bind(std::string_view id, T (Obj::*get)() const,
+                    void (Obj::*set)(V)) {
     members_.emplace(id, REFLECTION(Proxy<T>(obj, get, set)));
     const_members_.emplace(id, CONST_REFLECTION((obj.*get)()));
     return *this;
   }
 
-  template <typename T>
-  Reflection &bind(std::string_view id, T Obj::*member) {
+  template <typename T> Reflection & bind(std::string_view id, T Obj::*member) {
     members_.emplace(id, REFLECTION(obj.*member));
     const_members_.emplace(id, CONST_REFLECTION(obj.*member));
     return *this;
   }
 
   template <typename R, typename T>
-  Reflection &bind(std::string_view id, T Obj::*member) {
+  Reflection & bind(std::string_view id, T Obj::*member) {
     TypeConversion<R, T> convert;
     members_.emplace(id, CONST_REFLECTION(convert(obj.*member)));
     const_members_.emplace(id, CONST_REFLECTION(convert(obj.*member)));
@@ -64,22 +68,27 @@ private:
   static Cache<Getter<Obj>> const_members_;
 };
 
-template <typename T> class Reflection<T, std::enable_if_t<is_final_reflection<T>>> {
+template <typename T>
+class Reflection<T, std::enable_if_t<is_final_reflection<T>>> {
 public:
-  static Getter<T> getter(std::string_view) { throw std::logic_error("unreflectable"); }
-  static Accessor<T> accessor(std::string_view) { throw std::logic_error("unreflectable"); }
+  static Getter<T> getter(std::string_view) {
+    throw std::logic_error("unreflectable");
+  }
+  static Accessor<T> accessor(std::string_view) {
+    throw std::logic_error("unreflectable");
+  }
 };
 
-template <typename T> class Reflection<T*> {
+template <typename T> class Reflection<T *> {
 public:
   static auto getter(std::string_view id) {
-    return [f = Reflection<T>::getter(id)](T const *ptr, std::string name) {
+    return [f = Reflection<T>::getter(id)](T const * ptr, std::string name) {
       return f(*ptr, std::move(name));
     };
   }
 
   static auto accessor(std::string_view id) {
-    return [f = Reflection<T>::accessor(id)](T *ptr, std::string name) {
+    return [f = Reflection<T>::accessor(id)](T * ptr, std::string name) {
       return f(*ptr, std::move(name));
     };
   }

test/object_test.cxx

@@ -19,7 +19,7 @@ using testing::NotNull;
 namespace {
 struct Example {
   int a;
-  
+
   int get_c() const { return a + 4; }
   void set_c(int c) { a = c - 4; }
 };
@@ -29,27 +29,27 @@ struct Compound {
 };
 
 bool _1 = Reflection<Example>()
-    .bind("a", &Example::a)
-    .bind("c", &Example::get_c, &Example::set_c);
+              .bind("a", &Example::a)
+              .bind("c", &Example::get_c, &Example::set_c);
 
 bool _2 = Reflection<Compound>().bind("ex", &Compound::ex);
 }
 
 TEST(ObjectTest, CanFetchData) {
   Example ex{.a = 1};
-  
+
   Object a = Object(ex).get("a");
-  
-  EXPECT_NO_THROW((void) int(a)) << a.type();
+
+  EXPECT_NO_THROW((void)int(a)) << a.type();
   EXPECT_THAT(int(a), 1);
 }
 
 TEST(ObjectTest, CanSetDataOnNonConst) {
   Example ex{.a = 1};
-  
+
   {
     Object a = Object(ex).get("a");
-    EXPECT_NO_THROW((void) static_cast<int &>(a)) << a.type();
+    EXPECT_NO_THROW((void)static_cast<int &>(a)) << a.type();
     static_cast<int &>(a) = 2;
   }
   EXPECT_THAT(ex.a, 2);
@@ -57,64 +57,64 @@ TEST(ObjectTest, CanSetDataOnNonConst) {
 
 TEST(ObjectTest, ThrowsWhenTryingToEditConst) {
   Example const ex{.a = 1};
-  
+
   Object a = Object(ex).get("a");
-  EXPECT_THROW((void) static_cast<int &>(a), std::bad_cast);
+  EXPECT_THROW((void)static_cast<int &>(a), std::bad_cast);
 }
 
 TEST(ObjectTest, ThrowsWhenTryingToEditMoved) {
   Object a = Object(Example{.a = 1}).get("a");
-  EXPECT_THROW((void) static_cast<int &>(a), std::bad_cast);
+  EXPECT_THROW((void)static_cast<int &>(a), std::bad_cast);
 }
 
 TEST(ObjectTest, ThrowsWhenPerformingTypeCoersion) {
   Example const ex{.a = 1};
-  
+
   Object a = Object(ex).get("a");
-  EXPECT_THROW((void) double(a), std::bad_cast);
+  EXPECT_THROW((void)double(a), std::bad_cast);
 }
 
 TEST(ObjectTest, CanFetchWithGetter) {
   Example ex{.a = 1};
-  
+
   Object c = Object(ex).get("c");
-  EXPECT_NO_THROW((void) int(c)) << c.type();
+  EXPECT_NO_THROW((void)int(c)) << c.type();
   EXPECT_THAT(int(c), Eq(5));
   static_cast<int &>(c) = 4;
 }
 
 TEST(ObjectTest, CanModifyWithSetter) {
   Example ex{.a = 1};
-  
+
   {
     Object c = Object(ex).get("c");
-    EXPECT_NO_THROW((void) static_cast<int &>(c)) << c.type();
+    EXPECT_NO_THROW((void)static_cast<int &>(c)) << c.type();
     static_cast<int &>(c) = 4;
     // Notice that the setter is scoped on the Object expiring
     EXPECT_THAT(ex.a, Eq(1));
   }
-  
+
   EXPECT_THAT(ex.a, Eq(0));
 }
 
 TEST(ObjectTest, ThrowsWhenUsingSetterOnConst) {
   Example const ex{.a = 1};
-  
+
   Object c = Object(ex).get("c");
-  EXPECT_THROW((void) static_cast<int &>(c), std::bad_cast);
+  EXPECT_THROW((void)static_cast<int &>(c), std::bad_cast);
 }
 
 TEST(ObjectTest, CanDive) {
   Compound cm{.ex = {.a = 2}};
-  
+
   Object a = Object(cm).get(std::vector{"ex", "a"});
-  EXPECT_NO_THROW((void) int(a));
+  EXPECT_NO_THROW((void)int(a));
   EXPECT_THAT(int(a), Eq(2));
 }
 
 TEST(ObjectTest, AttachesNameInfo) {
   Compound cm{.ex = {.a = 2}};
-  
+
   Object a = Object(cm).get(std::vector{"ex", "a"});
   EXPECT_THAT(a.path(), Eq("this.ex.a"));
   EXPECT_THAT(a.name(), Eq("a"));
@@ -122,7 +122,7 @@ TEST(ObjectTest, AttachesNameInfo) {
 
 TEST(ObjectTest, CanReflectVariableName) {
   Compound cm{.ex = {.a = 2}};
-  
+
   Object a = reflect(cm).get(std::vector{"ex", "a"});
   EXPECT_THAT(a.path(), Eq("cm.ex.a"));
   EXPECT_THAT(a.name(), Eq("a"));

test/reflection_test.cxx

@@ -14,9 +14,7 @@ struct Example {
   int b;
 };
 
-bool _ = Reflection<Example>()
-    .bind("a", &Example::a)
-    .bind("c", &Example::b);
+bool _ = Reflection<Example>().bind("a", &Example::a).bind("c", &Example::b);
 }
 
 TEST(ReflectionTest, AquiresGetter) {
@@ -45,37 +43,37 @@ TEST(ReflectionTest, UseOnStringThrows) {
   EXPECT_THROW(Reflection<std::string>::accessor("a"), std::logic_error);
 }
 
-//TEST(ReflectionTest, BindsParameterByName) {
-//  EXPECT_TRUE(reflection<example>::exists<int>("a"));
-//}
+// TEST(ReflectionTest, BindsParameterByName) {
+//   EXPECT_TRUE(reflection<example>::exists<int>("a"));
+// }
 //
-//TEST(ReflectionTest, CanRenameParameter) {
-//  EXPECT_FALSE(reflection<example>::exists<int>("b"));
-//  EXPECT_TRUE(reflection<example>::exists<int>("c"));
-//}
+// TEST(ReflectionTest, CanRenameParameter) {
+//   EXPECT_FALSE(reflection<example>::exists<int>("b"));
+//   EXPECT_TRUE(reflection<example>::exists<int>("c"));
+// }
 //
-//TEST(ReflectionTest, CanAccessMember) {
-//  auto p = reflection<example>::get_pointer<int>("a");
-//  EXPECT_THAT(p, NotNull());
-//  EXPECT_THAT(p, Eq(&example::a));
+// TEST(ReflectionTest, CanAccessMember) {
+//   auto p = reflection<example>::get_pointer<int>("a");
+//   EXPECT_THAT(p, NotNull());
+//   EXPECT_THAT(p, Eq(&example::a));
 //
-//  example ex = { 5, 6 };
-//  EXPECT_THAT(&(ex.*p), Eq(&ex.a));
-//  EXPECT_THAT(ex.*p, Eq(5));
-//}
+//   example ex = { 5, 6 };
+//   EXPECT_THAT(&(ex.*p), Eq(&ex.a));
+//   EXPECT_THAT(ex.*p, Eq(5));
+// }
 //
-//TEST(ReflectionTest, CanGetNameFromMemPtr) {
-//  EXPECT_THAT(reflection<example>::name(&example::a), Eq("a"));
-//  EXPECT_THAT(reflection<example>::name(&example::b), Eq("c"));
-//}
+// TEST(ReflectionTest, CanGetNameFromMemPtr) {
+//   EXPECT_THAT(reflection<example>::name(&example::a), Eq("a"));
+//   EXPECT_THAT(reflection<example>::name(&example::b), Eq("c"));
+// }
 //
-//TEST(ReflectionTest, CanGetNameFromThis) {
-//  example ex = { 5, 6 };
-//  EXPECT_THAT(reflection<example>::name(ex, ex.a), Eq("a"));
-//  EXPECT_THAT(reflection<example>::name(ex, ex.b), Eq("c"));
-//}
+// TEST(ReflectionTest, CanGetNameFromThis) {
+//   example ex = { 5, 6 };
+//   EXPECT_THAT(reflection<example>::name(ex, ex.a), Eq("a"));
+//   EXPECT_THAT(reflection<example>::name(ex, ex.b), Eq("c"));
+// }
 //
-//TEST(ReflectionTest, NameForMissingIsEmpty) {
-//  example ex = { 5, 6 };
-//  EXPECT_THAT(reflection<example>::name(ex, 5), Eq(""));
-//}
+// TEST(ReflectionTest, NameForMissingIsEmpty) {
+//   example ex = { 5, 6 };
+//   EXPECT_THAT(reflection<example>::name(ex, 5), Eq(""));
+// }