[core] Fix issue reported by Coverity in core sub-component (#30753)

### Details:
 - Fix most of issue in core component

### Tickets:
 - CVS-167271

---------

Signed-off-by: Pawel Raasz <[email protected]>
Co-authored-by: Tomasz Jankowski <[email protected]>
Co-authored-by: Katarzyna Mitrus <[email protected]>

Author: 3 people

src/core/include/openvino/core/descriptor/input.hpp

@@ -104,6 +104,7 @@ class OPENVINO_API Input {
     Input(const Input&) = default;
     Input(Input&&) = default;
     Input& operator=(const Input&) = default;
+    Input& operator=(Input&&) = default;
 
 protected:
     // owner of an argument node (in lieu of m_arguments)

src/core/include/openvino/core/enum_names.hpp

@@ -48,7 +48,7 @@ class EnumNames {
     /// Creates the mapping.
     EnumNames(const std::string& enum_name, const std::vector<std::pair<std::string, EnumType>> string_enums)
         : m_enum_name(enum_name),
-          m_string_enums(string_enums) {}
+          m_string_enums(std::move(string_enums)) {}
 
     /// Must be defined to returns a singleton for each supported enum class
     static EnumNames<EnumType>& get();

src/core/include/openvino/core/type.hpp

@@ -98,9 +98,9 @@ is_type(Value value) {
 }
 
 /// \brief Tests if value is a pointer/shared_ptr that can be statically cast to any of the specified types
-template <typename Type, typename... Types, typename Value>
-bool is_type_any_of(Value value) {
-    return is_type<Type>(value) || (is_type_any_of<Types>(value) || ...);
+template <typename... Types, typename Value>
+bool is_type_any_of(Value&& value) {
+    return (is_type<Types>(std::forward<Value>(value)) || ...);
 }
 
 /// Casts a Value* to a Type* if it is of type Type, nullptr otherwise

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

@@ -63,7 +63,8 @@ class OPENVINO_API Interpolate : public Op {
         return m_attrs;
     }
 
-    void set_attrs(Attributes attrs);
+    void set_attrs(Attributes&& attrs);
+    void set_attrs(const Attributes& attrs);
 
 private:
     Attributes m_attrs;

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

@@ -56,7 +56,8 @@ class OPENVINO_API PriorBox : public Op {
     const Attributes& get_attrs() const {
         return m_attrs;
     }
-    void set_attrs(Attributes attrs);
+    void set_attrs(Attributes&& attrs);
+    void set_attrs(const Attributes& attrs);
 
     bool visit_attributes(AttributeVisitor& visitor) override;
     bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
@@ -117,7 +118,8 @@ class OPENVINO_API PriorBox : public Op {
     const Attributes& get_attrs() const {
         return m_attrs;
     }
-    void set_attrs(Attributes attrs);
+    void set_attrs(Attributes&& attrs);
+    void set_attrs(const Attributes& attrs);
 
     bool visit_attributes(AttributeVisitor& visitor) override;
     bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;

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

@@ -68,8 +68,11 @@ class OPENVINO_API Proposal : public Op {
     /**
      * @brief Set the Proposal operator attributes.
      * @param attrs  Attributes to be set.
+     * @{
      */
-    void set_attrs(Attributes attrs);
+    void set_attrs(Attributes&& attrs);
+    void set_attrs(const Attributes& attrs);
+    /** @} */
 
     bool visit_attributes(AttributeVisitor& visitor) override;
 

src/core/include/openvino/pass/manager.hpp

@@ -90,8 +90,7 @@ class OPENVINO_API Manager {
     std::shared_ptr<T> push_pass(Args&&... args) {
         static_assert(std::is_base_of<pass::PassBase, T>::value, "pass not derived from pass base");
         auto pass = std::make_shared<T>(std::forward<Args>(args)...);
-        auto pass_base = std::static_pointer_cast<PassBase>(pass);
-        m_pass_list.push_back(pass_base);
+        m_pass_list.push_back(pass);
         return pass;
     }
 

src/core/reference/include/openvino/reference/reduce_mean.hpp

@@ -10,8 +10,7 @@
 #include "openvino/core/shape_util.hpp"
 #include "openvino/reference/reduce_sum.hpp"
 
-namespace ov {
-namespace reference {
+namespace ov::reference {
 
 /**
  * @brief Reference implementation of ReduceMean operator.
@@ -25,16 +24,13 @@ template <class T>
 void reduce_mean(const T* in, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
     reduce_sum(in, out, in_shape, reduction_axes);
 
-    const auto out_shape = util::reduce(in_shape, reduction_axes);
-    if (shape_size(in_shape) == 0) {
-        return;
+    if (const auto input_size = shape_size(in_shape); input_size != 0) {
+        const auto out_shape = util::reduce(in_shape, reduction_axes);
+        const auto out_size = shape_size(out_shape);
+        const auto count = input_size / out_size;
+        std::transform(out, std::next(out, out_size), out, [count = static_cast<T>(count)](auto&& value) -> T {
+            return value / count;
+        });
     }
-
-    const auto out_size = shape_size(out_shape);
-    const auto count = static_cast<T>(shape_size(in_shape) / out_size);
-    std::transform(out, std::next(out, out_size), out, [count](const T value) {
-        return value / count;
-    });
 }
-}  // namespace reference
-}  // namespace ov
+}  // namespace ov::reference

src/core/reference/include/openvino/reference/rounding_guard.hpp

@@ -23,6 +23,9 @@ class RoundingGuard {
     RoundingGuard(int mode);
     ~RoundingGuard();
 
+    RoundingGuard(const RoundingGuard&) = delete;
+    RoundingGuard& operator=(const RoundingGuard&) = delete;
+
 private:
     int m_prev_round_mode;
 };

src/core/reference/include/openvino/reference/scatter_elements_update.hpp

@@ -7,10 +7,12 @@
 #include <cfenv>
 #include <cstring>
 #include <iterator>
+#include <optional>
 
 #include "openvino/core/except.hpp"
 #include "openvino/core/shape.hpp"
 #include "openvino/op/scatter_elements_update.hpp"
+#include "openvino/reference/rounding_guard.hpp"
 #include "openvino/reference/utils/coordinate_index.hpp"
 #include "openvino/reference/utils/coordinate_transform.hpp"
 
@@ -133,25 +135,6 @@ typename std::enable_if<std::is_integral<T>::value, T>::type arithmetic_mean(con
     return value;
 }
 
-template <typename T>
-struct RoundingDirectionGuard {
-    RoundingDirectionGuard() {
-        if (std::is_integral<T>::value) {
-            m_original_mode = std::fegetround();
-            std::fesetround(FE_DOWNWARD);
-        }
-    }
-
-    ~RoundingDirectionGuard() {
-        if (std::is_integral<T>::value) {
-            std::fesetround(m_original_mode);
-        }
-    }
-
-private:
-    decltype(std::fegetround()) m_original_mode;
-};
-
 template <typename DataType>
 void scatter_elem_update_with_reduction(const int64_t* indices,
                                         const DataType* updates,
@@ -210,11 +193,14 @@ void scatter_elem_update_with_reduction(const int64_t* indices,
     if (reduction_type == ov::op::v12::ScatterElementsUpdate::Reduction::MEAN) {
         // this object will change the rounding mode only for integer types which is required to match torch
         // upon destruction the previously used rounding mode will be restored
-        RoundingDirectionGuard<DataType> rounding_guard;
-        for (const auto& counter : mean_reduction_counters) {
+        std::optional<RoundingGuard> r_guard;
+        if constexpr (std::is_integral_v<DataType>) {
+            r_guard.emplace(FE_DOWNWARD);
+        }
+        for (const auto& [idx, count] : mean_reduction_counters) {
             // include the initial value in the arithmetic mean divisor (if needed)
-            const auto N = counter.second + static_cast<int32_t>(use_init_val);
-            out_buf[counter.first] = arithmetic_mean<DataType>(out_buf[counter.first], N);
+            const auto N = count + static_cast<int32_t>(use_init_val);
+            out_buf[idx] = arithmetic_mean<DataType>(out_buf[idx], N);
         }
     }
 }