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/program_args/arguments.h

@@ -6,8 +6,7 @@
 
 namespace program {
 
-template <typename Impl>
-class Arguments {
+template <typename Impl> class Arguments {
 protected:
   struct Option;
   struct Positional;
@@ -17,11 +16,11 @@ public:
   Arguments() = default;
   Arguments(int argc, char const * const * const argv);
 
-  auto option(std::string const &name, std::string const &description = "");
-  auto option(std::string const &name, char abbrev,
-              std::string const &description = "");
-  auto argument(size_t index, std::string const &name,
-                std::string const &description = "");
+  auto option(std::string const & name, std::string const & description = "");
+  auto option(std::string const & name, char abbrev,
+              std::string const & description = "");
+  auto argument(size_t index, std::string const & name,
+                std::string const & description = "");
 
 private:
   void usage() const;
@@ -49,28 +48,26 @@ struct Arguments<Impl>::WithDefault {
   template <typename T> operator T() const { return impl ?: T(default_value); }
 };
 
-template <typename Impl>
-struct Arguments<Impl>::Option {
-  Arguments<Impl> *self;
+template <typename Impl> struct Arguments<Impl>::Option {
+  Arguments<Impl> * self;
   std::string name;
   char abbrev;
   std::string description;
 
-  template <typename T> auto operator=(T &&value);
+  template <typename T> auto operator=(T && value);
   template <typename T> operator T() const;
   bool primed() const;
   explicit operator bool() const;
 };
 
-template <typename Impl>
-struct Arguments<Impl>::Positional {
-  Arguments<Impl> *self;
+template <typename Impl> struct Arguments<Impl>::Positional {
+  Arguments<Impl> * self;
   size_t index;
   bool is_optional;
   std::string name;
   std::string description;
 
-  template <typename T> auto operator=(T &&value);
+  template <typename T> auto operator=(T && value);
   template <typename T> operator T() const;
   bool primed() const;
   explicit operator bool() const;
@@ -81,10 +78,10 @@ struct Arguments<Impl>::Positional {
 #include "arguments_impl.hpp"
 
 #define TYPED_MAIN(tname)                                                      \
-  int typed_main(tname const &args);                                           \
+  int typed_main(tname const & args);                                          \
   int main(int argc, char const * const * const argv) try {                    \
     return typed_main(tname(argc, argv));                                      \
-  } catch(program::ProgramArgumentsError const &pae) {                         \
+  } catch (program::ProgramArgumentsError const & pae) {                       \
     std::cerr << "Error in program argument handling: " << pae.what() << "\n"; \
   }                                                                            \
-  int typed_main(tname const &args)
+  int typed_main(tname const & args)

include/program_args/arguments_impl.hpp

@@ -14,25 +14,21 @@ Arguments<Impl>::Option::operator T() const {
   return (*this) ? convert<T>(self->options.at(name)) : T();
 }
 
-template <typename Impl>
-Arguments<Impl>::Option::operator bool() const {
+template <typename Impl> Arguments<Impl>::Option::operator bool() const {
   return primed() && self->options.count(name);
 }
 
 template <typename Impl>
 template <typename T>
-auto Arguments<Impl>::Option::operator=(T &&value) {
+auto Arguments<Impl>::Option::operator=(T && value) {
   return WithDefault<Option, T>{*this, std::forward<T>(value)};
 }
 
-template <typename Impl>
-bool Arguments<Impl>::Option::primed() const {
+template <typename Impl> bool Arguments<Impl>::Option::primed() const {
   if (self->primed_) { return true; }
   std::vector<std::string> aliases{"--" + name};
-  if (abbrev) {
-    aliases.emplace_back(std::string{'-', abbrev});
-  }
-  for (auto &alias : aliases) {
+  if (abbrev) { aliases.emplace_back(std::string{'-', abbrev}); }
+  for (auto & alias : aliases) {
     if (!self->option_name_mapping.emplace(alias, name).second) {
       throw ArgumentStructureError("Duplicate option string", alias);
     }
@@ -51,8 +47,7 @@ Arguments<Impl>::Positional::operator T() const {
   return (*this) ? convert<T>(self->arguments.at(index)) : T();
 }
 
-template <typename Impl>
-Arguments<Impl>::Positional::operator bool() const {
+template <typename Impl> Arguments<Impl>::Positional::operator bool() const {
   bool const good = primed();
   if (good && self->arguments.size() <= index) {
     throw IllegalPositionError("No argument provided", index);
@@ -62,13 +57,12 @@ Arguments<Impl>::Positional::operator bool() const {
 
 template <typename Impl>
 template <typename T>
-auto Arguments<Impl>::Positional::operator=(T &&value) {
+auto Arguments<Impl>::Positional::operator=(T && value) {
   is_optional = true;
   return WithDefault<Positional, T>{*this, std::forward<T>(value)};
 }
 
-template <typename Impl>
-bool Arguments<Impl>::Positional::primed() const {
+template <typename Impl> bool Arguments<Impl>::Positional::primed() const {
   if (self->primed_) { return true; }
   if (is_optional) {
     self->optional_from = std::min(self->optional_from, index);
@@ -90,7 +84,7 @@ namespace program {
 template <typename Impl>
 Arguments<Impl>::Arguments(int argc, char const * const * const argv) {
   Impl generator;
-  *this = static_cast<Arguments const&>(generator);
+  *this = static_cast<Arguments const &>(generator);
   if (argument_names.rbegin()->first != argument_names.size() - 1) {
     throw IllegalPositionError("Higher positional than number recorded",
                                argument_names.rbegin()->first);
@@ -104,11 +98,11 @@ Arguments<Impl>::Arguments(int argc, char const * const * const argv) {
       std::exit(0); // TODO: ???
     } else if (arg_equals("--")) {
       // TODO: Special arguments store for passthroughs
-      arguments.insert(arguments.end(), &argv[i+1], &argv[argc]);
+      arguments.insert(arguments.end(), &argv[i + 1], &argv[argc]);
       break;
     } else if (argv[i][0] == '-') {
       // TODO: Arity
-      options[option_name_mapping.at(argv[i])].emplace_back(argv[i+1]);
+      options[option_name_mapping.at(argv[i])].emplace_back(argv[i + 1]);
       ++i;
     } else {
       arguments.emplace_back(argv[i]);
@@ -116,40 +110,37 @@ Arguments<Impl>::Arguments(int argc, char const * const * const argv) {
   }
 }
 
-template <typename Impl>
-void Arguments<Impl>::usage() const {
+template <typename Impl> void Arguments<Impl>::usage() const {
   std::cout << program << " [options...]";
-  for (auto &[index, name] : argument_names) {
-    std::cout << " " << (index == optional_from ? "[" : "")  << name;
-  }
-  if (optional_from != std::numeric_limits<size_t>::max()) {
-    std::cout << "]";
+  for (auto & [index, name] : argument_names) {
+    std::cout << " " << (index == optional_from ? "[" : "") << name;
   }
+  if (optional_from != std::numeric_limits<size_t>::max()) { std::cout << "]"; }
   std::cout << "\nPositional Arguments:\n";
-  for (auto &[name, desc] : positional_descriptions) {
+  for (auto & [name, desc] : positional_descriptions) {
     std::cout << "  " << name << ": " << desc << "\n";
   }
   std::cout << "Options:\n";
-  for (auto &[opt, desc] : option_descriptions) {
+  for (auto & [opt, desc] : option_descriptions) {
     std::cout << "  " << opt << ": " << desc << "\n";
   }
 }
 
 template <typename Impl>
-auto Arguments<Impl>::option(std::string const &name,
-                             std::string const &description) {
+auto Arguments<Impl>::option(std::string const & name,
+                             std::string const & description) {
   return Option{this, name, 0, description};
 }
 
 template <typename Impl>
-auto Arguments<Impl>::option(std::string const &name, char abbrev,
-                             std::string const &description) {
+auto Arguments<Impl>::option(std::string const & name, char abbrev,
+                             std::string const & description) {
   return Option{this, name, abbrev, description};
 }
 
 template <typename Impl>
-auto Arguments<Impl>::argument(size_t index, std::string const &name,
-                               std::string const &description) {
+auto Arguments<Impl>::argument(size_t index, std::string const & name,
+                               std::string const & description) {
   return Positional{this, index, false, name, description};
 }
 

include/program_args/exception.h

@@ -10,13 +10,13 @@ class ProgramArgumentsError : public std::logic_error {
 
 class ArgumentStructureError : public ProgramArgumentsError {
 public:
-  ArgumentStructureError(std::string const &desc, std::string const &name)
+  ArgumentStructureError(std::string const & desc, std::string const & name)
       : ProgramArgumentsError(desc + " for argument " + name) {}
 };
 
 class IllegalPositionError : public ProgramArgumentsError {
 public:
-  IllegalPositionError(std::string const &desc, size_t index)
+  IllegalPositionError(std::string const & desc, size_t index)
       : ProgramArgumentsError(desc + " at index " + std::to_string(index)) {}
 };
 

include/program_args/utilities.h

@@ -5,8 +5,8 @@
 #include <vector>
 
 namespace program {
-inline std::string join(std::string const &tok,
-                        std::vector<std::string> const &data) {
+inline std::string join(std::string const & tok,
+                        std::vector<std::string> const & data) {
   std::string accum = data.empty() ? "" : data.front();
   for (size_t i = 1; i < data.size(); ++i) {
     accum += tok;
@@ -22,26 +22,26 @@ template <typename T, typename D> T convert(D const & data) {
 }
 
 template <typename T>
-struct conversion_helper<T, std::enable_if_t<std::is_convertible_v<std::string, T>>> {
-  T operator()(std::string const &str) const { return T(str); }
-  T operator()(std::vector<std::string> const &data) const {
+struct conversion_helper<
+    T, std::enable_if_t<std::is_convertible_v<std::string, T>>> {
+  T operator()(std::string const & str) const { return T(str); }
+  T operator()(std::vector<std::string> const & data) const {
     return operator()(data.front());
   }
 };
 
-template <>
-struct conversion_helper<int> {
-  int operator()(std::string const &str) const { return std::stoi(str); }
-  int operator()(std::vector<std::string> const &data) const {
+template <> struct conversion_helper<int> {
+  int operator()(std::string const & str) const { return std::stoi(str); }
+  int operator()(std::vector<std::string> const & data) const {
     return operator()(data.front());
   }
 };
 
 template <typename T>
 struct conversion_helper<std::vector<T>> : conversion_helper<T> {
-  std::vector<T> operator()(std::vector<std::string> const &data) const {
+  std::vector<T> operator()(std::vector<std::string> const & data) const {
     std::vector<T> rval;
-    for (auto &str : data) {
+    for (auto & str : data) {
       rval.emplace_back((*this)(str));
     }
     return rval;