Formatting

src/include/migraph/instruction.hpp

@@ -25,13 +25,13 @@ struct instruction
     void recompute_shape();
 
     void clear_arguments();
-    
+
     friend bool operator==(const instruction& i, instruction_ref ref);
 
     bool valid(instruction_ref start) const;
 
     bool valid() const;
-    
+
     shape get_shape() const;
     const literal& get_literal() const;
 
@@ -67,10 +67,10 @@ struct instruction
 
     // internal
     void replace(std::vector<instruction_ref> args);
-    
+
     // internal
     void replace_argument(instruction_ref old, instruction_ref new_ins);
-    
+
     operation op;
     shape result;
     std::vector<instruction_ref> output;

src/instruction.cpp

@@ -4,151 +4,156 @@
 
 namespace migraph {
 
-    instruction::instruction(operation o, shape r, std::vector<instruction_ref> args)
-        : op(std::move(o)), result(std::move(r)), arguments(std::move(args))
-    {
-    }
+instruction::instruction(operation o, shape r, std::vector<instruction_ref> args)
+    : op(std::move(o)), result(std::move(r)), arguments(std::move(args))
+{
+}
 
-    instruction::instruction(literal l) : op(builtin::literal{}), result(l.get_shape()), lit(std::move(l)) {}
+instruction::instruction(literal l)
+    : op(builtin::literal{}), result(l.get_shape()), lit(std::move(l))
+{
+}
 
-    void instruction::replace(const shape& r)
+void instruction::replace(const shape& r)
+{
+    if(r != result)
     {
-        if(r != result)
+        result = r;
+        for(auto&& ins : output)
         {
-            result = r;
-            for(auto&& ins : output)
-            {
-                assert(ins->name().front() != '@');
-                ins->recompute_shape();
-            }
+            assert(ins->name().front() != '@');
+            ins->recompute_shape();
         }
     }
+}
 
-    void instruction::recompute_shape() { replace(compute_shape(op, arguments)); }
+void instruction::recompute_shape() { replace(compute_shape(op, arguments)); }
 
-    void instruction::clear_arguments()
+void instruction::clear_arguments()
+{
+    for(auto&& arg : arguments)
     {
-        for(auto&& arg : arguments)
-        {
-            arg->remove_output(*this);
-        }
-        arguments.clear();
+        arg->remove_output(*this);
     }
+    arguments.clear();
+}
+
+bool operator==(const instruction& i, instruction_ref ref)
+{
+    return std::addressof(i) == std::addressof(*ref);
+}
 
-    bool operator==(const instruction& i, instruction_ref ref)
+bool instruction::valid(instruction_ref start) const
+{
+    return valid() && std::all_of(arguments.begin(), arguments.end(), [&](instruction_ref i) {
+               auto self = std::find(i->outputs().begin(), i->outputs().end(), *this);
+               return self != i->outputs().end() &&
+                      std::distance(start, i) < std::distance(start, *self);
+           });
+}
+
+bool instruction::valid() const
+{
+    shape computed;
+    if(op.name() == "@literal")
     {
-        return std::addressof(i) == std::addressof(*ref);
+        computed = lit.get_shape();
     }
-
-    bool instruction::valid(instruction_ref start) const
+    else if(op.name() == "@param")
     {
-        return valid() && std::all_of(arguments.begin(), arguments.end(), [&](instruction_ref i) {
-                   auto self = std::find(i->outputs().begin(), i->outputs().end(), *this);
-                   return self != i->outputs().end() &&
-                          std::distance(start, i) < std::distance(start, *self);
-               });
+        computed = result;
     }
-
-    bool instruction::valid() const
+    else
     {
-        shape computed;
-        if(op.name() == "@literal")
-        {
-            computed = lit.get_shape();
-        }
-        else if(op.name() == "@param")
+        try
         {
-            computed = result;
+            computed = compute_shape(op, arguments);
         }
-        else
+        catch(migraph::exception&)
         {
-            try
-            {
-                computed = compute_shape(op, arguments);
-            }
-            catch(migraph::exception&)
-            {
-                return false;
-            }
+            return false;
         }
-        return result == computed &&
-               std::all_of(output.begin(), output.end(), [&](instruction_ref i) {
-                   return std::find(i->inputs().begin(), i->inputs().end(), *this) !=
-                          i->inputs().end();
-               });
     }
+    return result == computed && std::all_of(output.begin(), output.end(), [&](instruction_ref i) {
+               return std::find(i->inputs().begin(), i->inputs().end(), *this) != i->inputs().end();
+           });
+}
 
-    shape instruction::get_shape() const { return result; }
-    const literal& instruction::get_literal() const
-    {
-        assert(op.name() == "@literal");
-        return lit;
-    }
+shape instruction::get_shape() const { return result; }
+const literal& instruction::get_literal() const
+{
+    assert(op.name() == "@literal");
+    return lit;
+}
 
-    const operation& instruction::get_operator() const { return op; }
+const operation& instruction::get_operator() const { return op; }
 
-    std::string instruction::name() const { return op.name(); }
+std::string instruction::name() const { return op.name(); }
 
-    const std::vector<instruction_ref>& instruction::inputs() const { return arguments; }
+const std::vector<instruction_ref>& instruction::inputs() const { return arguments; }
 
-    const std::vector<instruction_ref>& instruction::outputs() const { return output; }
+const std::vector<instruction_ref>& instruction::outputs() const { return output; }
 
-    bool operator==(instruction_ref ref, const instruction& i) { return i == ref; }
+bool operator==(instruction_ref ref, const instruction& i) { return i == ref; }
 
-    bool operator!=(const instruction& i, instruction_ref ref) { return !(i == ref); }
+bool operator!=(const instruction& i, instruction_ref ref) { return !(i == ref); }
 
-    bool operator!=(instruction_ref ref, const instruction& i) { return !(i == ref); }
+bool operator!=(instruction_ref ref, const instruction& i) { return !(i == ref); }
 
-    void instruction::add_output(instruction_ref ins)
-    {
-        if(std::find(output.begin(), output.end(), ins) == output.end())
-            output.push_back(ins);
-    }
+void instruction::add_output(instruction_ref ins)
+{
+    if(std::find(output.begin(), output.end(), ins) == output.end())
+        output.push_back(ins);
+}
 
-    template <class T>
-    void instruction::remove_output(const T& ins)
-    {
-        migraph::erase(output, ins);
-    }
+template <class T>
+void instruction::remove_output(const T& ins)
+{
+    migraph::erase(output, ins);
+}
 
-    void instruction::backreference(instruction_ref ref)
-    {
-        for(auto&& arg : ref->inputs())
-            arg->add_output(ref);
-    }
+void instruction::backreference(instruction_ref ref)
+{
+    for(auto&& arg : ref->inputs())
+        arg->add_output(ref);
+}
 
-    void instruction::replace_argument(instruction_ref ins, instruction_ref old, instruction_ref new_ins)
-    {
-        ins->replace_argument(old, new_ins);
-        backreference(ins);
-        ins->recompute_shape();
-    }
+void instruction::replace_argument(instruction_ref ins,
+                                   instruction_ref old,
+                                   instruction_ref new_ins)
+{
+    ins->replace_argument(old, new_ins);
+    backreference(ins);
+    ins->recompute_shape();
+}
 
-    void
-    instruction::replace(instruction_ref ins, operation o, const shape& r, std::vector<instruction_ref> args)
-    {
-        ins->replace(std::move(o), r, std::move(args));
-        backreference(ins);
-    }
+void instruction::replace(instruction_ref ins,
+                          operation o,
+                          const shape& r,
+                          std::vector<instruction_ref> args)
+{
+    ins->replace(std::move(o), r, std::move(args));
+    backreference(ins);
+}
 
-    void instruction::replace(operation o, const shape& r, std::vector<instruction_ref> args)
-    {
-        op = std::move(o);
-        replace(r);
-        replace(std::move(args));
-    }
+void instruction::replace(operation o, const shape& r, std::vector<instruction_ref> args)
+{
+    op = std::move(o);
+    replace(r);
+    replace(std::move(args));
+}
 
-    void instruction::replace(std::vector<instruction_ref> args)
-    {
-        clear_arguments();
-        arguments = std::move(args);
-    }
+void instruction::replace(std::vector<instruction_ref> args)
+{
+    clear_arguments();
+    arguments = std::move(args);
+}
 
-    void instruction::replace_argument(instruction_ref old, instruction_ref new_ins)
-    {
-        std::replace(arguments.begin(), arguments.end(), old, new_ins);
-        old->remove_output(*this);
-    }
+void instruction::replace_argument(instruction_ref old, instruction_ref new_ins)
+{
+    std::replace(arguments.begin(), arguments.end(), old, new_ins);
+    old->remove_output(*this);
+}
 
 shape compute_shape(const operation& op, const std::vector<instruction_ref>& args)
 {