Cleanup string classes

nasa · Jul 29, 2021 · 7ec49c1 · 7ec49c1
1 parent 764194a
commit 7ec49c1
Show file tree

Hide file tree

Showing 34 changed files with 325 additions and 583 deletions.
diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/arrays/array_cpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/arrays/array_cpp.tmpl
@@ -24,6 +24,7 @@
 \#include <stdio.h>
 
 \#include "Fw/Types/Assert.hpp"
+\#include <Fw/Types/StringUtils.hpp>
 
 \#include "${name}ArrayAc.hpp"
 
@@ -34,66 +35,47 @@ namespace ${namespace} {
 #if $type == "string":
 
     ${name}::${name}String::${name}String(const char* src): StringBase() {
-        this->copyBuff(src,this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
     }
 
     ${name}::${name}String::${name}String(const Fw::StringBase& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${name}::${name}String::${name}String(const ${name}String& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${name}::${name}String::${name}String(void): StringBase() {
         this->m_buf[0] = 0;
     }
 
-    ${name}::${name}String::~${name}String(void) {
-    }
-
-    bool ${name}::${name}String::operator==(const ${name}String& src) const {
-        return (0 == strncmp(this->m_buf,src.m_buf,sizeof(this->m_buf)));
+    ${name}::${name}String& ${name}::${name}String::operator=(const ${name}String& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    NATIVE_UINT_TYPE ${name}::${name}String::length(void) const {
-        return (NATIVE_UINT_TYPE)strnlen(this->m_buf,sizeof(this->m_buf));
+    ${name}::${name}String& ${name}::${name}String::operator=(const StringBase& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    const char* ${name}::${name}String::toChar(void) const {
-        return this->m_buf;
+    ${name}::${name}String& ${name}::${name}String::operator=(const char* other) {
+        Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
+        return *this;
     }
 
-    Fw::SerializeStatus ${name}::${name}String::serialize(Fw::SerializeBufferBase& buffer) const {
-        NATIVE_UINT_TYPE strSize = strnlen(this->m_buf,sizeof(this->m_buf));
-        // serialize string
-        return buffer.serialize((U8*)this->m_buf,strSize);
+    ${name}::${name}String::~${name}String(void) {
     }
 
-    Fw::SerializeStatus ${name}::${name}String::deserialize(Fw::SerializeBufferBase& buffer) {
-        NATIVE_UINT_TYPE maxSize = sizeof(this->m_buf);
-        // deserialize string
-        Fw::SerializeStatus stat = buffer.deserialize((U8*)this->m_buf,maxSize);
-        // make sure it is null-terminated
-        this->terminate(maxSize);
-
-        return stat;
+    const char* ${name}::${name}String::toChar(void) const {
+        return this->m_buf;
     }
 
     NATIVE_UINT_TYPE ${name}::${name}String::getCapacity(void) const {
         return sizeof(this->m_buf);
     }
 
-    void ${name}::${name}String::terminate(NATIVE_UINT_TYPE size) {
-        // null terminate the string
-        this->m_buf[size < sizeof(this->m_buf)?size:sizeof(this->m_buf)-1] = 0;
-    }
-
-    const ${name}::${name}String& ${name}::${name}String::operator=(const ${name}::${name}String& other) {
-        this->copyBuff(other.m_buf,this->getCapacity());
-        return *this;
-    }
-
 #end if
 
   // ----------------------------------------------------------------------

diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/arrays/array_hpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/arrays/array_hpp.tmpl
@@ -62,22 +62,17 @@ namespace ${namespace} {
             ${name}String(const Fw::StringBase& src); //!< string base constructor
             ${name}String(const ${name}String& src); //!< string base constructor
             ${name}String(void); //!< default constructor
-            virtual ~${name}String(void); //!< destructor
-            const char* toChar(void) const; //!< retrieves char buffer of string
-            NATIVE_UINT_TYPE length(void) const; //!< returns length of string
-            bool operator==(const ${name}String& src) const; //!< equality operator
-
-            const ${name}String& operator=(const ${name}String& other); //!< equal operator for other strings
+            ${name}String& operator=(const ${name}String& other); //!< assignment operator
+            ${name}String& operator=(const Fw::StringBase& other); //!< other string assignment operator
+            ${name}String& operator=(const char* other); //!< char* assignment operator
+            ~${name}String(void); //!< destructor
 
-            Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const; //!< serialization function
-            Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer); //!< deserialization function
+            const char* toChar(void) const; //!< retrieves char buffer of string
+            NATIVE_UINT_TYPE getCapacity(void) const ;
 
         private:
-            NATIVE_UINT_TYPE getCapacity(void) const ;
-            void terminate(NATIVE_UINT_TYPE size); //!< terminate the string
 
             char m_buf[${string_size}]; //!< buffer for string storage
-
     };
 
 #end if

diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/port/includes1PortCpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/port/includes1PortCpp.tmpl
@@ -1,5 +1,6 @@
 \#include <FpConfig.hpp>
 \#include <Fw/Types/Assert.hpp>
 \#include <Fw/Types/Serializable.hpp>
+\#include <Fw/Types/StringUtils.hpp>
 
 \#include <${port_include_path}/${include_file}>
diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/port/namespacePortCpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/port/namespacePortCpp.tmpl
@@ -8,62 +8,47 @@ namespace ${n} {
 #if $type == "string":
 
     ${argname}String::${argname}String(const char* src): StringBase() {
-        this->copyBuff(src,this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
     }
 
     ${argname}String::${argname}String(const Fw::StringBase& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+         Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${argname}String::${argname}String(const ${argname}String& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+         Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${argname}String::${argname}String(void): StringBase() {
         this->m_buf[0] = 0;
     }
 
-    ${argname}String::~${argname}String(void) {
+    ${argname}String& ${argname}String::operator=(const ${argname}String& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    NATIVE_UINT_TYPE ${argname}String::length(void) const {
-        return (NATIVE_UINT_TYPE)strnlen(this->m_buf,sizeof(this->m_buf));
+    ${argname}String& ${argname}String::operator=(const StringBase& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    const char* ${argname}String::toChar(void) const {
-        return this->m_buf;
+    ${argname}String& ${argname}String::operator=(const char* other) {
+        Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
+        return *this;
     }
 
-    Fw::SerializeStatus ${argname}String::serialize(Fw::SerializeBufferBase& buffer) const {
-        NATIVE_UINT_TYPE strSize = strnlen(this->m_buf,sizeof(this->m_buf));
-        // serialize string as buffer
-        return buffer.serialize((U8*)this->m_buf,strSize);
+    ${argname}String::~${argname}String(void) {
     }
 
-    Fw::SerializeStatus ${argname}String::deserialize(Fw::SerializeBufferBase& buffer) {
-        NATIVE_UINT_TYPE maxSize = sizeof(this->m_buf);
-        // deserialize string
-        Fw::SerializeStatus stat = buffer.deserialize((U8*)this->m_buf,maxSize);
-        // make sure it is null-terminated
-        this->terminate(maxSize);
-
-        return stat;
+    const char* ${argname}String::toChar(void) const {
+        return this->m_buf;
     }
 
     NATIVE_UINT_TYPE ${argname}String::getCapacity(void) const {
         return sizeof(this->m_buf);
     }
 
-    const ${argname}String& ${argname}String::operator=(const ${argname}String& other) {
-        this->copyBuff(other.m_buf,this->getCapacity());
-        return *this;
-    }
-
-    void ${argname}String::terminate(NATIVE_UINT_TYPE size) {
-        // null terminate the string
-        this->m_buf[size < sizeof(this->m_buf)?size:sizeof(this->m_buf)-1] = 0;
-    }
-
 #end if
 #if $type == "buffer":
 

diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/port/namespacePortH.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/port/namespacePortH.tmpl
@@ -33,18 +33,15 @@ namespace ${namespace} {
             ${argname}String(const Fw::StringBase& src); //!< other string constructor
             ${argname}String(const ${argname}String& src); //!< same type string constructor
             ${argname}String(void); //!< default constructor
-            virtual ~${argname}String(void); //!< destructor
-            const char* toChar(void) const; //!< return internal buffer
-            NATIVE_UINT_TYPE length(void) const; //!< length of string
-
-            const ${argname}String& operator=(const ${argname}String& other); //!< equal operator for other strings
+            ${argname}String& operator=(const ${argname}String& other); //!< assignment operator
+            ${argname}String& operator=(const Fw::StringBase& other); //!< other string assignment operator
+            ${argname}String& operator=(const char* other); //!< char* assignment operator
+            ~${argname}String(void); //!< destructor
 
-            Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const; //!< deserialization method
-            Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer); //!< serialization method
+            const char* toChar(void) const; //!< return internal buffer
+            NATIVE_UINT_TYPE getCapacity(void) const ;
 
         private:
-            NATIVE_UINT_TYPE getCapacity(void) const ;
-            void terminate(NATIVE_UINT_TYPE size); //!< terminate the string
 
             char m_buf[${size}]; //!< buffer for string
     };

diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/serialize/includes1SerialCpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/serialize/includes1SerialCpp.tmpl
@@ -1,6 +1,7 @@
 \#include <${include_path}/${namespace}${name}SerializableAc.hpp>
 \#include <Fw/Types/Assert.hpp>
 \#include <Fw/Types/BasicTypes.hpp>
+\#include <Fw/Types/StringUtils.hpp>
 \#if FW_SERIALIZABLE_TO_STRING
 \#include <Fw/Types/EightyCharString.hpp>
 \#endif

diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/serialize/namespaceSerialCpp.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/serialize/namespaceSerialCpp.tmpl
@@ -7,65 +7,46 @@ namespace ${n} {
 #if $type == "string":
 
     ${name}::${memname}String::${memname}String(const char* src): StringBase() {
-        this->copyBuff(src,this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
     }
 
     ${name}::${memname}String::${memname}String(const Fw::StringBase& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${name}::${memname}String::${memname}String(const ${memname}String& src): StringBase() {
-        this->copyBuff(src.toChar(),this->getCapacity());
+        Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
     }
 
     ${name}::${memname}String::${memname}String(void): StringBase() {
         this->m_buf[0] = 0;
     }
 
-    ${name}::${memname}String::~${memname}String(void) {
-    }
-
-    bool ${name}::${memname}String::operator==(const ${memname}String& src) const {
-        return (0 == strncmp(this->m_buf,src.m_buf,sizeof(this->m_buf)));
+    ${name}::${memname}String& ${name}::${memname}String::operator=(const ${memname}String& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    NATIVE_UINT_TYPE ${name}::${memname}String::length(void) const {
-        return (NATIVE_UINT_TYPE)strnlen(this->m_buf,sizeof(this->m_buf));
+    ${name}::${memname}String& ${name}::${memname}String::operator=(const StringBase& other) {
+        Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
+        return *this;
     }
 
-    const char* ${name}::${memname}String::toChar(void) const {
-        return this->m_buf;
+    ${name}::${memname}String& ${name}::${memname}String::operator=(const char* other) {
+        Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
+        return *this;
     }
 
-    Fw::SerializeStatus ${name}::${memname}String::serialize(Fw::SerializeBufferBase& buffer) const {
-        NATIVE_UINT_TYPE strSize = strnlen(this->m_buf,sizeof(this->m_buf));
-        // serialize string
-        return buffer.serialize((U8*)this->m_buf,strSize);
+    ${name}::${memname}String::~${memname}String(void) {
     }
 
-    Fw::SerializeStatus ${name}::${memname}String::deserialize(Fw::SerializeBufferBase& buffer) {
-        NATIVE_UINT_TYPE maxSize = sizeof(this->m_buf);
-        // deserialize string
-        Fw::SerializeStatus stat = buffer.deserialize((U8*)this->m_buf,maxSize);
-        // make sure it is null-terminated
-        this->terminate(maxSize);
-
-        return stat;
+    const char* ${name}::${memname}String::toChar(void) const {
+        return this->m_buf;
     }
 
     NATIVE_UINT_TYPE ${name}::${memname}String::getCapacity(void) const {
         return sizeof(this->m_buf);
     }
 
-    void ${name}::${memname}String::terminate(NATIVE_UINT_TYPE size) {
-        // null terminate the string
-        this->m_buf[size < sizeof(this->m_buf)?size:sizeof(this->m_buf)-1] = 0;
-    }
-
-    const ${name}::${memname}String& ${name}::${memname}String::operator=(const ${name}::${memname}String& other) {
-        this->copyBuff(other.m_buf,this->getCapacity());
-        return *this;
-    }
-
 #end if
 #end for
diff --git a/Autocoders/Python/src/fprime_ac/generators/templates/serialize/namespaceSerialH.tmpl b/Autocoders/Python/src/fprime_ac/generators/templates/serialize/namespaceSerialH.tmpl
@@ -34,22 +34,17 @@ class ${name} : public Fw::Serializable {
             ${memname}String(const Fw::StringBase& src); //!< string base constructor
             ${memname}String(const ${memname}String& src); //!< string base constructor
             ${memname}String(void); //!< default constructor
-            virtual ~${memname}String(void); //!< destructor
-            const char* toChar(void) const; //!< retrieves char buffer of string
-            NATIVE_UINT_TYPE length(void) const; //!< returns length of string
-            bool operator==(const ${memname}String& src) const; //!< equality operator
-
-            const ${memname}String& operator=(const ${memname}String& other); //!< equal operator for other strings
+            ${memname}String& operator=(const ${memname}String& other); //!< assignment operator
+            ${memname}String& operator=(const Fw::StringBase& other); //!< other string assignment operator
+            ${memname}String& operator=(const char* other); //!< char* assignment operator
+            ~${memname}String(void); //!< destructor
 
-            Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const; //!< serialization function
-            Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer); //!< deserialization function
+            const char* toChar(void) const; //!< retrieves char buffer of string
+            NATIVE_UINT_TYPE getCapacity(void) const ;
 
         private:
-            NATIVE_UINT_TYPE getCapacity(void) const ;
-            void terminate(NATIVE_UINT_TYPE size); //!< terminate the string
 
             char m_buf[${size}]; //!< buffer for string storage
-
     };
 
 #end if