Fix CI warning, use CONST_POINTER in node build

Signed-off-by: alex-yuyue <yue.yu1@huawei.com>

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/batch_node.cc

@@ -93,7 +93,7 @@ Status BatchNode::ValidateParams() {
   return Status::OK();
 }
 
-Status BatchNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status BatchNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
 #ifdef ENABLE_PYTHON
   // if col_order_ isn't empty, then a project node needs to be attached after batch node. (same as map)
   // this means project_node needs to be the parent of batch_node. this means *node_ops = [project_node, batch_node]

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/batch_node.h

@@ -60,7 +60,7 @@ class BatchNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/bucket_batch_by_length_node.cc

@@ -82,7 +82,7 @@ void BucketBatchByLengthNode::Print(std::ostream &out) const {
   out << ")";
 }
 
-Status BucketBatchByLengthNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status BucketBatchByLengthNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   bucket_boundaries_.insert(bucket_boundaries_.begin(), 0);
   node_ops->push_back(std::make_shared<BucketBatchByLengthOp>(
     column_names_, bucket_boundaries_, bucket_batch_sizes_, element_length_function_, pad_info_,

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/bucket_batch_by_length_node.h

@@ -55,7 +55,7 @@ class BucketBatchByLengthNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/build_sentence_piece_vocab_node.cc

@@ -54,7 +54,7 @@ void BuildSentenceVocabNode::Print(std::ostream &out) const {
 }
 
 // Function to build BuildSentenceVocabNode
-Status BuildSentenceVocabNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status BuildSentenceVocabNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::shared_ptr<BuildSentencePieceVocabOp> build_sentence_piece_vocab_op;
   build_sentence_piece_vocab_op = std::make_shared<BuildSentencePieceVocabOp>(
     vocab_, col_names_, vocab_size_, character_coverage_, model_type_, params_, connector_que_size_);

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/build_sentence_piece_vocab_node.h

@@ -53,7 +53,7 @@ class BuildSentenceVocabNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/build_vocab_node.cc

@@ -50,7 +50,7 @@ void BuildVocabNode::Print(std::ostream &out) const {
 }
 
 // Function to build BuildVocabNode
-Status BuildVocabNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status BuildVocabNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::shared_ptr<BuildVocabOp> build_vocab_op;
   build_vocab_op = std::make_shared<BuildVocabOp>(vocab_, columns_, freq_range_, top_k_, special_tokens_,
                                                   special_first_, num_workers_, connector_que_size_);

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/build_vocab_node.h

@@ -52,7 +52,7 @@ class BuildVocabNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/concat_node.cc

@@ -72,7 +72,7 @@ Status ConcatNode::ValidateParams() {
   return Status::OK();
 }
 
-Status ConcatNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ConcatNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   if (children_flag_and_nums_.empty() || children_start_end_index_.empty()) {
     node_ops->push_back(std::make_shared<ConcatOp>(connector_que_size_));
   } else {

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/concat_node.h

@@ -53,7 +53,7 @@ class ConcatNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/dataset_node.h

@@ -148,7 +148,7 @@ class DatasetNode : public std::enable_shared_from_this<DatasetNode> {
   /// \brief Pure virtual function to convert a DatasetNode class into a runtime dataset object
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  virtual Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) = 0;
+  virtual Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) = 0;
 
   /// \brief base virtual function for derived class to implement parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/epoch_ctrl_node.cc

@@ -41,7 +41,7 @@ std::shared_ptr<DatasetNode> EpochCtrlNode::Copy() {
 void EpochCtrlNode::Print(std::ostream &out) const { out << Name() + "(epoch:" + std::to_string(num_epochs_) + ")"; }
 
 // Function to build the EpochCtrlOp
-Status EpochCtrlNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status EpochCtrlNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<EpochCtrlOp>(num_epochs_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/epoch_ctrl_node.h

@@ -52,7 +52,7 @@ class EpochCtrlNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/filter_node.cc

@@ -43,7 +43,7 @@ void FilterNode::Print(std::ostream &out) const {
   out << Name() + "(<predicate>," + "input_cols:" + PrintColumns(input_columns_) + ")";
 }
 
-Status FilterNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status FilterNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<FilterOp>(input_columns_, num_workers_, connector_que_size_, predicate_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/filter_node.h

@@ -50,7 +50,7 @@ class FilterNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/map_node.cc

@@ -54,7 +54,7 @@ void MapNode::Print(std::ostream &out) const {
       << operations_.size() << ",...)";
 }
 
-Status MapNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status MapNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::vector<std::shared_ptr<TensorOp>> tensor_ops;
 
   // Build tensorOp from tensorOperation vector

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/map_node.h

@@ -52,7 +52,7 @@ class MapNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/project_node.cc

@@ -52,7 +52,7 @@ Status ProjectNode::ValidateParams() {
   return Status::OK();
 }
 
-Status ProjectNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ProjectNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<ProjectOp>(columns_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/project_node.h

@@ -49,7 +49,7 @@ class ProjectNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/rename_node.cc

@@ -57,7 +57,7 @@ Status RenameNode::ValidateParams() {
   return Status::OK();
 }
 
-Status RenameNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status RenameNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<RenameOp>(input_columns_, output_columns_, connector_que_size_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/rename_node.h

@@ -50,7 +50,7 @@ class RenameNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/repeat_node.cc

@@ -37,7 +37,7 @@ std::shared_ptr<DatasetNode> RepeatNode::Copy() {
 
 void RepeatNode::Print(std::ostream &out) const { out << Name() + "(count:" + std::to_string(repeat_count_) + ")"; }
 
-Status RepeatNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status RepeatNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<RepeatOp>(repeat_count_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/repeat_node.h

@@ -51,7 +51,7 @@ class RepeatNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/root_node.cc

@@ -40,7 +40,7 @@ std::shared_ptr<DatasetNode> RootNode::Copy() {
 
 void RootNode::Print(std::ostream &out) const { out << Name(); }
 
-Status RootNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status RootNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // root node doesn't build a runtime Op. this function should return Status::Error when called.
   std::string err_msg = "Root node doesn't build a runtime Op";
   MS_LOG(ERROR) << err_msg;

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/root_node.h

@@ -52,7 +52,7 @@ class RootNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Getter of number of epochs
   int32_t num_epochs() { return num_epochs_; }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/shuffle_node.cc

@@ -43,7 +43,7 @@ void ShuffleNode::Print(std::ostream &out) const {
 }
 
 // Function to build the ShuffleOp
-Status ShuffleNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ShuffleNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<ShuffleOp>(shuffle_size_, shuffle_seed_, connector_que_size_, reset_every_epoch_,
                                                   rows_per_buffer_));
   return Status::OK();

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/shuffle_node.h

@@ -49,7 +49,7 @@ class ShuffleNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   Status ValidateParams() override;
 

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/skip_node.cc

@@ -38,7 +38,7 @@ std::shared_ptr<DatasetNode> SkipNode::Copy() {
 void SkipNode::Print(std::ostream &out) const { out << Name() + "(skip_count:" + std::to_string(skip_count_) + ")"; }
 
 // Function to build the SkipOp
-Status SkipNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status SkipNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<SkipOp>(skip_count_, connector_que_size_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/skip_node.h

@@ -49,7 +49,7 @@ class SkipNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/album_node.cc

@@ -65,7 +65,7 @@ Status AlbumNode::ValidateParams() {
 }
 
 // Function to build AlbumNode
-Status AlbumNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status AlbumNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   auto schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->LoadSchemaFile(schema_path_, column_names_));
 

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/album_node.h

@@ -51,7 +51,7 @@ class AlbumNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/celeba_node.cc

@@ -61,7 +61,7 @@ Status CelebANode::ValidateParams() {
 }
 
 // Function to build CelebANode
-Status CelebANode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status CelebANode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::unique_ptr<DataSchema> schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->AddColumn(ColDescriptor("image", DataType(DataType::DE_UINT8), TensorImpl::kFlexible, 1)));
   // label is like this:0 1 0 0 1......

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/celeba_node.h

@@ -52,7 +52,7 @@ class CelebANode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/cifar100_node.cc

@@ -54,7 +54,7 @@ Status Cifar100Node::ValidateParams() {
 }
 
 // Function to build CifarOp for Cifar100
-Status Cifar100Node::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status Cifar100Node::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Do internal Schema generation.
   auto schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->AddColumn(ColDescriptor("image", DataType(DataType::DE_UINT8), TensorImpl::kCv, 1)));

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/cifar100_node.h

@@ -50,7 +50,7 @@ class Cifar100Node : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/cifar10_node.cc

@@ -54,7 +54,7 @@ Status Cifar10Node::ValidateParams() {
 }
 
 // Function to build CifarOp for Cifar10
-Status Cifar10Node::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status Cifar10Node::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Do internal Schema generation.
   auto schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->AddColumn(ColDescriptor("image", DataType(DataType::DE_UINT8), TensorImpl::kCv, 1)));

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/cifar10_node.h

@@ -50,7 +50,7 @@ class Cifar10Node : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/clue_node.cc

@@ -84,7 +84,7 @@ std::vector<std::string> CLUENode::split(const std::string &s, char delim) {
 }
 
 // Function to build CLUENode
-Status CLUENode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status CLUENode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::map<std::string, std::string> key_map;
   if (task_ == "AFQMC") {
     if (usage_ == "train") {

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/clue_node.h

@@ -52,7 +52,7 @@ class CLUENode : public NonMappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/coco_node.cc

@@ -64,7 +64,7 @@ Status CocoNode::ValidateParams() {
 }
 
 // Function to build CocoNode
-Status CocoNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status CocoNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   CocoOp::TaskType task_type = CocoOp::TaskType::Detection;
   if (task_ == "Detection") {
     task_type = CocoOp::TaskType::Detection;

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/coco_node.h

@@ -50,7 +50,7 @@ class CocoNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/csv_node.cc

@@ -92,7 +92,7 @@ Status CSVNode::ValidateParams() {
 }
 
 // Function to build CSVNode
-Status CSVNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status CSVNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   bool shuffle_files = (shuffle_ == ShuffleMode::kGlobal || shuffle_ == ShuffleMode::kFiles);
 
   // CSVOp by itself is a non-mappable dataset that does not support sampling.

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/csv_node.h

@@ -73,7 +73,7 @@ class CSVNode : public NonMappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/generator_node.cc

@@ -50,7 +50,7 @@ void GeneratorNode::Print(std::ostream &out) const {
   out << Name() + "(<func>:" + ",columns:" + PrintColumns(column_names_) + ",<col_types>)";
 }
 
-Status GeneratorNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status GeneratorNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   std::unique_ptr<DataSchema> data_schema = std::make_unique<DataSchema>();
 
   if (schema_ != nullptr) {

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/generator_node.h

@@ -55,7 +55,7 @@ class GeneratorNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/image_folder_node.cc

@@ -61,7 +61,7 @@ Status ImageFolderNode::ValidateParams() {
   return Status::OK();
 }
 
-Status ImageFolderNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ImageFolderNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Do internal Schema generation.
   // This arg is exist in ImageFolderOp, but not externalized (in Python API).
   std::unique_ptr<DataSchema> schema = std::make_unique<DataSchema>();

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/image_folder_node.h

@@ -56,7 +56,7 @@ class ImageFolderNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/manifest_node.cc

@@ -82,7 +82,7 @@ Status ManifestNode::ValidateParams() {
   return Status::OK();
 }
 
-Status ManifestNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ManifestNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Do internal Schema generation.
   auto schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->AddColumn(ColDescriptor("image", DataType(DataType::DE_UINT8), TensorImpl::kCv, 1)));

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/manifest_node.h

@@ -51,7 +51,7 @@ class ManifestNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/minddata_node.cc

@@ -150,7 +150,7 @@ Status MindDataNode::BuildMindDatasetSamplerChain(const std::shared_ptr<SamplerO
 // Helper function to set sample_bytes from py::byte type
 void MindDataNode::SetSampleBytes(std::map<std::string, std::string> *sample_bytes) { sample_bytes_ = *sample_bytes; }
 
-Status MindDataNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status MindDataNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   RETURN_IF_NOT_OK(BuildMindDatasetSamplerChain(sampler_, &operators_, num_padded_));
 
   std::shared_ptr<MindRecordOp> mindrecord_op;

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/minddata_node.h

@@ -55,7 +55,7 @@ class MindDataNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/mnist_node.cc

@@ -50,7 +50,7 @@ Status MnistNode::ValidateParams() {
   return Status::OK();
 }
 
-Status MnistNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status MnistNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Do internal Schema generation.
   auto schema = std::make_unique<DataSchema>();
   RETURN_IF_NOT_OK(schema->AddColumn(ColDescriptor("image", DataType(DataType::DE_UINT8), TensorImpl::kCv, 1)));

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/mnist_node.h

@@ -50,7 +50,7 @@ class MnistNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/random_node.cc

@@ -67,7 +67,7 @@ int32_t RandomNode::GenRandomInt(int32_t min, int32_t max) {
 }
 
 // Build for RandomNode
-Status RandomNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status RandomNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   rand_gen_.seed(GetSeed());  // seed the random generator
   // If total rows was not given, then randomly pick a number
   std::shared_ptr<SchemaObj> schema_obj;

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/random_node.h

@@ -70,7 +70,7 @@ class RandomNode : public NonMappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/text_file_node.cc

@@ -70,7 +70,7 @@ Status TextFileNode::ValidateParams() {
 }
 
 // Function to build TextFileNode
-Status TextFileNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status TextFileNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   bool shuffle_files = (shuffle_ == ShuffleMode::kGlobal || shuffle_ == ShuffleMode::kFiles);
 
   // TextFileOp by itself is a non-mappable dataset that does not support sampling.

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/text_file_node.h

@@ -52,7 +52,7 @@ class TextFileNode : public NonMappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/tf_record_node.cc

@@ -105,7 +105,7 @@ Status TFRecordNode::ValidateParams() {
 }
 
 // Function to build TFRecordNode
-Status TFRecordNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status TFRecordNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Sort the datasets file in a lexicographical order
   std::vector<std::string> sorted_dir_files = dataset_files_;
   std::sort(sorted_dir_files.begin(), sorted_dir_files.end());

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/tf_record_node.h

@@ -85,7 +85,7 @@ class TFRecordNode : public NonMappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/voc_node.cc

@@ -85,7 +85,7 @@ Status VOCNode::ValidateParams() {
 }
 
 // Function to build VOCNode
-Status VOCNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status VOCNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   auto schema = std::make_unique<DataSchema>();
   VOCOp::TaskType task_type_;
 

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/source/voc_node.h

@@ -52,7 +52,7 @@ class VOCNode : public MappableSourceNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/sync_wait_node.cc

@@ -42,7 +42,7 @@ void SyncWaitNode::Print(std::ostream &out) const {
 }
 
 // Function to build the BarrierOp
-Status SyncWaitNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status SyncWaitNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   // Right now barrier should only take num_rows_per_buffer = 1
   // The reason for this is because having it otherwise can lead to blocking issues
   // See barrier_op.h for more details

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/sync_wait_node.h

@@ -51,7 +51,7 @@ class SyncWaitNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/take_node.cc

@@ -39,7 +39,7 @@ std::shared_ptr<DatasetNode> TakeNode::Copy() {
 void TakeNode::Print(std::ostream &out) const { out << Name() + "(num_rows:" + std::to_string(take_count_) + ")"; }
 
 // Function to build the TakeOp
-Status TakeNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status TakeNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<TakeOp>(take_count_, connector_que_size_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/take_node.h

@@ -49,7 +49,7 @@ class TakeNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/transfer_node.cc

@@ -67,7 +67,7 @@ Status TransferNode::ValidateParams() {
 }
 
 // Function to build TransferNode
-Status TransferNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status TransferNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   if (queue_name_.empty()) {
     // Get a uuid for queue name
     queue_name_ = Services::GetUniqueID();

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/transfer_node.h

@@ -50,7 +50,7 @@ class TransferNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/zip_node.cc

@@ -56,7 +56,7 @@ Status ZipNode::ValidateParams() {
   return Status::OK();
 }
 
-Status ZipNode::Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) {
+Status ZipNode::Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) {
   node_ops->push_back(std::make_shared<ZipOp>(rows_per_buffer_, connector_que_size_));
   return Status::OK();
 }

mindspore/ccsrc/minddata/dataset/engine/ir/datasetops/zip_node.h

@@ -49,7 +49,7 @@ class ZipNode : public DatasetNode {
   /// \brief a base class override function to create the required runtime dataset op objects for this class
   /// \param node_ops - A vector containing shared pointer to the Dataset Ops that this object will create
   /// \return Status Status::OK() if build successfully
-  Status Build(std::vector<std::shared_ptr<DatasetOp>> *node_ops) override;
+  Status Build(std::vector<std::shared_ptr<DatasetOp>> *const node_ops) override;
 
   /// \brief Parameters validation
   /// \return Status Status::OK() if all the parameters are valid