Switch core ops to type_name description.

src/ngraph/op/avg_pool.hpp

@@ -173,6 +173,7 @@ namespace ngraph
         class AvgPoolBackprop : public Op
         {
         public:
+            NGRAPH_API
             static const std::string type_name;
             const std::string& description() const override { return type_name; }
             AvgPoolBackprop() = default;

src/ngraph/op/batch_norm.hpp

@@ -92,6 +92,7 @@ namespace ngraph
         class BatchNormInference : public Op
         {
         public:
+            NGRAPH_API
             static const std::string type_name;
             const std::string& description() const override { return type_name; }
             BatchNormInference() = default;

src/ngraph/op/pad.cpp

@@ -21,12 +21,14 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Pad::type_name{"Pad"};
+
 op::Pad::Pad(const shared_ptr<Node>& arg,
              const shared_ptr<Node>& arg_pad_value,
              const CoordinateDiff& padding_below,
              const CoordinateDiff& padding_above,
              PadMode pad_mode)
-    : Op("Pad", check_single_output_args({arg, arg_pad_value}))
+    : Op(check_single_output_args({arg, arg_pad_value}))
     , m_padding_below(padding_below)
     , m_padding_above(padding_above)
     , m_padding_interior_fake(padding_below.size())

src/ngraph/op/pad.hpp

@@ -28,6 +28,9 @@ namespace ngraph
         class Pad : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a generic padding operation.
             ///
             /// \param arg The node producing input tensor to be padded.

src/ngraph/op/parameter.cpp

@@ -21,10 +21,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Parameter::type_name{"Parameter"};
+
 op::Parameter::Parameter(const element::Type& element_type,
                          const PartialShape& pshape,
                          const bool cacheable)
-    : Op("Parameter", {})
+    : Op(NodeVector{})
     , m_cacheable(cacheable)
     , m_partial_shape(pshape)
     , m_element_type(element_type)

src/ngraph/op/parameter.hpp

@@ -35,6 +35,9 @@ namespace ngraph
                                            const NodeVector& deltas) override;
 
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructions a tensor-typed parameter node.
             ///
             /// \param element_type The element type of the parameter.

src/ngraph/op/passthrough.cpp

@@ -18,12 +18,17 @@
 
 #include "ngraph/op/passthrough.hpp"
 
+using namespace std;
+using namespace ngraph;
+
+const string op::Passthrough::type_name{"Passthrough"};
+
 ngraph::op::Passthrough::Passthrough(const std::string& logical_type,
                                      const std::string& language,
                                      const std::string& function,
                                      const NodeVector& args,
                                      std::vector<std::tuple<element::Type, PartialShape>> outputs)
-    : Op{"Passthrough", args}
+    : Op{args}
     , m_logical_type{logical_type}
     , m_language{language}
     , m_function{function}
@@ -65,5 +70,5 @@ std::shared_ptr<ngraph::Node>
             "Passthrough node input counts cannot be changed for a given Passthrough function"};
     }
     return std::make_shared<Passthrough>(
-        description(), m_language, m_function, new_args, m_output_shapes);
+        m_logical_type, m_language, m_function, new_args, m_output_shapes);
 }

src/ngraph/op/passthrough.hpp

