fix: Added effective passing Point by value

CHANGELOG.md

@@ -1,4 +1,8 @@
 # Changelog
+## [unreleased]
+### Fixes
+- [198](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/198) - Effective passing Point by value
+
 ##  3.12.1 [2022-08-29]
 ### Fixes
 - [193](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/193) - Automatically adjusting point timestamp  according to the setting of write precision. 

src/InfluxData.cpp

@@ -29,8 +29,8 @@
 
 void InfluxData::setTimestamp(long int seconds) 
 { 
-    _timestamp = timeStampToString(seconds,9);
-    strcat(_timestamp, "000000000"); 
+    _data->timestamp = timeStampToString(seconds,9);
+    strcat(_data->timestamp, "000000000"); 
 }
 
  String InfluxData::toString() const { 

src/InfluxData.h

@@ -28,10 +28,10 @@
 
 class InfluxData : public Point {
  public:
-  InfluxData(String measurement) : Point(measurement) {}
+  InfluxData(const String &measurement) : Point(measurement) {}
 
-  void addValue(String key, float value) { addField(key, value); }
-  void addValueString(String key, String value) { addField(key, value); }
+  void addValue(const String &key, float value) { addField(key, value); }
+  void addValueString(const String &key, String value) { addField(key, value); }
   void setTimestamp(long int seconds);
   String toString() const;
 };

src/InfluxDbClient.cpp

@@ -286,10 +286,10 @@ void InfluxDBClient::reserveBuffer(int size) {
 }
 
 void InfluxDBClient::addZerosToTimestamp(Point &point, int zeroes) {
-    char *ts = point._timestamp, *s;
-    point._timestamp = new char[strlen(point._timestamp) + 1 + zeroes];
-    strcpy(point._timestamp, ts);
-    s = point._timestamp+strlen(ts);
+    char *ts = point._data->timestamp, *s;
+    point._data->timestamp = new char[strlen(point._data->timestamp) + 1 + zeroes];
+    strcpy(point._data->timestamp, ts);
+    s = point._data->timestamp+strlen(ts);
     for(int i=0;i<zeroes;i++) {
         *s++ = '0';
     }
@@ -302,17 +302,17 @@ void InfluxDBClient::checkPrecisions(Point & point) {
         if(!point.hasTime()) {
             point.setTime(_writeOptions._writePrecision);
         // Check different write precisions
-        } else if(point._tsWritePrecision != WritePrecision::NoTime && point._tsWritePrecision != _writeOptions._writePrecision) {
-            int diff = int(point._tsWritePrecision) - int(_writeOptions._writePrecision);
+        } else if(point._data->tsWritePrecision != WritePrecision::NoTime && point._data->tsWritePrecision != _writeOptions._writePrecision) {
+            int diff = int(point._data->tsWritePrecision) - int(_writeOptions._writePrecision);
             if(diff > 0) { //point has higher precision, cut 
-                point._timestamp[strlen(point._timestamp)-diff*3] = 0;
+                point._data->timestamp[strlen(point._data->timestamp)-diff*3] = 0;
             } else { //point has lower precision, add zeroes
                 addZerosToTimestamp(point, diff*-3);
             }
         }
     // check someone set WritePrecision on point and not on client. NS precision is ok, cause it is default on server
-    } else if(point.hasTime() && point._tsWritePrecision != WritePrecision::NoTime && point._tsWritePrecision != WritePrecision::NS) {
-        int diff = int(WritePrecision::NS) - int(point._tsWritePrecision);
+    } else if(point.hasTime() && point._data->tsWritePrecision != WritePrecision::NoTime && point._data->tsWritePrecision != WritePrecision::NS) {
+        int diff = int(WritePrecision::NS) - int(point._data->tsWritePrecision);
         addZerosToTimestamp(point, diff*3);
     } 
 }

src/Point.cpp

@@ -30,27 +30,45 @@
 
 Point::Point(const String & measurement)
 {
-    _measurement = escapeKey(measurement, false);
-    _timestamp = nullptr;
-    _tsWritePrecision = WritePrecision::NoTime;
+  _data = std::make_shared<Data>(escapeKey(measurement, false));
 }
 
 Point::~Point() {
-    delete [] _measurement;
-    delete [] _timestamp;
+}
+
+Point::Data::Data(char * measurement) {
+  this->measurement = measurement;
+  timestamp = nullptr;
+  tsWritePrecision = WritePrecision::NoTime;
+}
+
+Point::Data::~Data() {
+  delete [] measurement;
+  delete [] timestamp;
+}
+
+Point::Point(const Point &other) {
+  *this = other;
+}
+
+Point& Point::operator=(const Point &other) {
+  if(this != &other) {
+    this->_data = other._data;
+  }
+  return *this;
 }
 
 void Point::addTag(const String &name, String value) {
-    if(_tags.length() > 0) {
-        _tags += ',';
-    }
-    char *s = escapeKey(name);
-    _tags += s;
-    delete [] s;
-    _tags += '=';
-    s = escapeKey(value);
-    _tags += s;
-    delete [] s;
+  if(_data->tags.length() > 0) {
+      _data->tags += ',';
+  }
+  char *s = escapeKey(name);
+  _data->tags += s;
+  delete [] s;
+  _data->tags += '=';
+  s = escapeKey(value);
+  _data->tags += s;
+  delete [] s;
 }
 
 void Point::addField(const String &name, long long value) {
@@ -114,14 +132,14 @@ void Point::addField(const String &name, const String &value)  {
 }
 
 void Point::putField(const String &name, const String &value) {
-    if(_fields.length() > 0) {
-        _fields += ',';
+    if(_data->fields.length() > 0) {
+        _data->fields += ',';
     }
     char *s = escapeKey(name);
-    _fields += s;
+    _data->fields += s;
     delete [] s;
-    _fields += '=';
-    _fields += value;
+    _data->fields += '=';
+    _data->fields += value;
 }
 
 String Point::toLineProtocol(const String &includeTags) const {
@@ -130,23 +148,23 @@ String Point::toLineProtocol(const String &includeTags) const {
 
 String Point::createLineProtocol(const String &incTags) const {
     String line;
-    line.reserve(strLen(_measurement) + 1 + incTags.length() + 1 + _tags.length() + 1 + _fields.length() + 1 + strLen(_timestamp));
-    line += _measurement;
+    line.reserve(strLen(_data->measurement) + 1 + incTags.length() + 1 + _data->tags.length() + 1 + _data->fields.length() + 1 + strLen(_data->timestamp));
+    line += _data->measurement;
     if(incTags.length()>0) {
         line += ",";
         line += incTags;
     }
     if(hasTags()) {
         line += ",";
-        line += _tags;
+        line += _data->tags;
     }
     if(hasFields()) {
         line += " ";
-        line += _fields;
+        line += _data->fields;
     }
     if(hasTime()) {
         line += " ";
-        line += _timestamp;
+        line += _data->timestamp;
     }
     return line;
  }
@@ -172,7 +190,7 @@ void  Point::setTime(WritePrecision precision) {
             setTime((char *)nullptr);
             break;
     }
-    _tsWritePrecision = precision;
+    _data->tsWritePrecision = precision;
 }
 
 void  Point::setTime(unsigned long long timestamp) {
@@ -188,16 +206,16 @@ void Point::setTime(const char *timestamp) {
 }
 
 void Point::setTime(char *timestamp) {
-    delete [] _timestamp;
-    _timestamp = timestamp;
+    delete [] _data->timestamp;
+    _data->timestamp = timestamp;
 }
 
 void  Point::clearFields() {
-    _fields = (char *)nullptr;
-    delete [] _timestamp;
-    _timestamp = nullptr;
+    _data->fields = (char *)nullptr;
+    delete [] _data->timestamp;
+    _data->timestamp = nullptr;
 }
 
 void Point:: clearTags() {
-    _tags = (char *)nullptr;
+    _data->tags = (char *)nullptr;
 }

src/Point.h

@@ -30,6 +30,7 @@
 #include <Arduino.h>
 #include "WritePrecision.h"
 #include "util/helpers.h"
+#include <memory>
 
 /**
  * Class Point represents InfluxDB point in line protocol.
@@ -39,6 +40,8 @@ class Point {
 friend class InfluxDBClient;
   public:
     Point(const String &measurement);
+    Point(const Point &other);
+    Point& operator=(const Point &other);
     virtual ~Point();
     // Adds string tag 
     void addTag(const String &name, String value);
@@ -70,21 +73,27 @@ friend class InfluxDBClient;
     // Clear tags
     void clearTags();
     // True if a point contains at least one field. Points without a field cannot be written to db
-    bool hasFields() const { return _fields.length() > 0; }
+    bool hasFields() const { return _data->fields.length() > 0; }
     // True if a point contains at least one tag
-    bool hasTags() const   { return _tags.length() > 0; }
+    bool hasTags() const   { return _data->tags.length() > 0; }
     // True if a point contains timestamp
-    bool hasTime() const   { return strLen(_timestamp) > 0; }
+    bool hasTime() const   { return strLen(_data->timestamp) > 0; }
     // Creates line protocol with optionally added tags
     String toLineProtocol(const String &includeTags = "") const;
     // returns current timestamp
-    String getTime() const { return _timestamp; } 
+    String getTime() const { return _data->timestamp; } 
   protected:
-    char *_measurement;
-    String _tags;
-    String _fields;
-    char *_timestamp;
-    WritePrecision _tsWritePrecision;
+    class Data {
+      public:
+        Data(char *measurement);
+        ~Data();
+        char *measurement;
+        String tags;
+        String fields;
+        char *timestamp;
+        WritePrecision tsWritePrecision;
+    };
+    std::shared_ptr<Data> _data;
   protected:    
     // method for formating field into line protocol
     void putField(const String &name, const String &value);