codedex

mindspore/lite/tools/converter/parser/tflite/tflite_activation_parser.h

@@ -29,6 +29,8 @@ class TfliteReluParser : public TfliteNodeParser {
  public:
   TfliteReluParser() : TfliteNodeParser("Relu") {}
 
+  ~TfliteReluParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -37,6 +39,8 @@ class TfliteRelu6Parser : public TfliteNodeParser {
  public:
   TfliteRelu6Parser() : TfliteNodeParser("Relu6") {}
 
+  ~TfliteRelu6Parser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -45,6 +49,8 @@ class TfliteLeakyReluParser : public TfliteNodeParser {
  public:
   TfliteLeakyReluParser() : TfliteNodeParser("LeakyRelu") {}
 
+  ~TfliteLeakyReluParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -53,6 +59,8 @@ class TflitePReLUParser : public TfliteNodeParser {
  public:
   TflitePReLUParser() : TfliteNodeParser("PReLU") {}
 
+  ~TflitePReLUParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -61,6 +69,8 @@ class TfliteTanhParser : public TfliteNodeParser {
  public:
   TfliteTanhParser() : TfliteNodeParser("Tanh") {}
 
+  ~TfliteTanhParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -69,6 +79,8 @@ class TfliteHardSwishParser : public TfliteNodeParser {
  public:
   TfliteHardSwishParser() : TfliteNodeParser("HardSwish") {}
 
+  ~TfliteHardSwishParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -77,6 +89,8 @@ class TfliteLogisticParser : public TfliteNodeParser {
  public:
   TfliteLogisticParser() : TfliteNodeParser("Logistic") {}
 
+  ~TfliteLogisticParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_addn_parser.h

@@ -29,6 +29,8 @@ class TfliteAddNParser : public TfliteNodeParser {
  public:
   TfliteAddNParser() : TfliteNodeParser("AddN") {}
 
+  ~TfliteAddNParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_argmax_parser.h

@@ -29,6 +29,8 @@ class TfliteArgmaxParser : public TfliteNodeParser {
  public:
   TfliteArgmaxParser() : TfliteNodeParser("Argmax") {}
 
+  ~TfliteArgmaxParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_argmin_parser.h

@@ -29,6 +29,8 @@ class TfliteArgminParser : public TfliteNodeParser {
  public:
   TfliteArgminParser() : TfliteNodeParser("Argmin") {}
 
+  ~TfliteArgminParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_arithmetic_parser.h

@@ -29,6 +29,8 @@ class TfliteAddParser : public TfliteNodeParser {
  public:
   TfliteAddParser() : TfliteNodeParser("Add") {}
 
+  ~TfliteAddParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -37,6 +39,8 @@ class TfliteSubParser : public TfliteNodeParser {
  public:
   TfliteSubParser() : TfliteNodeParser("Sub") {}
 
+  ~TfliteSubParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -45,6 +49,8 @@ class TfliteMulParser : public TfliteNodeParser {
  public:
   TfliteMulParser() : TfliteNodeParser("Mul") {}
 
+  ~TfliteMulParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -53,6 +59,8 @@ class TfliteDivParser : public TfliteNodeParser {
  public:
   TfliteDivParser() : TfliteNodeParser("Div") {}
 
+  ~TfliteDivParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -61,6 +69,8 @@ class TfliteFloorDivParser : public TfliteNodeParser {
  public:
   TfliteFloorDivParser() : TfliteNodeParser("FloorDiv") {}
 
+  ~TfliteFloorDivParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -69,6 +79,8 @@ class TfliteFloorModParser : public TfliteNodeParser {
  public:
   TfliteFloorModParser() : TfliteNodeParser("FloorMod") {}
 
+  ~TfliteFloorModParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -77,6 +89,8 @@ class TflitePowParser : public TfliteNodeParser {
  public:
   TflitePowParser() : TfliteNodeParser("PowFusion") {}
 
+  ~TflitePowParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -85,6 +99,8 @@ class TfliteSquaredDifferenceParser : public TfliteNodeParser {
  public:
   TfliteSquaredDifferenceParser() : TfliteNodeParser("SquaredDifference") {}
 
+  ~TfliteSquaredDifferenceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -93,6 +109,8 @@ class TfliteMaximumParser : public TfliteNodeParser {
  public:
   TfliteMaximumParser() : TfliteNodeParser("Maximum") {}
 
+  ~TfliteMaximumParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -101,6 +119,8 @@ class TfliteMinimumParser : public TfliteNodeParser {
  public:
   TfliteMinimumParser() : TfliteNodeParser("Minimum") {}
 
+  ~TfliteMinimumParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -109,6 +129,8 @@ class TfliteAbsParser : public TfliteNodeParser {
  public:
   TfliteAbsParser() : TfliteNodeParser("Abs") {}
 
+  ~TfliteAbsParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -117,6 +139,8 @@ class TfliteExpParser : public TfliteNodeParser {
  public:
   TfliteExpParser() : TfliteNodeParser("Exp") {}
 
+  ~TfliteExpParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -125,6 +149,8 @@ class TfliteSqrtParser : public TfliteNodeParser {
  public:
   TfliteSqrtParser() : TfliteNodeParser("Sqrt") {}
 
+  ~TfliteSqrtParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -133,6 +159,8 @@ class TfliteRsqrtParser : public TfliteNodeParser {
  public:
   TfliteRsqrtParser() : TfliteNodeParser("Rsqrt") {}
 
+  ~TfliteRsqrtParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -141,6 +169,8 @@ class TfliteSquareParser : public TfliteNodeParser {
  public:
   TfliteSquareParser() : TfliteNodeParser("Square") {}
 
+  ~TfliteSquareParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -149,6 +179,8 @@ class TfliteSinParser : public TfliteNodeParser {
  public:
   TfliteSinParser() : TfliteNodeParser("Sin") {}
 
+  ~TfliteSinParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -157,6 +189,8 @@ class TfliteCosParser : public TfliteNodeParser {
  public:
   TfliteCosParser() : TfliteNodeParser("Cos") {}
 
+  ~TfliteCosParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -165,6 +199,8 @@ class TfliteLogParser : public TfliteNodeParser {
  public:
   TfliteLogParser() : TfliteNodeParser("Log") {}
 
+  ~TfliteLogParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -173,6 +209,8 @@ class TfliteRoundParser : public TfliteNodeParser {
  public:
   TfliteRoundParser() : TfliteNodeParser("Round") {}
 
+  ~TfliteRoundParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -181,6 +219,8 @@ class TfliteCeilParser : public TfliteNodeParser {
  public:
   TfliteCeilParser() : TfliteNodeParser("Ceil") {}
 
+  ~TfliteCeilParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -189,6 +229,8 @@ class TfliteFloorParser : public TfliteNodeParser {
  public:
   TfliteFloorParser() : TfliteNodeParser("Floor") {}
 
+  ~TfliteFloorParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -197,6 +239,8 @@ class TfliteNegParser : public TfliteNodeParser {
  public:
   TfliteNegParser() : TfliteNodeParser("Neg") {}
 
+  ~TfliteNegParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -205,6 +249,8 @@ class TfliteEqualParser : public TfliteNodeParser {
  public:
   TfliteEqualParser() : TfliteNodeParser("Equal") {}
 
+  ~TfliteEqualParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -213,6 +259,8 @@ class TfliteNotEqualParser : public TfliteNodeParser {
  public:
   TfliteNotEqualParser() : TfliteNodeParser("NotEqual") {}
 
+  ~TfliteNotEqualParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -221,6 +269,8 @@ class TfliteGreaterParser : public TfliteNodeParser {
  public:
   TfliteGreaterParser() : TfliteNodeParser("Greater") {}
 
+  ~TfliteGreaterParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -229,6 +279,8 @@ class TfliteGreaterEqualParser : public TfliteNodeParser {
  public:
   TfliteGreaterEqualParser() : TfliteNodeParser("GreaterEqual") {}
 
+  ~TfliteGreaterEqualParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -237,6 +289,8 @@ class TfliteLessParser : public TfliteNodeParser {
  public:
   TfliteLessParser() : TfliteNodeParser("Less") {}
 
+  ~TfliteLessParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -245,6 +299,8 @@ class TfliteLessEqualParser : public TfliteNodeParser {
  public:
   TfliteLessEqualParser() : TfliteNodeParser("LessEqual") {}
 
+  ~TfliteLessEqualParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_batch_to_space_parser.h

@@ -29,6 +29,8 @@ class TfliteBatchToSpaceParser : public TfliteNodeParser {
  public:
   TfliteBatchToSpaceParser() : TfliteNodeParser("BatchToSpace") {}
 
+  ~TfliteBatchToSpaceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_broadcast_to_parser.h

@@ -29,6 +29,8 @@ class TfliteBroadcastToParser : public TfliteNodeParser {
  public:
   TfliteBroadcastToParser() : TfliteNodeParser("BroadcastTo") {}
 
+  ~TfliteBroadcastToParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_cast_parser.h

@@ -29,6 +29,8 @@ class TfliteCastParser : public TfliteNodeParser {
  public:
   TfliteCastParser() : TfliteNodeParser("Cast") {}
 
+  ~TfliteCastParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_concat_parser.h

@@ -29,6 +29,8 @@ class TfliteConcatParser : public TfliteNodeParser {
  public:
   TfliteConcatParser() : TfliteNodeParser("Concat") {}
 
+  ~TfliteConcatParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_conv_parser.h

@@ -29,6 +29,8 @@ class TfliteConvParser : public TfliteNodeParser {
  public:
   TfliteConvParser() : TfliteNodeParser("Conv2D") {}
 
+  ~TfliteConvParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -37,6 +39,8 @@ class TfliteDepthwiseConv2DParser : public TfliteNodeParser {
  public:
   TfliteDepthwiseConv2DParser() : TfliteNodeParser("DepthwiseConv2D") {}
 
+  ~TfliteDepthwiseConv2DParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_conv_transpose_parser.h

@@ -29,6 +29,8 @@ class TfliteDeConvParser : public TfliteNodeParser {
  public:
   TfliteDeConvParser() : TfliteNodeParser("DeConv2D") {}
 
+  ~TfliteDeConvParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_custom_parser.h

@@ -29,6 +29,8 @@ class TfliteCustomParser : public TfliteNodeParser {
  public:
   TfliteCustomParser() : TfliteNodeParser("Custom") {}
 
+  ~TfliteCustomParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 

mindspore/lite/tools/converter/parser/tflite/tflite_depth_to_space_parser.h

@@ -29,6 +29,8 @@ class TfliteDepthToSpaceParser : public TfliteNodeParser {
  public:
   TfliteDepthToSpaceParser() : TfliteNodeParser("DepthToSpace") {}
 
+  ~TfliteDepthToSpaceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_dequantize_parser.h

@@ -28,6 +28,8 @@ class TfliteDequantizeParser : public TfliteNodeParser {
  public:
   TfliteDequantizeParser() : TfliteNodeParser("Dequantize") {}
 
+  ~TfliteDequantizeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_expand_dims_parser.h

@@ -29,6 +29,8 @@ class TfliteExpandDimsParser : public TfliteNodeParser {
  public:
   TfliteExpandDimsParser() : TfliteNodeParser("ExpandDims") {}
 
+  ~TfliteExpandDimsParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_fill_parser.h

@@ -29,6 +29,8 @@ class TfliteFillParser : public TfliteNodeParser {
  public:
   TfliteFillParser() : TfliteNodeParser("Fill") {}
 
+  ~TfliteFillParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_fullyconnected_parser.h

@@ -29,6 +29,8 @@ class TfliteFullyConnectedParser : public TfliteNodeParser {
  public:
   TfliteFullyConnectedParser() : TfliteNodeParser("FullyConnected") {}
 
+  ~TfliteFullyConnectedParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_gather_nd_parser.h

@@ -29,6 +29,8 @@ class TfliteGatherNdParser : public TfliteNodeParser {
  public:
   TfliteGatherNdParser() : TfliteNodeParser("GatherND") {}
 
+  ~TfliteGatherNdParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_gather_parser.h

@@ -29,6 +29,8 @@ class TfliteGatherParser : public TfliteNodeParser {
  public:
   TfliteGatherParser() : TfliteNodeParser("Gather") {}
 
+  ~TfliteGatherParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_hashtable_lookup_parser.h

@@ -29,6 +29,8 @@ class TfliteHashtableLookupParser : public TfliteNodeParser {
  public:
   TfliteHashtableLookupParser() : TfliteNodeParser("HashtableLookup") {}
 
+  ~TfliteHashtableLookupParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_l2norm_parser.h

@@ -29,6 +29,8 @@ class TfliteL2NormParser : public TfliteNodeParser {
  public:
   TfliteL2NormParser() : TfliteNodeParser("L2_NORMALIZATION") {}
 
+  ~TfliteL2NormParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_logical_parser.h

@@ -29,6 +29,8 @@ class TfliteLogicalAndParser : public TfliteNodeParser {
  public:
   TfliteLogicalAndParser() : TfliteNodeParser("LogicalAnd") {}
 
+  ~TfliteLogicalAndParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_lrn_parser.h

@@ -29,6 +29,8 @@ class TfliteLRNParser : public TfliteNodeParser {
  public:
   TfliteLRNParser() : TfliteNodeParser("LocalResponseNorm") {}
 
+  ~TfliteLRNParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_lsh_projection_parser.h

@@ -29,6 +29,8 @@ class TfliteLshProjectionParser : public TfliteNodeParser {
  public:
   TfliteLshProjectionParser() : TfliteNodeParser("LshProjection") {}
 
+  ~TfliteLshProjectionParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_matmul_parser.h

@@ -28,6 +28,8 @@ class TfliteMatMulParser : public TfliteNodeParser {
  public:
   TfliteMatMulParser() : TfliteNodeParser("MatMul") {}
 
+  ~TfliteMatMulParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h

@@ -42,6 +42,8 @@ class TfliteNodeRegister {
   TfliteNodeRegister(const tflite::BuiltinOperator &type, TfliteNodeParser *parser) {
     TfliteNodeParserRegistry::GetInstance()->parsers[type] = parser;
   }
+
+  ~TfliteNodeRegister() = default;
 };
 }  // namespace lite
 }  // namespace mindspore

mindspore/lite/tools/converter/parser/tflite/tflite_one_hot_parser.h

@@ -29,6 +29,8 @@ class TfliteOneHotParser : public TfliteNodeParser {
  public:
   TfliteOneHotParser() : TfliteNodeParser("OneHot") {}
 
+  ~TfliteOneHotParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.h

@@ -29,6 +29,8 @@ class TflitePadParser : public TfliteNodeParser {
  public:
   TflitePadParser() : TfliteNodeParser("Pad") {}
 
+  ~TflitePadParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_pooling_parser.h

@@ -29,6 +29,8 @@ class TfliteAvgPoolParser : public TfliteNodeParser {
  public:
   TfliteAvgPoolParser() : TfliteNodeParser("avg_pool") {}
 
+  ~TfliteAvgPoolParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };
@@ -37,6 +39,8 @@ class TfliteMaxPoolParser : public TfliteNodeParser {
  public:
   TfliteMaxPoolParser() : TfliteNodeParser("max_pool") {}
 
+  ~TfliteMaxPoolParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_quantize_parser.h

@@ -28,6 +28,8 @@ class TfliteQuantizeParser : public TfliteNodeParser {
  public:
   TfliteQuantizeParser() : TfliteNodeParser("Quantize") {}
 
+  ~TfliteQuantizeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_range_parser.h

@@ -29,6 +29,8 @@ class TfliteRangeParser : public TfliteNodeParser {
  public:
   TfliteRangeParser() : TfliteNodeParser("Range") {}
 
+  ~TfliteRangeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_rank_parser.h

@@ -29,6 +29,8 @@ class TfliteRankParser : public TfliteNodeParser {
  public:
   TfliteRankParser() : TfliteNodeParser("Rank") {}
 
+  ~TfliteRankParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_reduce_parser.h

@@ -28,6 +28,8 @@ class TfliteReduceParser : public TfliteNodeParser {
  public:
   TfliteReduceParser() : TfliteNodeParser("node_name") {}
 
+  ~TfliteReduceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_reshape_parser.h

@@ -29,6 +29,8 @@ class TfliteReshapeParser : public TfliteNodeParser {
  public:
   TfliteReshapeParser() : TfliteNodeParser("Reshape") {}
 
+  ~TfliteReshapeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_resize_parser.h

@@ -28,6 +28,8 @@ class TfliteResizeParser : public TfliteNodeParser {
  public:
   TfliteResizeParser() : TfliteNodeParser("resize_bilinear") {}
 
+  ~TfliteResizeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_reverse_parser.h

@@ -29,6 +29,8 @@ class TfliteReverseParser : public TfliteNodeParser {
  public:
   TfliteReverseParser() : TfliteNodeParser("reverse") {}
 
+  ~TfliteReverseParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_reverse_sequence_parser.h

@@ -29,6 +29,8 @@ class TfliteReverseSequenceParser : public TfliteNodeParser {
  public:
   TfliteReverseSequenceParser() : TfliteNodeParser("ReverseSequence") {}
 
+  ~TfliteReverseSequenceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_scatter_nd_parser.h

@@ -29,6 +29,8 @@ class TfliteScatterNdParser : public TfliteNodeParser {
  public:
   TfliteScatterNdParser() : TfliteNodeParser("ScatterNd") {}
 
+  ~TfliteScatterNdParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_shape_parser.h

@@ -29,6 +29,8 @@ class TfliteShapeParser : public TfliteNodeParser {
  public:
   TfliteShapeParser() : TfliteNodeParser("Shape") {}
 
+  ~TfliteShapeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_skip_gram_parser.h

@@ -29,6 +29,8 @@ class TfliteSkipGramParser : public TfliteNodeParser {
  public:
   TfliteSkipGramParser() : TfliteNodeParser("SkipGram") {}
 
+  ~TfliteSkipGramParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_slice_parser.h

@@ -29,6 +29,8 @@ class TfliteSliceParser : public TfliteNodeParser {
  public:
   TfliteSliceParser() : TfliteNodeParser("Slice") {}
 
+  ~TfliteSliceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_softmax_parser.h

@@ -29,6 +29,8 @@ class TfliteSoftmaxParser : public TfliteNodeParser {
  public:
   TfliteSoftmaxParser() : TfliteNodeParser("Softmax") {}
 
+  ~TfliteSoftmaxParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_space_to_batch_nd_parser.h

@@ -29,6 +29,8 @@ class TfliteSpaceToBatchNDParser : public TfliteNodeParser {
  public:
   TfliteSpaceToBatchNDParser() : TfliteNodeParser("SpaceToBatchND") {}
 
+  ~TfliteSpaceToBatchNDParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_space_to_depth_parser.h

@@ -29,6 +29,8 @@ class TfliteSpaceToDepthParser : public TfliteNodeParser {
  public:
   TfliteSpaceToDepthParser() : TfliteNodeParser("SpaceToDepth") {}
 
+  ~TfliteSpaceToDepthParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_sparse_to_dense_parser.h

@@ -29,6 +29,8 @@ class TfliteSparseToDenseParser : public TfliteNodeParser {
  public:
   TfliteSparseToDenseParser() : TfliteNodeParser("SparseToDense") {}
 
+  ~TfliteSparseToDenseParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_split_parser.h

@@ -29,6 +29,8 @@ class TfliteSplitParser : public TfliteNodeParser {
  public:
   TfliteSplitParser() : TfliteNodeParser("Split") {}
 
+  ~TfliteSplitParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_split_v_parser.h

@@ -29,6 +29,8 @@ class TfliteSplitVParser : public TfliteNodeParser {
  public:
   TfliteSplitVParser() : TfliteNodeParser("SplitV") {}
 
+  ~TfliteSplitVParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_squeeze_parser.h

@@ -29,6 +29,8 @@ class TfliteSqueezeParser : public TfliteNodeParser {
  public:
   TfliteSqueezeParser() : TfliteNodeParser("Squeeze") {}
 
+  ~TfliteSqueezeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_stack_parser.h

@@ -29,6 +29,8 @@ class TfliteStackParser : public TfliteNodeParser {
  public:
   TfliteStackParser() : TfliteNodeParser("Stack") {}
 
+  ~TfliteStackParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_strided_slice_parser.h

@@ -29,6 +29,8 @@ class TfliteStridedSliceParser : public TfliteNodeParser {
  public:
   TfliteStridedSliceParser() : TfliteNodeParser("StridedSlice") {}
 
+  ~TfliteStridedSliceParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_tile_parser.h

@@ -29,6 +29,8 @@ class TfliteTileParser : public TfliteNodeParser {
  public:
   TfliteTileParser() : TfliteNodeParser("Tile") {}
 
+  ~TfliteTileParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_topk_v2_parser.h

@@ -29,6 +29,8 @@ class TfliteTopKV2Parser : public TfliteNodeParser {
  public:
   TfliteTopKV2Parser() : TfliteNodeParser("TopKV2") {}
 
+  ~TfliteTopKV2Parser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_transpose_parser.h

@@ -29,6 +29,8 @@ class TfliteTransposeParser : public TfliteNodeParser {
  public:
   TfliteTransposeParser() : TfliteNodeParser("Transpose") {}
 
+  ~TfliteTransposeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_unique_parser.h

@@ -29,6 +29,8 @@ class TfliteUniqueParser : public TfliteNodeParser {
  public:
   TfliteUniqueParser() : TfliteNodeParser("Unique") {}
 
+  ~TfliteUniqueParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_unstack_parser.h

@@ -29,6 +29,8 @@ class TfliteUnstackParser : public TfliteNodeParser {
  public:
   TfliteUnstackParser() : TfliteNodeParser("Unstack") {}
 
+  ~TfliteUnstackParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_where_parser.h

@@ -29,6 +29,8 @@ class TfliteWhereParser : public TfliteNodeParser {
  public:
   TfliteWhereParser() : TfliteNodeParser("Where") {}
 
+  ~TfliteWhereParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_while_parser.h

@@ -29,6 +29,8 @@ class TfliteWhileParser : public TfliteNodeParser {
  public:
   TfliteWhileParser() : TfliteNodeParser("While") {}
 
+  ~TfliteWhileParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/converter/parser/tflite/tflite_zeros_like_parser.h

@@ -29,6 +29,8 @@ class TfliteZerosLikeParser : public TfliteNodeParser {
  public:
   TfliteZerosLikeParser() : TfliteNodeParser("ZerosLike") {}
 
+  ~TfliteZerosLikeParser() override = default;
+
   ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
                          const std::unique_ptr<tflite::ModelT> &tflite_model) override;
 };

mindspore/lite/tools/optimizer/graph/functionalize_cond.h

@@ -36,6 +36,8 @@ class FunctionalizeCond {
  public:
   FunctionalizeCond(FuncGraphPtr fg, CNodePtr merge_node) : fg_(fg), merge_node_(merge_node) {}
 
+  ~FunctionalizeCond() = default;
+
   STATUS Process();
 
  private:

mindspore/lite/tools/optimizer/graph/functionalize_while.h

@@ -35,6 +35,8 @@ class FunctionalizeWhile {
   FunctionalizeWhile(std::vector<AnfNodePtr> node_cluster, const CNodePtr &loop_cond_node, FuncGraphPtr fg)
       : node_cluster_(node_cluster), loop_cond_node_(loop_cond_node), fg_(fg) {}
 
+  ~FunctionalizeWhile() = default;
+
   // while
   STATUS BuildWhileNode();
   STATUS IdentifyWhileNodeInput();