refactor

Signed-off-by: Evgeniia Nugmanova <evgeniia.nugmanova@intel.com>

Author: jane-intel

src/core/include/openvino/pass/pattern/op/any.hpp

@@ -15,22 +15,17 @@ class OPENVINO_API Any : public Pattern {
     OPENVINO_RTTI("patternAny");
     /// \brief creates a Any node containing a sub-pattern described by \sa type and \sa
     ///        shape.
-    template <typename TPredicate>
-    Any(const element::Type& type, const PartialShape& s, const TPredicate& pred, const OutputVector& wrapped_values)
+    template <typename TPredicate, typename TArg>
+    Any(const element::Type& type, const PartialShape& s, const TPredicate& pred, const TArg& wrapped_values)
         : Pattern(wrapped_values, Predicate(pred)) {
         set_output_type(0, type, s);
     }
-    template <typename TPredicate>
-    Any(const element::Type& type, const PartialShape& s, const TPredicate& pred, const NodeVector& wrapped_values)
-        : Any(type, s, Predicate(pred), as_output_vector(wrapped_values)) {}
+
     /// \brief creates a Any node containing a sub-pattern described by the type and
     ///        shape of \sa node.
-    template <typename TPredicate>
-    Any(const Output<Node>& node, const TPredicate& pred, const OutputVector& wrapped_values)
+    template <typename TPredicate, typename TArg>
+    Any(const Output<Node>& node, const TPredicate& pred, const TArg& wrapped_values)
         : Any(node.get_element_type(), node.get_partial_shape(), pred, wrapped_values) {}
-    template <typename TPredicate>
-    Any(const Output<Node>& node, const TPredicate& pred, const NodeVector& wrapped_values)
-        : Any(node, Predicate(pred), as_output_vector(wrapped_values)) {}
 
     bool match_value(pattern::Matcher* matcher,
                      const Output<Node>& pattern_value,

src/core/include/openvino/pass/pattern/op/any_of.hpp

@@ -20,26 +20,21 @@ class OPENVINO_API AnyOf : public Pattern {
     OPENVINO_RTTI("patternAnyOf");
     /// \brief creates a AnyOf node containing a sub-pattern described by \sa type and
     ///        \sa shape.
-    template <typename TPredicate>
-    AnyOf(const element::Type& type, const PartialShape& s, const TPredicate& pred, const OutputVector& wrapped_values)
+    template <typename TPredicate, typename TArg>
+    AnyOf(const element::Type& type, const PartialShape& s, const TPredicate& pred, const TArg& wrapped_values)
         : Pattern(wrapped_values, Predicate(pred)) {
         if (wrapped_values.size() != 1) {
             OPENVINO_THROW("AnyOf expects exactly one argument");
         }
         set_output_type(0, type, s);
     }
-    template <typename TPredicate>
-    AnyOf(const element::Type& type, const PartialShape& s, const TPredicate& pred, const NodeVector& wrapped_values)
-        : AnyOf(type, s, Predicate(pred), as_output_vector(wrapped_values)) {}
 
     /// \brief creates a AnyOf node containing a sub-pattern described by the type and
     ///        shape of \sa node.
-    template <typename TPredicate>
-    AnyOf(const Output<Node>& node, const TPredicate& pred, const OutputVector& wrapped_values)
+    template <typename TPredicate, typename TArg>
+    AnyOf(const Output<Node>& node, const TPredicate& pred, const TArg& wrapped_values)
         : AnyOf(node.get_element_type(), node.get_partial_shape(), pred, wrapped_values) {}
-    template <typename TPredicate>
-    AnyOf(const std::shared_ptr<Node>& node, const TPredicate& pred, const NodeVector& wrapped_values)
-        : AnyOf(node, Predicate(pred), as_output_vector(wrapped_values)) {}
+
     bool match_value(Matcher* matcher, const Output<Node>& pattern_value, const Output<Node>& graph_value) override;
 };
 }  // namespace ov::pass::pattern::op

src/core/include/openvino/pass/pattern/op/optional.hpp

@@ -51,12 +51,10 @@ class OPENVINO_API Optional : public Pattern {
     /// \param type_infos Optional operation types to exclude them from the matching
     /// in case the following op types do not exist in a pattern to match.
     /// \param patterns The pattern to match a graph.
-    Optional(const std::vector<DiscreteTypeInfo>& type_infos, const OutputVector& inputs = {})
-        : Pattern(inputs),
-          optional_types(type_infos){};
-
-    template <typename TPredicate>
-    Optional(const std::vector<DiscreteTypeInfo>& type_infos, const OutputVector& inputs, const TPredicate& pred)
+    template <typename TPredicate = nullptr_t>
+    Optional(const std::vector<DiscreteTypeInfo>& type_infos,
+             const OutputVector& inputs = {},
+             const TPredicate& pred = nullptr)
         : Pattern(inputs, Predicate(pred)),
           optional_types(type_infos){};
 
@@ -84,8 +82,10 @@ void collect_type_info(std::vector<DiscreteTypeInfo>& type_info_vec) {
     collect_type_info<NodeTypeArgs...>(type_info_vec);
 }
 
-template <class... NodeTypes, typename TPredicate>
-std::shared_ptr<Node> optional(const OutputVector& inputs, const TPredicate& pred, const Attributes& attrs = {}) {
+template <class... NodeTypes, typename TPredicate = nullptr_t>
+std::shared_ptr<Node> optional(const OutputVector& inputs,
+                               const TPredicate& pred = nullptr,
+                               const Attributes& attrs = {}) {
     std::vector<DiscreteTypeInfo> optional_type_info_vec;
     collect_type_info<NodeTypes...>(optional_type_info_vec);
     return std::make_shared<op::Optional>(
@@ -94,8 +94,10 @@ std::shared_ptr<Node> optional(const OutputVector& inputs, const TPredicate& pre
         attrs.empty() ? op::Predicate(pred) : attrs_match(attrs) && op::Predicate(pred));
 }
 
-template <class... NodeTypes, typename TPredicate>
-std::shared_ptr<Node> optional(const Output<Node>& input, const TPredicate& pred, const Attributes& attrs = {}) {
+template <class... NodeTypes, typename TPredicate = nullptr_t>
+std::shared_ptr<Node> optional(const Output<Node>& input,
+                               const TPredicate& pred = nullptr,
+                               const Attributes& attrs = {}) {
     return optional<NodeTypes...>(OutputVector{input}, op::Predicate(pred), attrs);
 }
 
@@ -107,21 +109,22 @@ std::shared_ptr<Node> optional(const TPredicate& pred, const Attributes& attrs =
 }
 
 template <class... NodeTypes>
-std::shared_ptr<Node> optional(const std::initializer_list<Output<Node>>& inputs, const Attributes& attrs = {}) {
-    return optional<NodeTypes...>(OutputVector(inputs), attrs.empty() ? op::Predicate() : attrs_match(attrs));
+std::shared_ptr<Node> optional(const OutputVector& inputs, const Attributes& attrs) {
+    return optional<NodeTypes...>(inputs, attrs.empty() ? op::Predicate() : attrs_match(attrs));
 }
+
 template <class... NodeTypes>
-std::shared_ptr<Node> optional(const OutputVector& inputs, const Attributes& attrs = {}) {
-    return optional<NodeTypes...>(inputs, attrs.empty() ? op::Predicate() : attrs_match(attrs));
+std::shared_ptr<Node> optional(const std::initializer_list<Output<Node>>& inputs, const Attributes& attrs = {}) {
+    return optional<NodeTypes...>(OutputVector(inputs), attrs);
 }
 
 template <class... NodeTypes>
-std::shared_ptr<Node> optional(const Output<Node>& input, const Attributes& attrs = {}) {
+std::shared_ptr<Node> optional(const Output<Node>& input, const Attributes& attrs) {
     return optional<NodeTypes...>(OutputVector{input}, attrs);
 }
 
 template <class... NodeTypes>
 std::shared_ptr<Node> optional(const Attributes& attrs = {}) {
-    return optional<NodeTypes...>(OutputVector{}, attrs.empty() ? op::Predicate() : attrs_match(attrs));
+    return optional<NodeTypes...>(OutputVector{}, attrs);
 }
 }  // namespace ov::pass::pattern

src/core/include/openvino/pass/pattern/op/wrap_type.hpp

@@ -63,8 +63,10 @@ void collect_wrap_info(std::vector<DiscreteTypeInfo>& info) {
     collect_wrap_info<Targs...>(info);
 }
 
-template <class... Args, typename TPredicate>
-std::shared_ptr<Node> wrap_type(const OutputVector& inputs, const TPredicate& pred, const Attributes& attrs = {}) {
+template <class... Args, typename TPredicate = nullptr_t>
+std::shared_ptr<Node> wrap_type(const OutputVector& inputs = {},
+                                const TPredicate& pred = nullptr,
+                                const Attributes& attrs = {}) {
     std::vector<DiscreteTypeInfo> info;
     collect_wrap_info<Args...>(info);
     return std::make_shared<op::WrapType>(
@@ -73,25 +75,25 @@ std::shared_ptr<Node> wrap_type(const OutputVector& inputs, const TPredicate& pr
         inputs);
 }
 
+template <class... Args,
+          typename TPredicate,
+          typename std::enable_if_t<std::is_constructible_v<op::Predicate, TPredicate>>* = nullptr>
+std::shared_ptr<Node> wrap_type(const TPredicate& pred, const Attributes& attrs = {}) {
+    return wrap_type<Args...>({}, op::Predicate(pred), attrs);
+}
+
 template <class... Args>
-std::shared_ptr<Node> wrap_type(const OutputVector& inputs, const Attributes& attrs = {}) {
+std::shared_ptr<Node> wrap_type(const OutputVector& inputs, const Attributes& attrs) {
     return wrap_type<Args...>(inputs, (attrs.empty() ? op::Predicate() : attrs_match(attrs)));
 }
 
 template <class... Args>
-std::shared_ptr<Node> wrap_type(const std::initializer_list<Output<Node>>& inputs = {}, const Attributes& attrs = {}) {
+std::shared_ptr<Node> wrap_type(const std::initializer_list<Output<Node>>& inputs, const Attributes& attrs = {}) {
     return wrap_type<Args...>(OutputVector(inputs), attrs);
 }
 
-template <class... Args,
-          typename TPredicate,
-          typename std::enable_if_t<std::is_constructible_v<op::Predicate, TPredicate>>* = nullptr>
-std::shared_ptr<Node> wrap_type(const TPredicate& pred, const Attributes& attrs = {}) {
-    return wrap_type<Args...>({}, op::Predicate(pred), attrs);
-}
-
 template <class... Args>
 std::shared_ptr<Node> wrap_type(const Attributes& attrs) {
-    return wrap_type<Args...>({}, attrs);
+    return wrap_type<Args...>(attrs_match(attrs));
 }
 }  // namespace ov::pass::pattern