Formatting

src/driver/argument_parser.hpp

@@ -89,9 +89,7 @@ struct argument_parser
 
     static auto nargs(unsigned n = 1)
     {
-        return [=](auto&&, auto& arg) {
-            arg.nargs = n;
-        };
+        return [=](auto&&, auto& arg) { arg.nargs = n; };
     }
 
     template <class F>
@@ -135,7 +133,7 @@ struct argument_parser
             {
                 std::cout << std::endl;
                 std::string prefix = "    ";
-                if (arg.flags.empty())
+                if(arg.flags.empty())
                 {
                     std::cout << prefix;
                     std::cout << arg.metavar;
@@ -185,16 +183,14 @@ struct argument_parser
         std::unordered_map<std::string, unsigned> keywords;
         for(auto&& arg : arguments)
         {
-            for(auto&& flag:arg.flags)
+            for(auto&& flag : arg.flags)
                 keywords[flag] = arg.nargs + 1;
         }
-        auto arg_map = generic_parse(args, [&](std::string x) { 
-            return keywords[x]; 
-        });
+        auto arg_map = generic_parse(args, [&](std::string x) { return keywords[x]; });
         for(auto&& arg : arguments)
         {
             auto flags = arg.flags;
-            if (flags.empty())
+            if(flags.empty())
                 flags = {""};
             for(auto&& flag : arg.flags)
             {
@@ -223,18 +219,17 @@ struct argument_parser
             {
                 flag = x;
                 result[flag]; // Ensure the flag exists
-                if (k == 1)
+                if(k == 1)
                     flag = "";
-                else if (k == 2)
+                else if(k == 2)
                     clear = true;
                 else
                     clear = false;
-
             }
             else
             {
                 result[flag].push_back(x);
-                if (clear)
+                if(clear)
                     flag = "";
                 clear = false;
             }

src/driver/command.hpp

@@ -26,15 +26,15 @@ std::string command_name()
     return name.substr(name.rfind("::") + 2);
 }
 
-template<class T>
-void run_command(std::vector<std::string> args, bool add_help=false)
+template <class T>
+void run_command(std::vector<std::string> args, bool add_help = false)
 {
     T x;
     argument_parser ap;
-    if (add_help)
+    if(add_help)
         ap.add(nullptr, {"-h", "--help"}, ap.help("Show help"), ap.show_help());
     x.parse(ap);
-    if (ap.parse(args))
+    if(ap.parse(args))
         return;
     x.run();
 }
@@ -43,9 +43,7 @@ template <class T>
 int auto_register_command()
 {
     auto& m              = get_commands();
-    m[command_name<T>()] = [](std::vector<std::string> args) {
-        run_command<T>(args, true);
-    };
+    m[command_name<T>()] = [](std::vector<std::string> args) { run_command<T>(args, true); };
     return 0;
 }
 

src/driver/main.cpp

@@ -21,22 +21,23 @@ struct loader
         ap.add(type, {"--onnx"}, ap.help("Load as onnx"), ap.set_value("onnx"));
         ap.add(type, {"--tf"}, ap.help("Load as tensorflow"), ap.set_value("tf"));
         ap.add(is_nhwc, {"--nhwc"}, ap.help("Treat tensorflow format as nhwc"), ap.set_value(true));
-        ap.add(is_nhwc, {"--nchw"}, ap.help("Treat tensorflow format as nchw"), ap.set_value(false));
+        ap.add(
+            is_nhwc, {"--nchw"}, ap.help("Treat tensorflow format as nchw"), ap.set_value(false));
     }
 
     program load()
     {
         program p;
-        if (type.empty())
+        if(type.empty())
         {
-            if (ends_with(file, ".onnx"))
+            if(ends_with(file, ".onnx"))
                 type = "onnx";
             else
                 type = "tf";
         }
-        if (type == "onnx")
+        if(type == "onnx")
             p = parse_onnx(file);
-        else if (type == "tf")
+        else if(type == "tf")
             p = parse_tf(file, is_nhwc);
         return p;
     }
@@ -45,10 +46,7 @@ struct loader
 struct read : command<read>
 {
     loader l;
-    void parse(argument_parser& ap)
-    {
-        l.parse(ap);
-    }
+    void parse(argument_parser& ap) { l.parse(ap); }
 
     void run()
     {

src/include/migraphx/requires.hpp

@@ -24,8 +24,9 @@ using bool_c = std::integral_constant<bool, B>;
 #define MIGRAPHX_REQUIRES(...) class = void
 #else
 #define MIGRAPHX_REQUIRES(...)                                                                 \
-bool MIGRAPHX_REQUIRES_VAR()=true, \
-typename std::enable_if<(MIGRAPHX_REQUIRES_VAR() && (migraphx::and_<__VA_ARGS__>{})), int>::type = 0
+    bool MIGRAPHX_REQUIRES_VAR()            = true,                                            \
+         typename std::enable_if<(MIGRAPHX_REQUIRES_VAR() && (migraphx::and_<__VA_ARGS__>{})), \
+                                 int>::type = 0
 #endif
 
 } // namespace MIGRAPHX_INLINE_NS