Prefixed private attributes with _

- adapted braces
- added comments

src/string/string.cpp

@@ -2,94 +2,91 @@
 
 namespace c0ding {
   string::string() {
-    data = std::string();
+    _data = std::string();
   }
 
   string::string(string& str) {
-    data = std::string(str.get());
+    _data = std::string(str.get());
   }
 
   string::string(const std::string& str) {
-    data = std::string(str);
+    _data = std::string(str);
   }
 
   string::string(const c0ding::string& str, std::size_t pos, std::size_t len) {
-    data = std::string(str.get(), pos, len);
+    _data = std::string(str.get(), pos, len);
   }
 
   string::string(const std::string& str, std::size_t pos, std::size_t len) {
-    data = std::string(str, pos, len);
+    _data = std::string(str, pos, len);
   }
 
   string::string(const char* s) {
-    data = std::string(s);
+    _data = std::string(s);
   }
 
   string::string(const char* s, std::size_t n) {
-    data = std::string(s, n);
+    _data = std::string(s, n);
   }
 
   string::string(std::size_t n, char c) {
-    data = std::string(n, c);
+    _data = std::string(n, c);
   }
 
   template<class InputIterator>
   string::string(InputIterator first, InputIterator last) {
-    data = std::string(first, last);
+    _data = std::string(first, last);
   }
 
   string::string(std::initializer_list<char> il) {
-    data = std::string(il);
+    _data = std::string(il);
   }
 
   string::string(std::string&& str) noexcept {
-    data = std::string(str);
+    _data = std::string(str);
   }
 
   string::operator std::string() {
-    return data;
+    return _data;
   }
 
   string::operator std::string() const {
-    return data;
+    return _data;
   }
 
   string& string::operator=(const string& str) {
-    if (*this != str) {
+    if (this != &str) // Compare references
-      data = str.get();
+      _data = str.get();
-    }
 
     return *this;
   }
 
   string& string::operator=(const std::string& str) {
-    if (*this != str) {
+    if (*this != str) // Compare values
-      data = str;
+      _data = str;
-    }
 
     return *this;
   }
 
   string& string::operator=(const char* str) {
-    if (*this != str) {
+    if (*this != str) // Compare values
-      data = str;
+      _data = str;
-    }
 
     return *this;
   }
 
   string& string::operator+=(const string& str) {
-    data += str.get();
+    _data += str.get();
     return *this;
   }
 
   string& string::operator+=(const std::string& str) {
-    data += str;
+    _data += str;
     return *this;
   }
 
   string& string::operator+=(const char* str) {
-    data += str;
+    _data += str;
     return *this;
   }
 
@@ -139,81 +136,89 @@ namespace c0ding {
 
   void string::erase_line(const std::string& sequence) {
     std::size_t pos;
-    if ((pos = data.find(sequence)) != std::string::npos) {
+
-      std::size_t start = data.rfind('\n', pos);
+    if ((pos = _data.find(sequence)) != std::string::npos) {
-      std::size_t end = data.find('\n', pos);
+      std::size_t start = _data.rfind('\n', pos);
-      std::size_t size = (end != std::string::npos) ? end - start : data.length() - start;
+      std::size_t end = _data.find('\n', pos);
-      data.erase(start, size);
+      std::size_t size = (end != std::string::npos) ? end - start : _data.length() - start;
+      _data.erase(start, size);
     }
   }
 
   std::string string::get() {
-    return data;
+    return _data;
   }
 
   std::string string::get() const {
-    return data;
+    return _data;
   }
 
   std::string string::get_from(std::string delim) {
     std::string::size_type found;
-    found = data.find(delim);
+    found = _data.find(delim);
+
     if (found != std::string::npos) {
-      data.replace(0, (found + delim.length()), "");
+      _data.replace(0, (found + delim.length()), "");
-      return data;
+      return _data;
     }
+
     return delim;
   }
 
   std::string string::get_until(std::string delim) {
     std::string::size_type found;
-    found = data.find(delim);
+    found = _data.find(delim);
+
     if (found != std::string::npos) {
-      data.replace(found, data.length(), "");
+      _data.replace(found, _data.length(), "");
-      return data;
+      return _data;
     }
+
     return delim;
   }
 
   void string::replace(const std::string& value, const std::string& replacement) {
     std::string::size_type found = 0;
-    while ((found = data.find(value, found + replacement.length())) != std::string::npos) {
+
-      data.replace(found, value.length(), replacement);
+    while ((found = _data.find(value, found + replacement.length())) != std::string::npos)
-    }
+      _data.replace(found, value.length(), replacement);
   }
 
   std::vector<std::string> string::split(const std::string& delim) {
     std::vector<std::string> parts;
-    if (!data.length() || data.length() <= 0) { // string is not valid
+
+    if (!_data.length() || _data.length() <= 0) // string is not valid
       return parts;
-    }
+
-    std::string::size_type start = data.find_first_not_of(delim), end;
+    std::string::size_type start = _data.find_first_not_of(delim), end;
+
     if (start == std::string::npos) { // string contains no delim
-      parts.push_back(data);
+      parts.push_back(_data);
       return parts;
     }
 
-    while ((end = data.find(delim, start)) != std::string::npos) {
+    while ((end = _data.find(delim, start)) != std::string::npos) {
-      std::string part = data.substr(start, end - start);
+      std::string part = _data.substr(start, end - start);
-      if (part.length() > 0) {
+
+      if (part.length() > 0)
         parts.push_back(part);
-      }
+
       start = end + delim.length();
     }
 
-    std::string last = data.substr(start, end - start);
+    std::string last = _data.substr(start, end - start);
-    if (last.length() > 0) {
+
+    if (last.length() > 0)
       parts.push_back(last);
-    }
 
     return parts;
   }
 
   void string::to_lower() {
-    std::transform(data.begin(), data.end(), data.begin(), ::tolower);
+    std::transform(_data.begin(), _data.end(), _data.begin(), ::tolower);
   }
 
   void string::to_upper() {
-    std::transform(data.begin(), data.end(), data.begin(), ::toupper);
+    std::transform(_data.begin(), _data.end(), _data.begin(), ::toupper);
   }
 }

src/string/string.h

@@ -310,7 +310,7 @@ namespace c0ding {
     void to_upper();
 
   private:
-    std::string data;
+    std::string _data;
   };
 }