Clean up constructor interface

- replace string type constructor argument with "const string&"
- replace vector type constructor argument with "const vector<T>&"
- add rvalue reference constructor for TosaSerializationOperator and TosaSerializationBasicBlock
- add SetData() for TosaSerializationTensor, so tensor can be constructed first and data can be linked later

Signed-off-by: Kevin Cheng <kevin.cheng@arm.com>
Change-Id: I7c739df54c37b7ba69ebb6e5af118f660c7c0623
diff --git a/include/tosa_serialization_handler.h b/include/tosa_serialization_handler.h
index a60e506..b07fa3b 100644
--- a/include/tosa_serialization_handler.h
+++ b/include/tosa_serialization_handler.h
@@ -114,7 +114,7 @@
                             const flatbuffers::Vector<int32_t>* shape,
                             DType dtype,
                             const flatbuffers::Vector<uint8_t>* data);
-    TosaSerializationTensor(std::string& name,
+    TosaSerializationTensor(const std::string& name,
                             const std::vector<int32_t>& shape,
                             DType dtype,
                             const std::vector<uint8_t>& data);
@@ -148,6 +148,14 @@
     {
         _name = name;
     }
+    void SetData(const std::vector<uint8_t>& data)
+    {
+        _data = data;
+    }
+    void SetData(std::vector<uint8_t>&& data)
+    {
+        _data = std::move(data);
+    }
 
 private:
     DType _dtype;                /* data type enumeration, see tosa_isa_generated.h */
@@ -166,8 +174,15 @@
                               const TosaAttributeBase* attribute,
                               QuantInfo qinfo_type,
                               const TosaQuantInfoBase* qinfo,
-                              std::vector<std::string> input_tensor_names,
-                              std::vector<std::string> output_tensor_names);
+                              const std::vector<std::string>& input_tensor_names,
+                              const std::vector<std::string>& output_tensor_names);
+    TosaSerializationOperator(Op op,
+                              Attribute attribute_type,
+                              const TosaAttributeBase* attribute,
+                              QuantInfo qinfo_type,
+                              const TosaQuantInfoBase* qinfo,
+                              std::vector<std::string>&& input_tensor_names,
+                              std::vector<std::string>&& output_tensor_names);
     ~TosaSerializationOperator();
 
     // accessor
@@ -201,6 +216,10 @@
     }
 
 private:
+    void InitializeAttributeQinfo(Attribute attribute_type,
+                                  const TosaAttributeBase* attribute,
+                                  QuantInfo qinfo_type,
+                                  const TosaQuantInfoBase* qinfo);
     Op _op;                        /* operator enum, see tosa_isa_generated.h for enumeration table */
     Attribute _attribute_type;     /* operator attribute enum, used for dynamic casting TosaAttributeBase class */
     TosaAttributeBase* _attribute; /* real attribute class goes here */
@@ -214,11 +233,16 @@
 {
 public:
     // constructor and destructor
-    TosaSerializationBasicBlock(std::string name,
-                                std::vector<TosaSerializationOperator*> operators,
-                                std::vector<TosaSerializationTensor*> tensors,
-                                std::vector<std::string> inputs,
-                                std::vector<std::string> outputs);
+    TosaSerializationBasicBlock(const std::string& name,
+                                const std::vector<TosaSerializationOperator*>& operators,
+                                const std::vector<TosaSerializationTensor*>& tensors,
+                                const std::vector<std::string>& inputs,
+                                const std::vector<std::string>& outputs);
+    TosaSerializationBasicBlock(std::string&& name,
+                                std::vector<TosaSerializationOperator*>&& operators,
+                                std::vector<TosaSerializationTensor*>&& tensors,
+                                std::vector<std::string>&& inputs,
+                                std::vector<std::string>&& outputs);
     ~TosaSerializationBasicBlock();
 
     // accessor
diff --git a/src/tosa_serialization_handler.cpp b/src/tosa_serialization_handler.cpp
index a382542..547c3db 100644
--- a/src/tosa_serialization_handler.cpp
+++ b/src/tosa_serialization_handler.cpp
@@ -36,7 +36,7 @@
     }
 }
 
