Implemented strSplit() and strJoin() with tests.

Author: end2endzone

src/bin2cpp/common.cpp

@@ -27,6 +27,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
+#include <sstream>
 
 #include "rapidassist/strings.h"
 #include "rapidassist/filesystem.h"
@@ -322,4 +323,45 @@ namespace bin2cpp
     return tmp;
   }
 
+  void strSplit(const std::string& value, char separator, std::vector<std::string>& values)
+  {
+    values.clear();
+    size_t start = 0;
+    size_t end = std::string::npos;
+    size_t length = 0;
+
+    // find first separator
+    end = value.find(separator, start);
+    while ( end != std::string::npos )
+    {
+      length = end - start;
+      std::string item = value.substr(start, length);
+      values.push_back(item);
+
+      // find next separator
+      start = end + 1;
+      end = value.find(separator, start);
+    }
+
+    // Capture last token
+    values.push_back(value.substr(start));
+  }
+
+  std::string strJoin(const std::vector<std::string>& values, char separator)
+  {
+    std::string output;
+
+    for ( size_t i = 0; i < values.size(); i++ )
+    {
+      const std::string& element = values[i];
+      output += element;
+      
+      bool is_last = (i == (values.size() - 1));
+      if ( !is_last )
+        output.append(1, separator);
+    }
+
+    return output;
+  }
+
 }; //bin2cpp

src/bin2cpp/common.h

@@ -29,6 +29,7 @@
 #include <string>
 #include <stdio.h>
 #include <set>
+#include <vector>
 
 namespace bin2cpp
 {
@@ -124,6 +125,22 @@ namespace bin2cpp
   ///<return>Returns the path matching all given components.<return>
   std::string pathJoin(const std::string & directory, const std::string & file_name, const std::string & file_extension);
 
+  ///<summary>
+  ///Split a string into a list of values based on a specified separator character.
+  ///</summary>
+  ///<param name="value">The input string that contains values to split.</param>
+  ///<param name="separator">The character that separate the values in the string.</param>
+  ///<param name="values">The output individual values in the input string.</param>
+  void strSplit(const std::string & value, char separator, std::vector<std::string> & values);
+
+  ///<summary>
+  ///"Combine a list of values into a single string, using a specified separator character.
+  ///</summary>
+  ///<param name="values">The list of values to join to a single string.</param>
+  ///<param name="separator">The character that separate the values in the string.</param>
+  ///<return>Returns the combined string.<return>
+  std::string strJoin(const std::vector<std::string>& values, char separator);
+
 }; //bin2cpp
 
 #endif //BIN2CPP_COMMON_H

test/bin2cpp_unittest/TestCommon.cpp

@@ -253,3 +253,53 @@ TEST_F(TestCommon, testPathSplitJoin)
       "file_ext=\"" << file_ext << "\"\n";
   }
 }
+
+TEST_F(TestCommon, testStringSplitJoin)
+{
+  struct TEST_HELPER
+  {
+    char separator;
+    std::string value;
+    std::vector<std::string> expected_values;
+  };
+  static const char SEPARATOR = ':';
+
+  // arrange
+  static const TEST_HELPER test_values[] = {
+    {SEPARATOR, "",                   {""}},              // empty string
+    {SEPARATOR, "abc",                {"abc"}},           // no separator
+    {SEPARATOR, "a:b:c",              {"a", "b", "c"}},   // multiple
+    {SEPARATOR, ":b:c",               {"", "b", "c"}},    // start with separator
+    {SEPARATOR, "a:b:",               {"a", "b", ""}},    // end with separator
+    {SEPARATOR, "a::",                {"a", "", ""}},     // 2 consecutive separators
+    {SEPARATOR, "::",                 {"", "", ""}},      // only consecutive separators
+  };
+  static const size_t num_test_values = sizeof(test_values) / sizeof(test_values[0]);
+
+  // act (strSplit)
+  for ( size_t i = 0; i < num_test_values; i++ )
+  {
+    const TEST_HELPER& t = test_values[i];
+
+    std::vector<std::string> actual_values;
+    bin2cpp::strSplit(t.value, t.separator, actual_values);
+
+    // assert
+    ASSERT_EQ(actual_values, t.expected_values) << "Test fail for strSplit() with test_values[" << i << "]. Splitting value `" << t.value << "` with separator '" << t.separator << "' should result in " << t.expected_values.size() << " elements.";
+  }
+
+  // act (strJoin)
+  for ( size_t i = 0; i < num_test_values; i++ )
+  {
+    const TEST_HELPER& t = test_values[i];
+
+    std::vector<std::string> tmp_values;
+    bin2cpp::strSplit(t.value, t.separator, tmp_values);
+
+    std::string expected_value = t.value;
+    std::string actual_value = bin2cpp::strJoin(tmp_values, t.separator);
+
+    // assert
+    ASSERT_EQ(actual_value, expected_value) << "Test fail for strJoin() with test_values[" << i << "]. Joining values with separator '" << t.separator << "' should result in `" << expected_value << "` but we got `" << actual_value << "`.";
+  }
+}