@@ -38,6 +38,9 @@ namespace ngraph
 class ngraph::op::Passthrough final : public Op
 {
 public:
+    NGRAPH_API
+    static const std::string type_name;
+    const std::string& description() const override { return type_name; }
     Passthrough(const std::string& logical_type, // aka "What this operation is doing"
                 const std::string& language,     // The language the implementation is written in
                 const std::string& function,     // The operation implementation

src/ngraph/op/power.cpp

@@ -22,10 +22,12 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Power::type_name{"Power"};
+
 op::Power::Power(const shared_ptr<Node>& arg0,
                  const shared_ptr<Node>& arg1,
                  const AutoBroadcastSpec& autob)
-    : BinaryElementwiseArithmetic("Power", arg0, arg1, autob)
+    : BinaryElementwiseArithmetic(arg0, arg1, autob)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/power.hpp

@@ -39,6 +39,9 @@ namespace ngraph
         class Power : public util::BinaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs an exponentiation operation.
             ///
             /// \param arg0 Node that produces the first input tensor.

src/ngraph/op/relu.cpp

@@ -20,8 +20,11 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Relu::type_name{"Relu"};
+const string op::ReluBackprop::type_name{"ReluBackprop"};
+
 op::Relu::Relu(shared_ptr<Node> arg)
-    : UnaryElementwiseArithmetic("Relu", {arg})
+    : UnaryElementwiseArithmetic({arg})
 {
     constructor_validate_and_infer_types();
 }
@@ -33,7 +36,7 @@ shared_ptr<Node> op::Relu::copy_with_new_args(const NodeVector& new_args) const
 }
 
 op::ReluBackprop::ReluBackprop(shared_ptr<Node> arg, shared_ptr<Node> delta)
-    : BinaryElementwiseArithmetic("ReluBackprop", arg, delta)
+    : BinaryElementwiseArithmetic(arg, delta)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/relu.hpp

@@ -33,6 +33,9 @@ namespace ngraph
         class Relu : public ngraph::op::util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a Relu operation.
             ///
             /// \param arg Node that produces the input tensor.
@@ -50,6 +53,9 @@ namespace ngraph
         class ReluBackprop : public ngraph::op::util::BinaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a ReluBackprop operation.
             ///
             /// \param arg Node that produces the relu forward input tensor.

src/ngraph/op/reverse.cpp

@@ -23,8 +23,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Reverse::type_name{"Reverse"};
+
 op::Reverse::Reverse(const shared_ptr<Node>& arg, const AxisSet& reversed_axes)
-    : Op("Reverse", check_single_output_args({arg}))
+    : Op(check_single_output_args({arg}))
     , m_reversed_axes(reversed_axes)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/reverse.hpp

@@ -46,6 +46,9 @@ namespace ngraph
         class Reverse : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a reverse operation.
             ///
             /// \param arg The input tensor, some of whose axes are to be reversed.

src/ngraph/op/reverse_sequence.cpp

@@ -25,11 +25,13 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::ReverseSequence::type_name{"ReverseSequence"};
+
 op::ReverseSequence::ReverseSequence(const std::shared_ptr<Node> arg,
                                      const std::shared_ptr<Node> seq_indices,
                                      size_t batch_axis,
                                      size_t seq_axis)
-    : Op("ReverseSequence", check_single_output_args({arg, seq_indices}))
+    : Op(check_single_output_args({arg, seq_indices}))
     , m_batch_axis(batch_axis)
     , m_seq_axis(seq_axis)
 {

src/ngraph/op/reverse_sequence.hpp

@@ -25,6 +25,9 @@ namespace ngraph
         class ReverseSequence : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs an arcsin operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/scatter_add.cpp

@@ -24,6 +24,8 @@ static int INPUTS = 0;
 static int INDICES = 1;
 static int UPDATES = 2;
 
+const string op::ScatterAdd::type_name{"ScatterAdd"};
+
 shared_ptr<Node> op::ScatterAdd::copy_with_new_args(const NodeVector& new_args) const
 {
     check_new_args_count(this, new_args);

src/ngraph/op/scatter_add.hpp

@@ -26,13 +26,16 @@ namespace ngraph
         class ScatterAdd : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \param inputs Tensor
             /// \param indices Index tensor: Data type must be `element::i32` or `element::i64`
             /// \param updates Tensor: Must have same type as inputs
             ScatterAdd(const std::shared_ptr<Node>& inputs,
                        const std::shared_ptr<Node>& indices,
                        const std::shared_ptr<Node>& updates)
-                : Op("ScatterAdd", check_single_output_args({inputs, indices, updates}))
+                : Op(check_single_output_args({inputs, indices, updates}))
             {
                 constructor_validate_and_infer_types();
             }

src/ngraph/op/scatter_nd_add.cpp

@@ -24,6 +24,8 @@ static int INPUTS = 0;
 static int INDICES = 1;
 static int UPDATES = 2;
 
+const string op::ScatterNDAdd::type_name{"ScatterNDAdd"};
+
 shared_ptr<Node> op::ScatterNDAdd::copy_with_new_args(const NodeVector& new_args) const
 {
     check_new_args_count(this, new_args);

src/ngraph/op/scatter_nd_add.hpp

@@ -26,13 +26,16 @@ namespace ngraph
         class ScatterNDAdd : public Op
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \param inputs Tensor
             /// \param indices Index tensor: Data type must be `element::i32` or `element::i64`
             /// \param updates Tensor: Must have same type as inputs
             ScatterNDAdd(const std::shared_ptr<Node>& inputs,
                          const std::shared_ptr<Node>& indices,
                          const std::shared_ptr<Node>& updates)
-                : Op("ScatterNDAdd", check_single_output_args({inputs, indices, updates}))
+                : Op(check_single_output_args({inputs, indices, updates}))
             {
                 constructor_validate_and_infer_types();
             }

src/ngraph/op/sigmoid.cpp

@@ -21,6 +21,9 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Sigmoid::type_name{"Sigmoid"};
+const string op::SigmoidBackprop::type_name{"SigmoidBackprop"};
+
 shared_ptr<Node> op::Sigmoid::copy_with_new_args(const NodeVector& new_args) const
 {
     check_new_args_count(this, new_args);
@@ -28,13 +31,13 @@ shared_ptr<Node> op::Sigmoid::copy_with_new_args(const NodeVector& new_args) con
 }
 
 op::Sigmoid::Sigmoid(shared_ptr<Node> arg)
-    : UnaryElementwiseArithmetic("Sigmoid", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }
 
 op::SigmoidBackprop::SigmoidBackprop(shared_ptr<Node> arg, shared_ptr<Node> delta)
-    : BinaryElementwiseArithmetic("SigmoidBackprop", arg, delta)
+    : BinaryElementwiseArithmetic(arg, delta)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/sigmoid.hpp

@@ -28,6 +28,9 @@ namespace ngraph
         class Sigmoid : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             Sigmoid(std::shared_ptr<Node> arg);
             virtual std::shared_ptr<Node>
                 copy_with_new_args(const NodeVector& new_args) const override;
@@ -40,6 +43,9 @@ namespace ngraph
         class SigmoidBackprop : public util::BinaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a SigmoidBackprop operation.
             ///
             /// \param arg Node that produces the Sigmoid forward input tensor.

src/ngraph/op/sign.cpp

@@ -19,8 +19,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Sign::type_name{"Sign"};
+
 op::Sign::Sign(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Sign", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/sign.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class Sign : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs an elementwise sign operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/sin.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Sin::type_name{"Sin"};
+
 op::Sin::Sin(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Sin", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/sin.hpp

@@ -38,6 +38,9 @@ namespace ngraph
         class Sin : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a sine operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/sinh.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Sinh::type_name{"Sinh"};
+
 op::Sinh::Sinh(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Sinh", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/sinh.hpp

@@ -26,6 +26,9 @@ namespace ngraph
         class Sinh : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a hyperbolic sine operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/softmax.cpp

@@ -29,8 +29,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Softmax::type_name{"Softmax"};
+
 op::Softmax::Softmax(const shared_ptr<Node>& arg, const AxisSet& axes)
-    : UnaryElementwiseArithmetic("Softmax", arg)
+    : UnaryElementwiseArithmetic(arg)
     , m_axes(axes)
 {
     constructor_validate_and_infer_types();

src/ngraph/op/softmax.hpp

@@ -27,6 +27,9 @@ namespace ngraph
         class Softmax : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a softmax operation.
             ///
             /// \param arg Node that produces the first input tensor.<br>

src/ngraph/op/sqrt.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Sqrt::type_name{"Sqrt"};
+
 op::Sqrt::Sqrt(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Sqrt", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/sqrt.hpp

@@ -38,6 +38,9 @@ namespace ngraph
         class Sqrt : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a square operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/stop_gradient.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::StopGradient::type_name{"StopGradient"};
+
 op::StopGradient::StopGradient(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("StopGradient", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/stop_gradient.hpp

@@ -26,6 +26,9 @@ namespace ngraph
         class StopGradient : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs StopGradient
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/tan.cpp

@@ -22,8 +22,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Tan::type_name{"Tan"};
+
 op::Tan::Tan(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Tan", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/tan.hpp

@@ -38,6 +38,9 @@ namespace ngraph
         class Tan : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a tangent operation.
             ///
             /// \param arg Node that produces the input tensor.

src/ngraph/op/tanh.cpp

@@ -21,8 +21,10 @@
 using namespace std;
 using namespace ngraph;
 
+const string op::Tanh::type_name{"Tanh"};
+
 op::Tanh::Tanh(const shared_ptr<Node>& arg)
-    : UnaryElementwiseArithmetic("Tanh", arg)
+    : UnaryElementwiseArithmetic(arg)
 {
     constructor_validate_and_infer_types();
 }

src/ngraph/op/tanh.hpp

@@ -26,6 +26,9 @@ namespace ngraph
         class Tanh : public util::UnaryElementwiseArithmetic
         {
         public:
+            NGRAPH_API
+            static const std::string type_name;
+            const std::string& description() const override { return type_name; }
             /// \brief Constructs a hyperbolic tangent operation.
             ///
             /// \param arg Node that produces the input tensor.