Merge remote-tracking branch 'upstream/master' into tj/rtti/as_type/p…

…lugins/cpu

src/common/low_precision_transformations/include/low_precision/add.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API AddTransformation : public EltwiseBaseTransformation {
 public:
-    OPENVINO_RTTI("AddTransformation", "0");
+    OPENVINO_RTTI("AddTransformation", "0", EltwiseBaseTransformation);
     AddTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/assign_and_read_value.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API AssignAndReadValueTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("AssignAndReadValueTransformation", "0");
+    OPENVINO_RTTI("AssignAndReadValueTransformation", "0", LayerTransformation);
     AssignAndReadValueTransformation(const std::shared_ptr<ov::Model> model, const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher& m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;

src/common/low_precision_transformations/include/low_precision/avg_pool.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API AvgPoolTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("AvgPoolTransformation", "0");
+    OPENVINO_RTTI("AvgPoolTransformation", "0", LayerTransformation);
     AvgPoolTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/batch_to_space.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API BatchToSpaceTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("BatchToSpaceTransformation", "0");
+    OPENVINO_RTTI("BatchToSpaceTransformation", "0", LayerTransformation);
     BatchToSpaceTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;

src/common/low_precision_transformations/include/low_precision/broadcast.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API BroadcastTransformation : public TransparentBaseTransformation {
 public:
-    OPENVINO_RTTI("BroadcastTransformation", "0");
+    OPENVINO_RTTI("BroadcastTransformation", "0", TransparentBaseTransformation);
     BroadcastTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<ov::Node> layer) const override;
 };

src/common/low_precision_transformations/include/low_precision/clamp.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ClampTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ClampTransformation", "0");
+    OPENVINO_RTTI("ClampTransformation", "0", LayerTransformation);
     ClampTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher& m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;

src/common/low_precision_transformations/include/low_precision/concat.hpp

@@ -29,7 +29,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ConcatTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ConcatTransformation", "0");
+    OPENVINO_RTTI("ConcatTransformation", "0", LayerTransformation);
     ConcatTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/convert.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API ConvertTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ConvertTransformation", "0");
+    OPENVINO_RTTI("ConvertTransformation", "0", LayerTransformation);
     ConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/convolution.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ConvolutionTransformation : public WeightableLayerTransformation {
 public:
-    OPENVINO_RTTI("ConvolutionTransformation", "0");
+    OPENVINO_RTTI("ConvolutionTransformation", "0", WeightableLayerTransformation);
     ConvolutionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isQuantized(const std::shared_ptr<const Node>& layer,

src/common/low_precision_transformations/include/low_precision/depth_to_space.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API DepthToSpaceTransformation : public TransparentBaseTransformation {
 public:
-    OPENVINO_RTTI("DepthToSpaceTransformation", "0");
+    OPENVINO_RTTI("DepthToSpaceTransformation", "0", TransparentBaseTransformation);
     DepthToSpaceTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<ov::Node> layer) const override;
 };

src/common/low_precision_transformations/include/low_precision/eliminate_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API EliminateFakeQuantizeTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("EliminateFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("EliminateFakeQuantizeTransformation", "0", CleanupTransformation);
     EliminateFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fake_quantize.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FakeQuantizeTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FakeQuantizeTransformation", "0", LayerTransformation);
     FakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fake_quantize_decomposition.hpp

@@ -23,7 +23,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FakeQuantizeDecompositionTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FakeQuantizeDecompositionTransformation", "0");
+    OPENVINO_RTTI("FakeQuantizeDecompositionTransformation", "0", LayerTransformation);
     FakeQuantizeDecompositionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fold_convert.hpp

@@ -23,7 +23,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FoldConvertTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("FoldConvertTransformation", "0");
+    OPENVINO_RTTI("FoldConvertTransformation", "0", CleanupTransformation);
     FoldConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fold_fake_quantize.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FoldFakeQuantizeTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FoldFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FoldFakeQuantizeTransformation", "0", LayerTransformation);
     FoldFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fuse_convert.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseConvertTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("FuseConvertTransformation", "0");
+    OPENVINO_RTTI("FuseConvertTransformation", "0", CleanupTransformation);
     FuseConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fuse_multiply_to_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseMultiplyToFakeQuantizeTransformation : public FuseElementwiseToFakeQuantizeTransformation {
 public:
-    OPENVINO_RTTI("FuseMultiplyToFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FuseMultiplyToFakeQuantizeTransformation", "0", FuseElementwiseToFakeQuantizeTransformation);
     FuseMultiplyToFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fuse_subtract_to_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseSubtractToFakeQuantizeTransformation : public FuseElementwiseToFakeQuantizeTransformation {
 public:
-    OPENVINO_RTTI("FuseSubtractToFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FuseSubtractToFakeQuantizeTransformation", "0", FuseElementwiseToFakeQuantizeTransformation);
     FuseSubtractToFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/gather.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API GatherTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("GatherTransformation", "0");
+    OPENVINO_RTTI("GatherTransformation", "0", LayerTransformation);
     GatherTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/group_convolution.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API GroupConvolutionTransformation : public ConvolutionTransformation {
 public:
-    OPENVINO_RTTI("GroupConvolutionTransformation", "0");
+    OPENVINO_RTTI("GroupConvolutionTransformation", "0", ConvolutionTransformation);
     GroupConvolutionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isQuantized(const std::shared_ptr<const Node>& layer,

src/common/low_precision_transformations/include/low_precision/interpolate.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API InterpolateTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("InterpolateTransformation", "0");
+    OPENVINO_RTTI("InterpolateTransformation", "0", LayerTransformation);
     InterpolateTransformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/mat_mul.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MatMulTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MatMulTransformation", "0");
+    OPENVINO_RTTI("MatMulTransformation", "0", LayerTransformation);
     MatMulTransformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/max_pool.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MaxPoolTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MaxPoolTransformation", "0");
+    OPENVINO_RTTI("MaxPoolTransformation", "0", LayerTransformation);
     MaxPoolTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;

src/common/low_precision_transformations/include/low_precision/move_fake_quantize.hpp

@@ -14,7 +14,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API MoveFakeQuantize : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MoveFakeQuantize", "0");
+    OPENVINO_RTTI("MoveFakeQuantize", "0", LayerTransformation);
     MoveFakeQuantize(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/multiply.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MultiplyTransformation : public WeightableLayerTransformation {
 public:
-    OPENVINO_RTTI("MultiplyTransformation", "0");
+    OPENVINO_RTTI("MultiplyTransformation", "0", WeightableLayerTransformation);
     MultiplyTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
 

src/common/low_precision_transformations/include/low_precision/multiply_partial.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MultiplyPartialTransformation : public EltwiseBaseTransformation {
 public:
-    OPENVINO_RTTI("MultiplyPartialTransformation", "0");
+    OPENVINO_RTTI("MultiplyPartialTransformation", "0", EltwiseBaseTransformation);
     MultiplyPartialTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/multiply_to_group_convolution.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MultiplyToGroupConvolutionTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("MultiplyToGroupConvolutionTransformation", "0");
+    OPENVINO_RTTI("MultiplyToGroupConvolutionTransformation", "0", CleanupTransformation);
     MultiplyToGroupConvolutionTransformation(
         const Params& params = Params(),
         const PrecisionsRestriction::PrecisionsByPorts& restrictions = {});

src/common/low_precision_transformations/include/low_precision/mvn.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MVNTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MVNTransformation", "0");
+    OPENVINO_RTTI("MVNTransformation", "0", LayerTransformation);
     MVNTransformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/normalize_l2.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API NormalizeL2Transformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("NormalizeL2Transformation", "0");
+    OPENVINO_RTTI("NormalizeL2Transformation", "0", LayerTransformation);
     NormalizeL2Transformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/pad.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API PadTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("PadTransformation", "0");
+    OPENVINO_RTTI("PadTransformation", "0", LayerTransformation);
     PadTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, pattern::Matcher& m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;

src/common/low_precision_transformations/include/low_precision/prelu.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API PReluTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("PReluTransformation", "0");
+    OPENVINO_RTTI("PReluTransformation", "0", LayerTransformation);
     PReluTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/recurrent_cell.hpp

@@ -14,7 +14,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API RecurrentCellTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("RecurrentCellTransformation", "0");
+    OPENVINO_RTTI("RecurrentCellTransformation", "0", LayerTransformation);
     RecurrentCellTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/reduce_max.hpp

@@ -24,7 +24,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReduceMaxTransformation : public ReduceBaseTransformation {
 public:
-    OPENVINO_RTTI("ReduceMaxTransformation", "0");
+    OPENVINO_RTTI("ReduceMaxTransformation", "0", ReduceBaseTransformation);
     ReduceMaxTransformation(const Params& params = Params());
     bool isPrecisionPreserved(std::shared_ptr<Node> reduce) const noexcept override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> reduce) const override;

src/common/low_precision_transformations/include/low_precision/reduce_mean.hpp

@@ -24,7 +24,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReduceMeanTransformation : public ReduceBaseTransformation {
 public:
-    OPENVINO_RTTI("ReduceMeanTransformation", "0");
+    OPENVINO_RTTI("ReduceMeanTransformation", "0", ReduceBaseTransformation);
     ReduceMeanTransformation(const Params& params = Params());
     bool isPrecisionPreserved(std::shared_ptr<Node> reduce) const noexcept override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> reduce) const override;

src/common/low_precision_transformations/include/low_precision/reduce_min.hpp

@@ -24,7 +24,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReduceMinTransformation : public ReduceBaseTransformation {
 public:
-    OPENVINO_RTTI("ReduceMinTransformation", "0");
+    OPENVINO_RTTI("ReduceMinTransformation", "0", ReduceBaseTransformation);
     ReduceMinTransformation(const Params& params = Params());
     bool isPrecisionPreserved(std::shared_ptr<Node> reduce) const noexcept override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> reduce) const override;

src/common/low_precision_transformations/include/low_precision/reduce_sum.hpp

@@ -24,7 +24,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReduceSumTransformation : public ReduceBaseTransformation {
 public:
-    OPENVINO_RTTI("ReduceSumTransformation", "0");
+    OPENVINO_RTTI("ReduceSumTransformation", "0", ReduceBaseTransformation);
     ReduceSumTransformation(const Params& params = Params());
     bool isPrecisionPreserved(std::shared_ptr<Node> reduce) const noexcept override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> reduce) const override;

src/common/low_precision_transformations/include/low_precision/relu.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReluTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ReluTransformation", "0");
+    OPENVINO_RTTI("ReluTransformation", "0", LayerTransformation);
     ReluTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/reshape.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ReshapeTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ReshapeTransformation", "0");
+    OPENVINO_RTTI("ReshapeTransformation", "0", LayerTransformation);
     ReshapeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;