[core] Migrate ShuffleChannels operator to new API (#21340)

* Drop legacy stuff

* Repalce HostTensor with ov::Tensor

* Remove redundant call

* Revert safer axis normalilzation

src/core/include/openvino/op/shuffle_channels.hpp

@@ -46,13 +46,10 @@ public:
     const int64_t& get_group() const {
         return m_group;
     }
-    OPENVINO_SUPPRESS_DEPRECATED_START
-    bool evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const override;
-    OPENVINO_SUPPRESS_DEPRECATED_END
+    bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
     bool has_evaluate() const override;
 
 private:
-    bool evaluate_shuffle_channels(const HostTensorVector& outputs, const HostTensorVector& inputs) const;
     int64_t m_axis{1};
     int64_t m_group{1};
 };

src/core/src/op/shuffle_channels.cpp

@@ -2,38 +2,34 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "ngraph/op/shuffle_channels.hpp"
+#include "openvino/op/shuffle_channels.hpp"
 
 #include <numeric>
-#include <shuffle_channels_shape_inference.hpp>
 
 #include "itt.hpp"
-#include "ngraph/attribute_visitor.hpp"
-#include "ngraph/builder/reshape.hpp"
-#include "ngraph/runtime/host_tensor.hpp"
-#include "ngraph/type/element_type.hpp"
-#include "ngraph/type/element_type_traits.hpp"
-#include "openvino/core/validation_util.hpp"
+#include "openvino/core/attribute_visitor.hpp"
 #include "openvino/reference/shuffle_channels.hpp"
+#include "shuffle_channels_shape_inference.hpp"
+#include "validation_util.hpp"
 
-using namespace std;
-using namespace ngraph;
-
-op::ShuffleChannels::ShuffleChannels(const Output<Node>& data, const int64_t axis, const int64_t group)
+namespace ov {
+namespace op {
+namespace v0 {
+ShuffleChannels::ShuffleChannels(const Output<Node>& data, const int64_t axis, const int64_t group)
     : Op({data}),
       m_axis(axis),
       m_group{group} {
     constructor_validate_and_infer_types();
 }
 
-bool ngraph::op::v0::ShuffleChannels::visit_attributes(AttributeVisitor& visitor) {
+bool ShuffleChannels::visit_attributes(AttributeVisitor& visitor) {
     OV_OP_SCOPE(v0_ShuffleChannels_visit_attributes);
     visitor.on_attribute("axis", m_axis);
     visitor.on_attribute("group", m_group);
     return true;
 }
 
-size_t op::ShuffleChannels::get_zero_based_axis() const {
+size_t ShuffleChannels::get_zero_based_axis() const {
     const auto input_rank = get_input_partial_shape(0).rank();
     if (input_rank.is_static()) {
         OPENVINO_SUPPRESS_DEPRECATED_START
@@ -44,7 +40,7 @@ size_t op::ShuffleChannels::get_zero_based_axis() const {
     }
 }
 
-void op::ShuffleChannels::validate_and_infer_types() {
+void ShuffleChannels::validate_and_infer_types() {
     OV_OP_SCOPE(v0_ShuffleChannels_validate_and_infer_types);
 
     OPENVINO_SUPPRESS_DEPRECATED_START
@@ -53,42 +49,42 @@ void op::ShuffleChannels::validate_and_infer_types() {
     set_output_type(0, get_input_element_type(0), output_shape);
 }
 
-shared_ptr<Node> op::ShuffleChannels::clone_with_new_inputs(const OutputVector& new_args) const {
+std::shared_ptr<Node> ShuffleChannels::clone_with_new_inputs(const OutputVector& new_args) const {
     OV_OP_SCOPE(v0_ShuffleChannels_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return make_shared<ShuffleChannels>(new_args.at(0), m_axis, m_group);
+    return std::make_shared<ShuffleChannels>(new_args.at(0), m_axis, m_group);
 }
 
-OPENVINO_SUPPRESS_DEPRECATED_START
-bool op::ShuffleChannels::evaluate_shuffle_channels(const HostTensorVector& outputs,
-                                                    const HostTensorVector& inputs) const {
-    const auto arg = inputs[0]->get_data_ptr<const char>();
-    auto out = outputs[0]->get_data_ptr<char>();
-    const auto data_shape = inputs[0]->get_shape();
-    const size_t elem_size = inputs[0]->get_element_type().size();
+bool ShuffleChannels::evaluate(TensorVector& outputs, const TensorVector& inputs) const {
+    OV_OP_SCOPE(v0_ShuffleChannels_evaluate);
+    OPENVINO_ASSERT(inputs.size() == 1);
+    OPENVINO_ASSERT(outputs.size() == 1);
 
-    outputs[0]->set_element_type(inputs[0]->get_element_type());
-    outputs[0]->set_shape(data_shape);
+    const auto& input = inputs[0];
+    const auto& data_shape = input.get_shape();
 
-    ov::reference::shuffle_channels(arg, out, data_shape, elem_size, m_axis, m_group);
+    auto& output = outputs[0];
+    output.set_shape(data_shape);
 
+    const auto arg = static_cast<const char*>(input.data());
+    const auto out = static_cast<char*>(output.data());
+    const auto elem_size = input.get_element_type().size();
+    reference::shuffle_channels(arg, out, data_shape, elem_size, m_axis, m_group);
     return true;
 }
-bool op::ShuffleChannels::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const {
-    OV_OP_SCOPE(v0_ShuffleChannels_evaluate);
-    return evaluate_shuffle_channels(outputs, inputs);
-}
-OPENVINO_SUPPRESS_DEPRECATED_END
 
-bool op::ShuffleChannels::has_evaluate() const {
+bool ShuffleChannels::has_evaluate() const {
     OV_OP_SCOPE(v0_ShuffleChannels_has_evaluate);
     return true;
 }
 
-void op::v0::ShuffleChannels::set_axis(int64_t axis) {
+void ShuffleChannels::set_axis(int64_t axis) {
     m_axis = axis;
 }
 
-void op::v0::ShuffleChannels::set_group(int64_t group) {
+void ShuffleChannels::set_group(int64_t group) {
     m_group = group;
 }
+}  // namespace v0
+}  // namespace op
+}  // namespace ov