-TosaSerializationTensor::TosaSerializationTensor(std::string& name,
+TosaSerializationTensor::TosaSerializationTensor(const std::string& name,
                                                  const std::vector<int32_t>& shape,
                                                  DType dtype,
                                                  const std::vector<uint8_t>& data)
@@ -50,22 +50,17 @@
 TosaSerializationTensor::TosaSerializationTensor()
 {
     _dtype = DType_UNKNOWN;
-
-    _name = "UNKNOWN";
+    _name  = "UNKNOWN";
 }
 
 TosaSerializationTensor::~TosaSerializationTensor()
 {}
 
-TosaSerializationOperator::TosaSerializationOperator(Op op,
-                                                     Attribute attribute_type,
-                                                     const TosaAttributeBase* attribute,
-                                                     QuantInfo qinfo_type,
-                                                     const TosaQuantInfoBase* qinfo,
-                                                     std::vector<std::string> input_tensor_names,
-                                                     std::vector<std::string> output_tensor_names)
+void TosaSerializationOperator::InitializeAttributeQinfo(Attribute attribute_type,
+                                                         const TosaAttributeBase* attribute,
+                                                         QuantInfo qinfo_type,
+                                                         const TosaQuantInfoBase* qinfo)
 {
-    _op             = op;
     _attribute_type = attribute_type;
 
     switch (attribute_type)
@@ -104,25 +99,50 @@
     }
 
     assert(_attribute && _qinfo);
+}
 
+TosaSerializationOperator::TosaSerializationOperator(Op op,
+                                                     Attribute attribute_type,
+                                                     const TosaAttributeBase* attribute,
+                                                     QuantInfo qinfo_type,
+                                                     const TosaQuantInfoBase* qinfo,
+                                                     const std::vector<std::string>& input_tensor_names,
+                                                     const std::vector<std::string>& output_tensor_names)
+{
+    _op                  = op;
     _input_tensor_names  = input_tensor_names;
     _output_tensor_names = output_tensor_names;
+
+    InitializeAttributeQinfo(attribute_type, attribute, qinfo_type, qinfo);
+}
+
+TosaSerializationOperator::TosaSerializationOperator(Op op,
+                                                     Attribute attribute_type,
+                                                     const TosaAttributeBase* attribute,
+                                                     QuantInfo qinfo_type,
+                                                     const TosaQuantInfoBase* qinfo,
+                                                     std::vector<std::string>&& input_tensor_names,
+                                                     std::vector<std::string>&& output_tensor_names)
+{
+    _op                  = op;
+    _input_tensor_names  = std::move(input_tensor_names);
+    _output_tensor_names = std::move(output_tensor_names);
+
+    InitializeAttributeQinfo(attribute_type, attribute, qinfo_type, qinfo);
 }
 
 TosaSerializationOperator::~TosaSerializationOperator()
 {
     delete _attribute;
     delete _qinfo;
-    // TosaSerializationTensor should be free'd in TosaSerializationSerializationHandler destructor
 }
 
-TosaSerializationBasicBlock::TosaSerializationBasicBlock(std::string name,
-                                                         std::vector<TosaSerializationOperator*> operators,
-                                                         std::vector<TosaSerializationTensor*> tensors,
-                                                         std::vector<std::string> inputs,
-                                                         std::vector<std::string> outputs)
+TosaSerializationBasicBlock::TosaSerializationBasicBlock(const std::string& name,
+                                                         const std::vector<TosaSerializationOperator*>& operators,
+                                                         const std::vector<TosaSerializationTensor*>& tensors,
+                                                         const std::vector<std::string>& inputs,
+                                                         const std::vector<std::string>& outputs)
 {
-
     _name      = name;
     _operators = operators;
     _tensors   = tensors;
@@ -130,6 +150,19 @@
     _outputs   = outputs;
 }
 
+TosaSerializationBasicBlock::TosaSerializationBasicBlock(std::string&& name,
+                                                         std::vector<TosaSerializationOperator*>&& operators,
+                                                         std::vector<TosaSerializationTensor*>&& tensors,
+                                                         std::vector<std::string>&& inputs,
+                                                         std::vector<std::string>&& outputs)
+{
+    _name      = std::move(name);
+    _operators = std::move(operators);
+    _tensors   = std::move(tensors);
+    _inputs    = std::move(inputs);
+    _outputs   = std::move(outputs);
+}
+
 TosaSerializationBasicBlock::~TosaSerializationBasicBlock()
 {
     // deallocate all operators