Day 63 My own string library implementation

mandliya · mandliya · commit a05d36f5783b · 2015-10-18T05:16:56.000-04:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -13,6 +13,19 @@ set(CMAKE_CXX_FLAGS "-Wall -std=c++11 -g -pedantic")
 
 foreach( sourcefile ${SOURCES} )
         get_filename_component( demo_name ${sourcefile} NAME_WE )
+		if (${demo_name} STREQUAL "pstring")
+			add_library(pstring ${sourcefile})
+            continue()
+		endif()
+		if (${demo_name} STREQUAL "pUnitTest")
+			add_library(pUnitTest ${sourcefile})
+            continue()
+		endif()
         add_executable( ${demo_name} ${sourcefile} )
+		if (${demo_name} STREQUAL "pstring_test")
+			target_link_libraries (${demo_name} pstring pUnitTest)
+		endif()
+            continue()
+		endif()
 endforeach( sourcefile ${SOURCES} )
 
diff --git a/README.md b/README.md
@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 91 |
-| Current Streak | 62 days |
-| Longest Streak | 62 ( August 17, 2015 - October 17, 2015 ) |
+| Total Problems | 92 |
+| Current Streak | 63 days |
+| Longest Streak | 63 ( August 17, 2015 - October 18, 2015 ) |
 
 </center>
 
@@ -49,6 +49,7 @@ Include contains single header implementation of data structures and some algori
 | Linux Kernel Double LinkedList Implementation | [double_linked_list.h](include/double_linked_list.h) |
 | Generic Graph Implementation (Adjacency List) | [graph.h](include/graph.h) |
 | Heap Sort Implementation | [heap_sort.h](include/heap_sort.h)|
+| My own string library implementation | [pstring.h](include/pstring.h) [pstring.cpp](include/pstring.cpp)|
 
 ###Bit Manipulation Problems
 | Problem | Solution |
@@ -119,6 +120,7 @@ Include contains single header implementation of data structures and some algori
 | Implementation of Robin-Karp algorithm for string search | [robinKarpStringMatching.cpp](string_problmes/robinKarpStringMatching.cpp) |
 | Find next permutation of a given string, ie. rearrange the given string sucht a way that is next lexicographically greater string than given string | [next_permutation.cpp](string_problems/next_permutation.cpp)|
 | Implementation of Z algorithm for pattern matching | [z.cpp](string_problems/z.cpp)|
+| Test cases for self created string library | [pstring_test.cpp](string_problems/pstring_test.cpp)|
 
 ### Common Data Structure and logic problems
 | Problem | Solution |
