style

src/ngraph/except.hpp

@@ -21,7 +21,6 @@ namespace ngraph
     /// Base error for ngraph runtime errors.
     struct ngraph_error : std::runtime_error
     {
-        
         explicit ngraph_error(const std::string& what_arg)
             : std::runtime_error(what_arg)
         {

src/ngraph/function.hpp

@@ -21,14 +21,14 @@
 
 namespace ngraph
 {
-
     /**
      ** A user-defined function.
      **/
     class Function
     {
     public:
-        Function(const Node::ptr& result, const std::vector<std::shared_ptr<Parameter>>& parameters);
+        Function(const Node::ptr&                               result,
+                 const std::vector<std::shared_ptr<Parameter>>& parameters);
 
         Node::ptr result() { return m_result; }
 
@@ -44,7 +44,11 @@ namespace ngraph
 
     namespace op
     {
-        std::shared_ptr<Function> function(const Node::ptr& result, const std::initializer_list<std::shared_ptr<Parameter>>& parameters);
-        std::shared_ptr<Function> function(const Node::ptr& result, const std::vector<std::shared_ptr<Parameter>>& parameters);
+        std::shared_ptr<Function>
+            function(const Node::ptr&                                         result,
+                     const std::initializer_list<std::shared_ptr<Parameter>>& parameters);
+        std::shared_ptr<Function>
+            function(const Node::ptr&                               result,
+                     const std::vector<std::shared_ptr<Parameter>>& parameters);
     }
 }

src/ngraph/node.hpp

@@ -69,7 +69,10 @@ namespace ngraph
          ** will be used by the pattern matcher when comparing a pattern
          ** graph against the graph.
          **/
-         bool is_same_op_type(const Node::ptr& node) const { return typeid(*this) == typeid(*node.get()); }
+        bool is_same_op_type(const Node::ptr& node) const
+        {
+            return typeid(*this) == typeid(*node.get());
+        }
 
     protected:
         std::vector<Node::ptr> m_arguments;

src/ngraph/op.hpp

@@ -73,7 +73,6 @@ namespace ngraph
     class Op : public Node
     {
     public:
-
         Op(const std::vector<Node::ptr>& arguments)
             : Node(arguments, nullptr)
         {
@@ -86,8 +85,8 @@ namespace ngraph
      **/
     class FunctionOp : public Op
     {
-
         virtual std::string description() const override { return "FunctionOp"; }
+
     protected:
         Node::ptr m_function;
     };

src/ngraph/parameter.hpp

@@ -19,7 +19,6 @@
 
 namespace ngraph
 {
-
     class Function;
 
     /**
@@ -30,6 +29,7 @@ namespace ngraph
     class Parameter : public Node
     {
         friend class Function;
+
     protected:
         // Called by the Function constructor to associate this parameter with the function.
         // It is an error to try to associate a parameter with more than one function.
@@ -50,8 +50,9 @@ namespace ngraph
     namespace op
     {
         /// Factory for frameworks
-        std::shared_ptr<ngraph::Parameter> parameter(const ValueType::ptr& value_type=nullptr);
+        std::shared_ptr<ngraph::Parameter> parameter(const ValueType::ptr& value_type = nullptr);
         /// Convenience factory for tests
-        std::shared_ptr<ngraph::Parameter> parameter(const ngraph::element::Type element_type, const Shape& shape);
+        std::shared_ptr<ngraph::Parameter> parameter(const ngraph::element::Type element_type,
+                                                     const Shape&                shape);
     }
 }

src/ops/function.cpp

@@ -17,7 +17,8 @@
 using namespace std;
 using namespace ngraph;
 
-Function::Function(const Node::ptr& result, const std::vector<std::shared_ptr<ngraph::Parameter>>& parameters)
+Function::Function(const Node::ptr&                                       result,
+                   const std::vector<std::shared_ptr<ngraph::Parameter>>& parameters)
     : m_result(result)
     , m_parameters(parameters)
     , m_name("Function")
@@ -29,12 +30,14 @@ Function::Function(const Node::ptr& result, const std::vector<std::shared_ptr<ng
     }
 }
 
-shared_ptr<Function> ngraph::op::function(const Node::ptr& result, const initializer_list<shared_ptr<Parameter>>& parameters)
+shared_ptr<Function> ngraph::op::function(const Node::ptr&                               result,
+                                          const initializer_list<shared_ptr<Parameter>>& parameters)
 {
     return make_shared<Function>(result, parameters);
 }
 
-shared_ptr<Function> ngraph::op::function(const Node::ptr& result, const vector<shared_ptr<Parameter>>& parameters)
+shared_ptr<Function> ngraph::op::function(const Node::ptr&                     result,
+                                          const vector<shared_ptr<Parameter>>& parameters)
 {
     return make_shared<Function>(result, parameters);
 }

src/ops/parameter.cpp

@@ -26,23 +26,23 @@ Parameter::Parameter(const ValueType::ptr& value_type)
 
 void Parameter::assign_function(Function* function, size_t index)
 {
-    if (nullptr != m_function){
+    if (nullptr != m_function)
+    {
         throw ngraph_error("Re-assigning function to a parameter.");
     }
     m_function = function;
     m_index    = index;
 }
 
-void Parameter::propagate_types()
-{
-}
+void Parameter::propagate_types() {}
 
 shared_ptr<Parameter> ngraph::op::parameter(const ValueType::ptr& value_type)
 {
     return make_shared<Parameter>(value_type);
 }
 
-shared_ptr<Parameter> ngraph::op::parameter(const ngraph::element::Type element_type, const Shape& shape)
+shared_ptr<Parameter> ngraph::op::parameter(const ngraph::element::Type element_type,
+                                            const Shape&                shape)
 {
     return make_shared<Parameter>(make_shared<TensorViewType>(element_type, shape));
 }

test/build_graph.cpp

@@ -32,6 +32,7 @@ TEST(build_graph, build_simple)
     ASSERT_EQ(dot->arguments()[1], arg0);
 
     auto cluster_0 = op::function(dot, {arg0, arg1, arg2, arg3});
+
     ASSERT_EQ(cluster_0->result(), dot);
 }
 
@@ -72,8 +73,4 @@ TEST(build_graph, node_comparison)
 }
 
 // Check argument inverses
-TEST(build_graph, arg_inverse)
-{
-
-}
-
+TEST(build_graph, arg_inverse) {}