Style updates

examples/subcom_in_files/main.cpp

@@ -4,13 +4,13 @@
 
 #include "subcommand_a.hpp"
 
-int main( int argc, char** argv ) {
+int main(int argc, char **argv) {
     CLI::App app{"..."};
 
     // Call the setup functions for the subcommands.
-    // They are kept alive by a shared pointer in the 
+    // They are kept alive by a shared pointer in the
     // lambda function held by CLI11
-    setup_subcommand_a( app );
+    setup_subcommand_a(app);
 
     // Make sure we get at least one subcommand
     app.require_subcommand();

examples/subcom_in_files/subcommand_a.cpp

@@ -8,20 +8,18 @@
 /// The variables of the struct are bound to the CLI options.
 /// We use a shared ptr so that the addresses of the variables remain for binding,
 /// You could return the shared pointer if you wanted to access the values in main.
-void setup_subcommand_a( CLI::App& app ) {
+void setup_subcommand_a(CLI::App &app) {
     // Create the option and subcommand objects.
     auto opt = std::make_shared<SubcommandAOptions>();
-    auto sub = app.add_subcommand( "subcommand_a", "performs subcommand a", true );
+    auto sub = app.add_subcommand("subcommand_a", "performs subcommand a", true);
 
     // Add options to sub, binding them to opt.
     sub->add_option("-f,--file", opt->file, "File name")->required();
     sub->add_flag("--with-foo", opt->with_foo, "Counter");
 
     // Set the run function as callback to be called when this subcommand is issued.
-    sub->set_callback([opt]() {
-        run_subcommand_a( *opt );
-    });
-    
+    sub->set_callback([opt]() { run_subcommand_a(*opt); });
+
     // Note: In C++14, you could make a unique pointer, then pass it into the lambda function via
     // a move. That's slightly more elegant, but you won't be able to see the runtime difference
     // in skipping one mutex check for shared_ptr.
@@ -30,11 +28,10 @@ void setup_subcommand_a( CLI::App& app ) {
 /// The function that runs our code.
 /// This could also simply be in the callback lambda itself,
 /// but having a separate function is cleaner.
-void run_subcommand_a( SubcommandAOptions const& opt )
-{
+void run_subcommand_a(SubcommandAOptions const &opt) {
     // Do stuff...
     std::cout << "Working on file: " << opt.file << std::endl;
-    if( opt.with_foo ) {
+    if(opt.with_foo) {
         std::cout << "Using foo!" << std::endl;
     }
 }

examples/subcom_in_files/subcommand_a.hpp

@@ -9,12 +9,12 @@
 /// Collection of all options of Subcommand A.
 struct SubcommandAOptions {
     std::string file;
-    bool        with_foo;
+    bool with_foo;
 };
 
 // We could manually make a few variables and use shared pointers for each; this
-// is just done this way to be nicely organized 
+// is just done this way to be nicely organized
 
 // Function declarations.
-void setup_subcommand_a( CLI::App& app );
-void run_subcommand_a( SubcommandAOptions const& opt );
+void setup_subcommand_a(CLI::App &app);
+void run_subcommand_a(SubcommandAOptions const &opt);

include/CLI/App.hpp

@@ -45,8 +45,8 @@ using App_p = std::unique_ptr<App>;
 
 /// Creates a command line program, with very few defaults.
 /** To use, create a new `Program()` instance with `argc`, `argv`, and a help description. The templated
-*  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
-* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+ *  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+ * program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
 class App {
     friend Option;
     friend detail::AppFriend;