diff --git a/include/pUnitTest.cpp b/include/pUnitTest.cpp
@@ -0,0 +1,33 @@
+//  BWUTest.cpp
+//  A simple unit test class
+//  by Bill Weinman <http://bw.org/>
+//  Copyright (c) 2014-2015 The BearHeart Group LLC
+//
+
+#include "pUnitTest.h"
+
+UTest::UTest( const char * _test_str ) {
+    init(_test_str);
+}
+
+void UTest::init( const char * _tstr ) {
+    _test_str = _tstr;
+    _pass_count = _fail_count = 0;
+}
+
+void UTest::test ( const char * description, const int flag ) {
+    const char * pf = nullptr;
+    if (flag) {
+        pf = __ut_pstr;
+        ++_pass_count;
+    } else {
+        pf = __ut_fstr;
+        ++_fail_count;
+    }
+    if(!_summary_flag) printf("%s: %s -> %s\n", _test_str, description, pf);
+}
+
+void UTest::report() const {
+    printf("%s: pass: %ld, fail: %ld\n", _test_str, pass_count(), fail_count());
+    fflush(stdout);
+}
diff --git a/include/pUnitTest.h b/include/pUnitTest.h
@@ -0,0 +1,37 @@
+//  BWUTest.h
+//  A simple unit test class
+
+#ifndef __PSTRING_UTEST__
+#define __PSTRING_UTEST__
+
+#include <cstdio>
+
+#define _UTest_VERSION "1.0.0"
+
+const static char * __ut_pstr = "pass";
+const static char * __ut_fstr = "fail";
+
+class UTest {
+    unsigned long int _pass_count = 0;
+    unsigned long int _fail_count = 0;
+    bool _summary_flag = false;
+
+    const char * _test_str = nullptr;
+
+    UTest( UTest & );                   // no copy constructor
+    UTest operator = ( UTest & );       // no assignment operator
+    UTest(){}                           // no default constructor
+public:
+    static const char * version() { return _UTest_VERSION; }
+
+    UTest( const char * );
+    void init ( const char * );
+    bool summary ( bool flag ) { return _summary_flag = flag; }
+    bool summary ( ) { return _summary_flag; }
+    unsigned long int pass_count() const { return _pass_count; }
+    unsigned long int fail_count() const { return _fail_count; }
+    void test ( const char * description, const int flag );
+    void report() const;
+};
+
+#endif /* defined(__PSTRING_UTEST__) */
diff --git a/include/pstring.cpp b/include/pstring.cpp
@@ -0,0 +1,275 @@
+/**
+ *  A string library for practice
+ *  Ravi Mandliya
+ */
+
+#include "pstring.h"
+
+using String = algo::String;
+
+String::String( ) {
+  _reset();
+}
+
+String::String( const char * s ) {
+  _copy_str(s);
+}
+
+String::String( const String & str ) {
+  _copy_str(str);
+}
+
+String::String( String && other ) noexcept {
+  _reset();
+  _str = other._str;
+  _str_len = other._str_len;
+  other._str = nullptr;
+  other._str_len = 0;
+  other._reset();
+}
+
+String::~String() {
+  _reset();
+}
+
+void String::_alloc_cstr(size_t sz) {
+  if ( _str ) {
+    _reset();
+  }
+  _str_len = ( sz > algo::_PSTRING_MAX_LEN ) ? algo::_PSTRING_MAX_LEN : sz;
+  _str = new char[_str_len + 1]();
+}
+
+void String::_reset() {
+  if ( _str ) {
+    delete [] _str;
+  }
+  _str = nullptr;
+  _str_len = 0;
+}
+
+void String::_swap( String & other ) {
+  std::swap( _str, other._str );
+  std::swap( _str_len, other._str_len );
+}
+
+const char * String::c_str() const {
+  return _str;
+}
+
+void String::_copy_str( const char * s ) {
+  if ( s ) {
+    size_t sz = strnlen( s, algo::_PSTRING_MAX_LEN );
+    _alloc_cstr( sz );
+    strncpy( _str, s, sz );
+  }
+}
+
+bool String::_have_value() const {
+  if ( _str ) {
+    return true;
+  }
+  return false;
+}
+
+size_t String::_char_find( const char & match, size_t pos ) const {
+  if ( pos >= _str_len ) {
+    return algo::npos;
+  }
+  for ( size_t i  = 0; _str[i + pos]; ++i ) {
+    if ( _str[i] == match ) {
+      return i;
+    }
+  }
+  return algo::npos;
+}
+
+void String::_char_replace( const char & match_char,
+                            const char & replace_char) {
+  for ( size_t i = 0; _str[i]; ++i ) {
+    if ( _str[i] == match_char ) {
+      _str[i] = replace_char;
+      return;
+    }
+  }
+}
+
+String & String::operator = ( String other ) {
+  _swap(other);
+  return *this;
+}
+
+String & String::operator += ( const char * s ) {
+  if ( s ) {
+    size_t len1 = strlen(s);
+    if ( len1 < 1 ) {
+      return *this;
+    }
+    size_t new_len = len1 + _str_len;
+    new_len = (new_len > algo::_PSTRING_MAX_LEN )  ? algo::_PSTRING_MAX_LEN : new_len;
+    char * buf = new char[new_len + 1];
+    if (_str_len && _str ) {
+      memcpy(buf, _str, _str_len);
+    }
+    memcpy(buf + _str_len, s, len1);
+    _copy_str( buf );
+    delete[] buf;
+  }
+  return * this;
+}
+
+String & String::operator += ( const String & s ) {
+  operator+=( s.c_str() );
+  return * this;
+}
+
+const char String::operator [] (const size_t index) const {
+  if ( index >= this->length() ) return 0;
+  return _str[index];
+}
+
+bool String::operator == ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) == 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+bool String::operator != ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) != 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+bool String::operator >= ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) >= 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+bool String::operator <= ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) <= 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+bool String::operator < ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) < 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+bool String::operator > ( const String & s ) const {
+  if ( std::strncmp(this->c_str(), s.c_str(), algo::_PSTRING_MAX_LEN ) > 0 ) {
+    return true;
+  }
+  else return false;
+}
+
+String::operator const char * () const {
+  return this->c_str();
+}
+
+String String::lower() const {
+  String rs = *this;
+  for ( size_t i = 0; rs._str[i]; ++i ) {
+    rs._str[i] = tolower(rs._str[i]);
+  }
+  return rs;
+}
+
+String String::upper() const {
+  String rs = *this;
+  for ( size_t i = 0; rs._str[i]; ++i ) {
+    rs._str[i] = toupper(rs._str[i]);
+  }
+  return rs;
+}
+
+const char & String::front() const {
+  return _str[0];
+}
+
+const char & String::back() const {
+  return _str[_str_len - 1];
+}
+
+String String::substr( size_t pos, size_t len ) const {
+  String rs;
+  char * buf;
+  if ( len + 1 > algo::_PSTRING_MAX_LEN ||
+       ( pos + len ) > algo::_PSTRING_MAX_LEN ) {
+    return rs;
+  }
+  if ( _str_len - pos < len ) {
+    return rs;
+  }
+  if (!_str) {
+    return rs;
+  }
+  buf = new char[ len + 1 ]();
+  memcpy( buf, _str + pos, len );
+  rs = buf;
+  delete[] buf;
+  return rs;
+}
+
+size_t String::find( const char * s, size_t pos ) const {
+  size_t index = algo::npos;
+  if ( pos >= _str_len ) {
+    return index;
+  }
+  char * sub = strstr( _str + pos, s );
+  if ( sub ) {
+    return ( sub - _str );
+  }
+  return algo::npos;
+}
+
+size_t String::find( const String & match, size_t pos ) const {
+  return find( match.c_str(), pos);
+}
+
+size_t String::find( char c, size_t pos ) const {
+  return _char_find(c, pos);
+}
+
+String String::replace( size_t pos, size_t len, const char * str ) {
+  String res;
+  if ( ( pos >= _str_len ) || ( pos + len >= _str_len ) ) {
+    return res;
+  }
+  String s1 = pos > 0 ? substr( 0, pos ) : "" ;
+  String s2 = str;
+  String s3 = substr( pos + len, _str_len - (pos+len));
+  String s4 = s1 + s2 + s3;
+  return s4;
+}
+
+String String::replace( size_t pos, size_t len, const String & str) {
+  return replace(pos, len, str.c_str());
+}
+
+int String::compare( const char * str ) const {
+  return strncmp( this->c_str(), str, algo::_PSTRING_MAX_LEN );
+}
+
+int String::compare( const String & str ) const noexcept {
+  return strncmp( this->c_str(), str.c_str(), algo::_PSTRING_MAX_LEN );
+}
+
+String algo::operator + ( const String & lhs, const String & rhs ) {
+  String ans = lhs;
+  ans += rhs;
+  return ans;
+}
+
+String algo::operator + ( const String & lhs, const char * rhs ) {
+  String ans = lhs;
+  ans += rhs;
+  return ans;
+}
diff --git a/include/pstring.h b/include/pstring.h
diff --git a/string_problems/pstring_test.cpp b/string_problems/pstring_test.cpp
