moved methods from cpp in h

LSFramework/LSString.cpp

@@ -6,27 +6,32 @@ LSString::LSString(const char* pData)
   : m_uiLength(StringLength(pData))
   , m_uiCapacity(StringLength(pData))
 {
-  m_pData = new char[m_uiLength + 1];
-  memset(m_pData, 0, m_uiLength + 1);
-  if(pData) memcpy(m_pData, pData, m_uiLength);
+  Assign(pData);
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
 LSString::LSString(const std::string& sRhs)
-  : m_pData(new char[sRhs.length()])
-  , m_uiLength(sRhs.length())
+  : m_uiLength(sRhs.length())
   , m_uiCapacity(sRhs.length())
 {
+  Assign(sRhs);
+}
+
+//-----------------------------------------------------------------------------------------------------------------------------
+LSString& LSString::operator=(const LSString& sRhs)
+{
+  m_uiLength = sRhs.Length();
+  m_uiCapacity = sRhs.Capacity();
+  Assign(sRhs);
+  return *this;
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
 LSString::LSString(const LSString& sRhs)
   : m_uiLength(sRhs.m_uiLength)
-  , m_pData(new char[sRhs.m_uiLength + 1])
   , m_uiCapacity(sRhs.m_uiCapacity)
 {
-  memset(m_pData + m_uiLength, 0, 1);
-  memcpy(m_pData, sRhs.m_pData, m_uiLength);
+  Assign(sRhs);
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
@@ -36,15 +41,11 @@ LSString::~LSString()
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
-void LSString::Insert(const LSString& sRhs, size_t uiPos)
+void LSString::Assign(const char* pData)
 {
-  Insert(sRhs.m_pData, uiPos);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-void LSString::Insert(const std::string& sRhs, size_t uiPos)
-{
-  Insert(sRhs.c_str(), uiPos);
+  m_pData = new char[m_uiLength + 1];
+  memset(m_pData, 0, m_uiLength + 1);
+  if (pData) memcpy(m_pData, pData, m_uiLength);
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
@@ -69,42 +70,6 @@ void LSString::Insert(const char* pData, size_t uiPos)
   m_uiLength = zNewLength;
 }
 
-//-----------------------------------------------------------------------------------------------------------------------------
-void LSString::Append(const LSString& sRhs)
-{
-  Insert(sRhs, sRhs.Length());
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-void LSString::Append(const std::string& sRhs)
-{
-  Insert(sRhs, sRhs.length());
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-void LSString::Append(const char* pData)
-{
-  Insert(pData, m_uiLength);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-bool LSString::Remove(const LSString& sRhs)
-{
-  return RemoveAt(Find(sRhs), sRhs.m_uiLength);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-bool LSString::Remove(const std::string& sRhs)
-{
-  return RemoveAt(Find(sRhs), sRhs.length());
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-bool LSString::Remove(const char* pData)
-{
-  return RemoveAt(Find(pData), StringLength(pData));
-}
-
 //-----------------------------------------------------------------------------------------------------------------------------
 bool LSString::RemoveAt(size_t uiPos, size_t uiSize)
 {
@@ -131,18 +96,6 @@ size_t LSString::StringLength(const char* pChar) const
   return iRet;
 }
 
-//-----------------------------------------------------------------------------------------------------------------------------
-bool LSString::Contains(const LSString& sRhs) const
-{
-  return Contains(sRhs.m_pData);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-bool LSString::Contains(const std::string& sRhs) const
-{
-  return Contains(sRhs.c_str());
-}
-
 //-----------------------------------------------------------------------------------------------------------------------------
 bool LSString::Contains(const char* pData) const
 {
@@ -160,18 +113,6 @@ bool LSString::Contains(const char* pData) const
   return iRet == 0;
 }
 
-//-----------------------------------------------------------------------------------------------------------------------------
-size_t LSString::Find(const LSString& sRhs, size_t uiOffset) const
-{
-  return Find(sRhs.m_pData, uiOffset);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-size_t LSString::Find(const std::string& sRhs, size_t uiOffset) const
-{
-  return Find(sRhs.c_str(), uiOffset);
-}
-
 //-----------------------------------------------------------------------------------------------------------------------------
 size_t LSString::Find(const char* pData, size_t uiOffset) const
 {
@@ -191,30 +132,6 @@ size_t LSString::Find(const char* pData, size_t uiOffset) const
   return uiCurrentOffset;
 }
 
-//-----------------------------------------------------------------------------------------------------------------------------
-char LSString::At(size_t uiPos) const
-{
-  return *(m_pData + uiPos);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-size_t LSString::Length() const
-{
-  return m_uiLength;
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-std::string LSString::ToStdString() const
-{
-  return std::string(m_pData);
-}
-
-//-----------------------------------------------------------------------------------------------------------------------------
-const char* LSString::ToCChar() const
-{
-  return m_pData;
-}
-
 //-----------------------------------------------------------------------------------------------------------------------------
 void LSString::IncreaseCapacity(size_t uiNewLength)
 {

LSFramework/LSString.h

@@ -10,61 +10,121 @@ public:
 
   LSString(const char* pData);
 
-  LSString(const LSString& sRhs);
+  LSString(const LSString& sString);
 
-  LSString(const std::string& sRhs);
+  LSString(const std::string& sString);
 
-  LSString& operator=(const LSString& sRhs) = delete;
+  LSString& operator=(const LSString& sRhs);
 
   // - Destructor
   ~LSString();
 
   // - Alloc
-  void Insert(const LSString& sRhs, size_t uiPos);
-
-  void Insert(const std::string& sRhs, size_t uiPos);
+#pragma region Conversion
+  inline void Assign(const LSString& sString)
+  {
+    Assign(sString.ToCChar());
+  }
+  inline void Assign(const std::string& sString)
+  {
+    Assign(sString.c_str());
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline void Append(const LSString& sRhs)
+  {
+    Insert(sRhs, sRhs.Length());
+  }
+  inline void Append(const std::string& sRhs)
+  {
+    Insert(sRhs, sRhs.length());
+  }
+  inline void Append(const char* pData)
+  {
+    Insert(pData, m_uiLength);
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline void Insert(const LSString& sRhs, size_t uiPos)
+  {
+    Insert(sRhs.m_pData, uiPos);
+  }
+  inline void Insert(const std::string& sRhs, size_t uiPos)
+  {
+    Insert(sRhs.c_str(), uiPos);
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline bool Remove(const LSString& sRhs)
+  {
+    return RemoveAt(Find(sRhs), sRhs.m_uiLength);
+  }
+  inline bool Remove(const std::string& sRhs)
+  {
+    return RemoveAt(Find(sRhs), sRhs.length());
+  }
+  inline bool Remove(const char* pData)
+  {
+    return RemoveAt(Find(pData), StringLength(pData));
+  }
+#pragma endregion
 
+#pragma region Logic
+  void Assign(const char* pData);
   void Insert(const char* pData, size_t uiPos);
-
-  void Append(const LSString& sRhs);
-
-  void Append(const std::string& sRhs);
-
-  void Append(const char* pData);
-
-  bool Remove(const LSString& sRhs);
-
-  bool Remove(const std::string& sRhs);
-
-  bool Remove(const char* pData);
-
   bool RemoveAt(size_t uiPos, size_t uiSize);
+#pragma endregion
 
   // - Utility
+#pragma region Conversion
+  inline bool Contains(const LSString& sRhs) const
+  {
+    return Contains(sRhs.m_pData);
+  }
+  bool Contains(const std::string& sRhs) const
+  {
+    return Contains(sRhs.c_str());
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline size_t Find(const LSString& sRhs, size_t uiOffset) const
+  {
+    return Find(sRhs.m_pData, uiOffset);
+  }
+  inline size_t Find(const std::string& sRhs, size_t uiOffset) const
+  {
+    return Find(sRhs.c_str(), uiOffset);
+  }
+#pragma endregion
+
+#pragma region Logic
   size_t StringLength(const char* pData) const;
-
-  bool Contains(const LSString& sRhs) const;
-
-  bool Contains(const std::string& sRhs) const;
-
   bool Contains(const char* pData) const;
-
-  size_t Find(const LSString& sRhs, size_t uiOffset = 0) const;
-
-  size_t Find(const std::string& sRhs, size_t uiOffset = 0) const;
-
   size_t Find(const char* pData, size_t uiOffset = 0) const;
-
-  char At(size_t uiPos) const;
-
-  size_t Length() const;
-
-  std::string ToStdString() const;
-
-  const char* ToCChar() const;
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline char At(size_t uiPos) const
+  {
+    return *(m_pData + uiPos);
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline size_t Length() const
+  {
+    return m_uiLength;
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline size_t Capacity() const
+  {
+    return m_uiCapacity;
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline std::string ToStdString() const
+  {
+    return std::string(m_pData);
+  }
+  //-----------------------------------------------------------------------------------------------------------------------------
+  inline const char* ToCChar() const
+  {
+    return m_pData;
+  }
+#pragma endregion
 
 private:
-
   void IncreaseCapacity(size_t uiNewLength = 0);
 
   char* m_pData = nullptr;

LSFramework/Timer.cpp

@@ -2,9 +2,10 @@
 #include <iostream>
 
 //-----------------------------------------------------------------------------------------------------------------------------
-Timer::Timer()
+Timer::Timer(LSString sEndString)
+  : m_StartTimePoint(std::chrono::high_resolution_clock::now())
 {
-  m_StartTimePoint = std::chrono::high_resolution_clock::now();
+  m_sEndString = sEndString;
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------
@@ -16,6 +17,6 @@ Timer::~Timer()
   auto end   = std::chrono::time_point_cast<std::chrono::microseconds>(endTimePoint).time_since_epoch().count();
 
   auto duration = end - start;
-  printf("Duration in Microseconds: %2d (%.3f ms)\n", duration, (duration * 0.001));
+  printf("%sMicroseconds: %2d (%.3f ms)\n", m_sEndString.ToCChar(), static_cast<int>(duration), (duration * 0.001));
   //std::cout << "Duration in Microseconds: " << duration << " (" << duration * 0.001 << " ms)" << std::endl;
 }

LSFramework/Timer.h

@@ -1,12 +1,14 @@
 #pragma once
 #include <chrono>
+#include "LSString.h"
 
 class Timer
 {
 public:
-  Timer(void);
+  Timer(LSString sEndString = "");
 
   ~Timer(void);
 private:
+  LSString m_sEndString;
   std::chrono::time_point<std::chrono::high_resolution_clock> m_StartTimePoint;
 };

LSFramework/main.cpp

@@ -12,15 +12,15 @@ int main()
   {
     printf("---LSString---\n");
     printf("Number of runs: %d\n", (int)RUNS);
-    Timer ttt;
+    Timer tWhole("Complete duration in ");
     for (size_t zRun = 1; zRun <= RUNS; zRun++)
     {
       printf("Run: %2d: ", static_cast<int>(zRun));
 
-      Timer tt;
+      Timer tSingle("Duration in ");
       LSString s(nullptr);
 
-      for (size_t z = 0; z < RUNS * 187; z++)
+      for (size_t z = 0; z < 187; z++)
       {
         s.Append(PAYLOAD);
       }