4.2

1 files changed, 237 insertions, 260 deletions

diff --git a/zen/string_base.h b/zen/string_base.h
index 914e0434..ffc2f839 100644
--- a/zen/string_base.h
+++ b/zen/string_base.h
@@ -12,9 +12,11 @@
 #include "string_tools.h"
 #include <boost/detail/atomic_count.hpp>
 
-//Zbase - a policy based string class
+//Zbase - a policy based string class optimizing performance and genericity
 
 
+namespace zen
+{
 /*
 Allocator Policy:
 -----------------
@@ -28,7 +30,7 @@ public:
     //::operator new/ ::operator delete show same performance characterisics like malloc()/free()!
     static void* allocate(size_t size) { return ::operator new(size); } //throw (std::bad_alloc)
     static void  deallocate(void* ptr) { ::operator delete(ptr); }
-    static size_t calcCapacity(size_t length) { return std::max<size_t>(16, length + length / 2); }
+    static size_t calcCapacity(size_t length) { return std::max<size_t>(16, length + length / 2); } //any growth rate should not exceed golden ratio: 1.618033989
 };
 
 
@@ -43,54 +45,54 @@ public:
 /*
 Storage Policy:
 ---------------
-template <typename T, //Character Type
-         class AP>    //Allocator Policy
-
-    T* create(size_t size)
-    T* create(size_t size, size_t minCapacity)
-    T* clone(T* ptr)
-    void destroy(T* ptr)
-    bool canWrite(const T* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
-    size_t length(const T* ptr)
-    void setLength(T* ptr, size_t newLength)
+template <typename Char, //Character Type
+         class AP>       //Allocator Policy
+
+    Char* create(size_t size)
+    Char* create(size_t size, size_t minCapacity)
+    Char* clone(Char* ptr)
+    void destroy(Char* ptr)
+    bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
+    size_t length(const Char* ptr)
+    void setLength(Char* ptr, size_t newLength)
 */
 
-template <typename T, //Character Type
-         class AP>   //Allocator Policy
+template <typename Char, //Character Type
+         class    AP>   //Allocator Policy
 class StorageDeepCopy : public AP
 {
 protected:
     ~StorageDeepCopy() {}
 
-    static T* create(size_t size) { return create(size, size); }
-    static T* create(size_t size, size_t minCapacity)
+    static Char* create(size_t size) { return create(size, size); }
+    static Char* create(size_t size, size_t minCapacity)
     {
         const size_t newCapacity = AP::calcCapacity(minCapacity);
         assert(newCapacity >= minCapacity);
         assert(minCapacity >= size);
 
-        Descriptor* const newDescr = static_cast<Descriptor*>(AP::allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(T)));
+        Descriptor* const newDescr = static_cast<Descriptor*>(AP::allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char)));
 
         newDescr->length   = size;
         newDescr->capacity = newCapacity;
 
-        return reinterpret_cast<T*>(newDescr + 1);
+        return reinterpret_cast<Char*>(newDescr + 1);
     }
 
-    static T* clone(T* ptr)
+    static Char* clone(Char* ptr)
     {
-        T* newData = create(length(ptr));
+        Char* newData = create(length(ptr));
         std::copy(ptr, ptr + length(ptr) + 1, newData);
         return newData;
     }
 
-    static void destroy(T* ptr) { AP::deallocate(descr(ptr)); }
+    static void destroy(Char* ptr) { AP::deallocate(descr(ptr)); }
 
     //this needs to be checked before writing to "ptr"
-    static bool canWrite(const T* ptr, size_t minCapacity) { return minCapacity <= descr(ptr)->capacity; }
-    static size_t length(const T* ptr) { return descr(ptr)->length; }
+    static bool canWrite(const Char* ptr, size_t minCapacity) { return minCapacity <= descr(ptr)->capacity; }
+    static size_t length(const Char* ptr) { return descr(ptr)->length; }
 
-    static void setLength(T* ptr, size_t newLength)
+    static void setLength(Char* ptr, size_t newLength)
     {
         assert(canWrite(ptr, newLength));
         descr(ptr)->length = newLength;
@@ -103,43 +105,43 @@ private:
         size_t capacity; //allocated size without null-termination
     };
 
-    static       Descriptor* descr(      T* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
-    static const Descriptor* descr(const T* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
+    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
+    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
 };
 
 
-template <typename T, //Character Type
-         class AP>   //Allocator Policy
+template <typename Char, //Character Type
+         class AP>      //Allocator Policy
 class StorageRefCountThreadSafe : public AP
 {
 protected:
     ~StorageRefCountThreadSafe() {}
 
-    static T* create(size_t size)
+    static Char* create(size_t size)
     {
         return create(size, size);
     }
 
-    static T* create(size_t size, size_t minCapacity)
+    static Char* create(size_t size, size_t minCapacity)
     {
         const size_t newCapacity = AP::calcCapacity(minCapacity);
         assert(newCapacity >= minCapacity);
         assert(minCapacity >= size);
 
-        Descriptor* const newDescr = static_cast<Descriptor*>(AP::allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(T)));
+        Descriptor* const newDescr = static_cast<Descriptor*>(AP::allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char)));
         new (newDescr) Descriptor(1, size, newCapacity);
 
-        return reinterpret_cast<T*>(newDescr + 1);
+        return reinterpret_cast<Char*>(newDescr + 1);
     }
 
-    static T* clone(T* ptr)
+    static Char* clone(Char* ptr)
     {
         assert(descr(ptr)->refCount > 0);
         ++descr(ptr)->refCount;
         return ptr;
     }
 
-    static void destroy(T* ptr)
+    static void destroy(Char* ptr)
     {
         if (--descr(ptr)->refCount == 0)
         {
@@ -148,18 +150,18 @@ protected:
         }
     }
 
-    static bool canWrite(const T* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
+    static bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
     {
         assert(descr(ptr)->refCount > 0);
         return descr(ptr)->refCount == 1 && minCapacity <= descr(ptr)->capacity;
     }
 
-    static size_t length(const T* ptr)
+    static size_t length(const Char* ptr)
     {
         return descr(ptr)->length;
     }
 
-    static void setLength(T* ptr, size_t newLength)
+    static void setLength(Char* ptr, size_t newLength)
     {
         assert(canWrite(ptr, newLength));
         descr(ptr)->length = newLength;
@@ -175,97 +177,99 @@ private:
         size_t capacity; //allocated size without null-termination
     };
 
-    static       Descriptor* descr(      T* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
-    static const Descriptor* descr(const T* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
+    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
+    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
 };
 //################################################################################################################################################################
 
 
 //perf note: interstingly StorageDeepCopy and StorageRefCountThreadSafe show same performance in FFS comparison
 
-template <class T,									                  //Character Type
+template <class Char,  							                       //Character Type
          template <class, class> class SP = StorageRefCountThreadSafe, //Storage Policy
-         class AP = AllocatorOptimalSpeed>				              //Allocator Policy
-class Zbase : public SP<T, AP>
+         class AP = AllocatorOptimalSpeed>				               //Allocator Policy
+class Zbase : public SP<Char, AP>
 {
 public:
     Zbase();
-    Zbase(const T* source); //implicit conversion from a C-string
-    Zbase(const T* source, size_t length);
+    Zbase(const Char* source); //implicit conversion from a C-string
+    Zbase(const Char* source, size_t length);
     Zbase(const Zbase& source);
     Zbase(Zbase&& tmp);
-    explicit Zbase(T source); //dangerous if implicit: T buffer[]; Zbase name = buffer; ups...
+    explicit Zbase(Char source); //dangerous if implicit: Char buffer[]; Zbase name = buffer; ups...
     //allow explicit construction from different string type, prevent ambiguity via SFINAE
     template <class S> explicit Zbase(const S& other, typename S::value_type = 0);
     ~Zbase();
 
-    //operator const T* () const; //NO implicit conversion to a C-string!! Many problems... one of them: if we forget to provide operator overloads, it'll just work with a T*...
+    //operator const Char* () const; //NO implicit conversion to a C-string!! Many problems... one of them: if we forget to provide operator overloads, it'll just work with a Char*...
 
     //STL accessors
-    typedef       T*       iterator;
-    typedef const T* const_iterator;
-    typedef       T&       reference;
-    typedef const T& const_reference;
-    typedef       T value_type;
-    const T* begin() const;
-    const T* end()   const;
-    T*       begin();
-    T*       end();
+    typedef       Char*       iterator;
+    typedef const Char* const_iterator;
+    typedef       Char&       reference;
+    typedef const Char& const_reference;
+    typedef       Char value_type;
+    const Char* begin() const;
+    const Char* end()   const;
+    Char*       begin();
+    Char*       end();
 
     //std::string functions
     size_t length() const;
     size_t size() const;
-    const T* c_str() const; //C-string format with NULL-termination
-    const T* data()  const; //internal representation, NULL-termination not guaranteed
-    const T operator[](size_t pos) const;
+    const Char* c_str() const; //C-string format with NULL-termination
+    const Char* data()  const; //internal representation, NULL-termination not guaranteed
+    const Char operator[](size_t pos) const;
     bool empty() const;
     void clear();
-    size_t find(const Zbase& str, size_t pos = 0)    const; //
-    size_t find(const T* str,     size_t pos = 0)    const; //returns "npos" if not found
-    size_t find(T ch,             size_t pos = 0)    const; //
-    size_t rfind(T ch,            size_t pos = npos) const; //
-    size_t rfind(const T* str,    size_t pos = npos) const; //
+    size_t find (const Zbase& str, size_t pos = 0)    const; //
+    size_t find (const Char* str,  size_t pos = 0)    const; //returns "npos" if not found
+    size_t find (Char  ch,         size_t pos = 0)    const; //
+    size_t rfind(Char  ch,         size_t pos = npos) const; //
+    size_t rfind(const Char* str,  size_t pos = npos) const; //
     Zbase& replace(size_t pos1, size_t n1, const Zbase& str);
     void reserve(size_t minCapacity);
-    Zbase& assign(const T* source, size_t len);
-    void resize(size_t newSize, T fillChar = 0);
+    Zbase& assign(const Char* source, size_t len);
+    Zbase& append(const Char* source, size_t len);
+    void resize(size_t newSize, Char fillChar = 0);
     void swap(Zbase& other);
-    void push_back(T val); //STL access
+    void push_back(Char val); //STL access
 
-    Zbase& operator=(const Zbase& source);
-    Zbase& operator=(Zbase&& tmp);
-    Zbase& operator=(const T* source);
-    Zbase& operator=(T source);
+    Zbase& operator=(Zbase source);
+    Zbase& operator=(const Char* source);
+    Zbase& operator=(Char source);
     Zbase& operator+=(const Zbase& other);
-    Zbase& operator+=(const T* other);
-    Zbase& operator+=(T ch);
+    Zbase& operator+=(const Char* other);
+    Zbase& operator+=(Char ch);
 
     static const size_t	npos = static_cast<size_t>(-1);
 
 private:
-    Zbase(int);            //detect usage errors
-    Zbase& operator=(int); //
+    Zbase(int);             //
+    Zbase& operator=(int);  //detect usage errors
+    Zbase& operator+=(int); //
+    void push_back(int);    //
 
-    T* rawStr;
+    Char* rawStr;
 };
 
-template <class T, template <class, class> class SP, class AP> bool operator==(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> bool operator==(const Zbase<T, SP, AP>& lhs, const T*                rhs);
-template <class T, template <class, class> class SP, class AP> bool operator==(const T*                lhs, const Zbase<T, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator==(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator==(const Zbase<Char, SP, AP>& lhs, const Char*                rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator==(const Char*                lhs, const Zbase<Char, SP, AP>& rhs);
 
-template <class T, template <class, class> class SP, class AP> bool operator!=(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> bool operator!=(const Zbase<T, SP, AP>& lhs, const T*                rhs);
-template <class T, template <class, class> class SP, class AP> bool operator!=(const T*                lhs, const Zbase<T, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator!=(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator!=(const Zbase<Char, SP, AP>& lhs, const Char*                rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator!=(const Char*                lhs, const Zbase<Char, SP, AP>& rhs);
 
-template <class T, template <class, class> class SP, class AP> bool operator< (const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> bool operator< (const Zbase<T, SP, AP>& lhs, const T*                rhs);
-template <class T, template <class, class> class SP, class AP> bool operator< (const T*                lhs, const Zbase<T, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator< (const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator< (const Zbase<Char, SP, AP>& lhs, const Char*                rhs);
+template <class Char, template <class, class> class SP, class AP> bool operator< (const Char*                lhs, const Zbase<Char, SP, AP>& rhs);
 
-template <class T, template <class, class> class SP, class AP> const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs, const T*                rhs);
-template <class T, template <class, class> class SP, class AP> const Zbase<T, SP, AP> operator+(const T*                lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> const Zbase<T, SP, AP> operator+(      T                 lhs, const Zbase<T, SP, AP>& rhs);
-template <class T, template <class, class> class SP, class AP> const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs,       T                 rhs);
+template <class Char, template <class, class> class SP, class AP> const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Char*                rhs);
+template <class Char, template <class, class> class SP, class AP> const Zbase<Char, SP, AP> operator+(const Char*                lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> const Zbase<Char, SP, AP> operator+(      Char                 lhs, const Zbase<Char, SP, AP>& rhs);
+template <class Char, template <class, class> class SP, class AP> const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs,       Char                 rhs);
 
 
 
@@ -304,8 +308,8 @@ template <class T, template <class, class> class SP, class AP> const Zbase<T, SP
 
 
 //################################# inline implementation ########################################
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase()
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase()
 {
     //resist the temptation to avoid this allocation by referening a static global: NO performance advantage, MT issues!
     rawStr    = this->create(0);
@@ -313,8 +317,8 @@ Zbase<T, SP, AP>::Zbase()
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase(T source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase(Char source)
 {
     rawStr    = this->create(1);
     rawStr[0] = source;
@@ -322,17 +326,17 @@ Zbase<T, SP, AP>::Zbase(T source)
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase(const T* source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase(const Char* source)
 {
-    const size_t sourceLen = zen::strLength(source);
+    const size_t sourceLen = strLength(source);
     rawStr = this->create(sourceLen);
     std::copy(source, source + sourceLen + 1, rawStr); //include null-termination
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase(const T* source, size_t sourceLen)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase(const Char* source, size_t sourceLen)
 {
     rawStr = this->create(sourceLen);
     std::copy(source, source + sourceLen, rawStr);
@@ -340,23 +344,23 @@ Zbase<T, SP, AP>::Zbase(const T* source, size_t sourceLen)
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase(const Zbase<T, SP, AP>& source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase(const Zbase<Char, SP, AP>& source)
 {
     rawStr = this->clone(source.rawStr);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::Zbase(Zbase<T, SP, AP>&& tmp)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::Zbase(Zbase<Char, SP, AP>&& tmp)
 {
     rawStr = this->clone(tmp.rawStr); //for a ref-counting string there probably isn't a faster way, even with r-value references
 }
 
 
-template <class T, template <class, class> class SP, class AP>
+template <class Char, template <class, class> class SP, class AP>
 template <class S> inline
-Zbase<T, SP, AP>::Zbase(const S& other, typename S::value_type)
+Zbase<Char, SP, AP>::Zbase(const S& other, typename S::value_type)
 {
     const size_t sourceLen = other.size();
     rawStr = this->create(sourceLen);
@@ -365,80 +369,73 @@ Zbase<T, SP, AP>::Zbase(const S& other, typename S::value_type)
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>::~Zbase()
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>::~Zbase()
 {
     this->destroy(rawStr);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::find(const Zbase& str, size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::find(const Zbase& str, size_t pos) const
 {
     assert(pos <= length());
-    const T* thisEnd = end(); //respect embedded 0
-    const T* iter = std::search(begin() + pos, thisEnd,
-                                str.begin(), str.end());
+    const Char* thisEnd = end(); //respect embedded 0
+    const Char* iter = std::search(begin() + pos, thisEnd,
+                                   str.begin(), str.end());
     return iter == thisEnd ? npos : iter - begin();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::find(const T* str, size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::find(const Char* str, size_t pos) const
 {
     assert(pos <= length());
-    const T* thisEnd = end(); //respect embedded 0
-    const T* iter = std::search(begin() + pos, thisEnd,
-                                str, str + zen::strLength(str));
+    const Char* thisEnd = end(); //respect embedded 0
+    const Char* iter = std::search(begin() + pos, thisEnd,
+                                   str, str + strLength(str));
     return iter == thisEnd ? npos : iter - begin();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::find(T ch, size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::find(Char ch, size_t pos) const
 {
     assert(pos <= length());
-    const T* thisEnd = end();
-    const T* iter = std::find(begin() + pos, thisEnd, ch); //respect embedded 0
+    const Char* thisEnd = end();
+    const Char* iter = std::find(begin() + pos, thisEnd, ch); //respect embedded 0
     return iter == thisEnd ? npos : iter - begin();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::rfind(T ch, size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::rfind(Char ch, size_t pos) const
 {
     assert(pos == npos || pos <= length());
 
-    const size_t thisLen = length();
-    if (thisLen == 0) return npos;
-    pos = std::min(thisLen - 1, pos); //handle "npos" and "pos == length()" implicitly
+    const Char* currEnd = pos == npos ? end() : begin() + std::min(pos + 1, length());
 
-    while (rawStr[pos] != ch) //pos points to last char of the string
-    {
-        if (pos == 0)
-            return npos;
-        --pos;
-    }
-    return pos;
+    const Char* iter = find_last(begin(), currEnd, ch);
+    return iter == currEnd ? npos : iter - begin();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::rfind(const T* str, size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::rfind(const Char* str, size_t pos) const
 {
     assert(pos == npos || pos <= length());
 
-    const size_t strLen = zen::strLength(str);
-    const T* currEnd = pos == npos ? end() : begin() + std::min(pos + strLen, length());
+    const size_t strLen = strLength(str);
+    const Char* currEnd = pos == npos ? end() : begin() + std::min(pos + strLen, length());
 
-    const T* iter = std::find_end(begin(), currEnd,
-                                  str, str + strLen);
+    const Char* iter = search_last(begin(), currEnd,
+                                   str, str + strLen);
     return iter == currEnd ? npos : iter - begin();
 }
 
 
-template <class T, template <class, class> class SP, class AP>
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::replace(size_t pos1, size_t n1, const Zbase& str)
+template <class Char, template <class, class> class SP, class AP>
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::replace(size_t pos1, size_t n1, const Zbase& str)
 {
     assert(str.data() < rawStr || rawStr + length() < str.data()); //str mustn't point to data in this string
     assert(pos1 + n1 <= length());
@@ -469,7 +466,7 @@ Zbase<T, SP, AP>& Zbase<T, SP, AP>::replace(size_t pos1, size_t n1, const Zbase&
     else
     {
         //copy directly into new string
-        T* const newStr = this->create(newLen);
+        Char* const newStr = this->create(newLen);
 
         std::copy(rawStr, rawStr + pos1, newStr);
         std::copy(str.data(), str.data() + n2, newStr + pos1);
@@ -482,8 +479,8 @@ Zbase<T, SP, AP>& Zbase<T, SP, AP>::replace(size_t pos1, size_t n1, const Zbase&
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-void Zbase<T, SP, AP>::resize(size_t newSize, T fillChar)
+template <class Char, template <class, class> class SP, class AP> inline
+void Zbase<Char, SP, AP>::resize(size_t newSize, Char fillChar)
 {
     if (canWrite(rawStr, newSize))
     {
@@ -494,7 +491,7 @@ void Zbase<T, SP, AP>::resize(size_t newSize, T fillChar)
     }
     else
     {
-        T* newStr = this->create(newSize);
+        Char* newStr = this->create(newSize);
         newStr[newSize] = 0;
 
         if (length() < newSize)
@@ -511,153 +508,153 @@ void Zbase<T, SP, AP>::resize(size_t newSize, T fillChar)
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator==(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator==(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs)
 {
     return lhs.length() == rhs.length() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); //respect embedded 0
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator==(const Zbase<T, SP, AP>& lhs, const T* rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator==(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
 {
-    return lhs.length() == zen::strLength(rhs) && std::equal(lhs.begin(), lhs.end(), rhs); //respect embedded 0
+    return lhs.length() == strLength(rhs) && std::equal(lhs.begin(), lhs.end(), rhs); //respect embedded 0
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator==(const T* lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator==(const Char* lhs, const Zbase<Char, SP, AP>& rhs)
 {
     return operator==(rhs, lhs);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator!=(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator!=(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs)
 {
     return !operator==(lhs, rhs);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator!=(const Zbase<T, SP, AP>& lhs, const T* rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator!=(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
 {
     return !operator==(lhs, rhs);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator!=(const T* lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator!=(const Char* lhs, const Zbase<Char, SP, AP>& rhs)
 {
     return !operator==(lhs, rhs);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator<(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator<(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs)
 {
     return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
                                         rhs.begin(), rhs.end());
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator<(const Zbase<T, SP, AP>& lhs, const T* rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator<(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
 {
     return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
-                                        rhs, rhs + zen::strLength(rhs));
+                                        rhs, rhs + strLength(rhs));
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool operator<(const T* lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+bool operator<(const Char* lhs, const Zbase<Char, SP, AP>& rhs)
 {
-    return std::lexicographical_compare(lhs, lhs + zen::strLength(lhs), //respect embedded 0
+    return std::lexicographical_compare(lhs, lhs + strLength(lhs), //respect embedded 0
                                         rhs.begin(), rhs.end());
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::length() const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::length() const
 {
-    return SP<T, AP>::length(rawStr);
+    return SP<Char, AP>::length(rawStr);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-size_t Zbase<T, SP, AP>::size() const
+template <class Char, template <class, class> class SP, class AP> inline
+size_t Zbase<Char, SP, AP>::size() const
 {
     return length();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const T* Zbase<T, SP, AP>::c_str() const
+template <class Char, template <class, class> class SP, class AP> inline
+const Char* Zbase<Char, SP, AP>::c_str() const
 {
     return rawStr;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const T* Zbase<T, SP, AP>::data() const
+template <class Char, template <class, class> class SP, class AP> inline
+const Char* Zbase<Char, SP, AP>::data() const
 {
     return rawStr;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const T Zbase<T, SP, AP>::operator[](size_t pos) const
+template <class Char, template <class, class> class SP, class AP> inline
+const Char Zbase<Char, SP, AP>::operator[](size_t pos) const
 {
     assert(pos < length());
     return rawStr[pos];
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const T* Zbase<T, SP, AP>::begin() const
+template <class Char, template <class, class> class SP, class AP> inline
+const Char* Zbase<Char, SP, AP>::begin() const
 {
     return rawStr;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const T* Zbase<T, SP, AP>::end() const
+template <class Char, template <class, class> class SP, class AP> inline
+const Char* Zbase<Char, SP, AP>::end() const
 {
     return rawStr + length();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-T* Zbase<T, SP, AP>::begin()
+template <class Char, template <class, class> class SP, class AP> inline
+Char* Zbase<Char, SP, AP>::begin()
 {
-    reserve(length());
+    reserve(length()); //make unshared!
     return rawStr;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-T* Zbase<T, SP, AP>::end()
+template <class Char, template <class, class> class SP, class AP> inline
+Char* Zbase<Char, SP, AP>::end()
 {
     return begin() + length();
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-void Zbase<T, SP, AP>::push_back(T val)
+template <class Char, template <class, class> class SP, class AP> inline
+void Zbase<Char, SP, AP>::push_back(Char val)
 {
     operator+=(val);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-bool Zbase<T, SP, AP>::empty() const
+template <class Char, template <class, class> class SP, class AP> inline
+bool Zbase<Char, SP, AP>::empty() const
 {
     return length() == 0;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-void Zbase<T, SP, AP>::clear()
+template <class Char, template <class, class> class SP, class AP> inline
+void Zbase<Char, SP, AP>::clear()
 {
     if (!empty())
     {
@@ -672,55 +669,55 @@ void Zbase<T, SP, AP>::clear()
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs)
 {
-    return Zbase<T, SP, AP>(lhs) += rhs;
+    return Zbase<Char, SP, AP>(lhs) += rhs;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs, const T* rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
 {
-    return Zbase<T, SP, AP>(lhs) += rhs;
+    return Zbase<Char, SP, AP>(lhs) += rhs;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const Zbase<T, SP, AP> operator+(const T* lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+const Zbase<Char, SP, AP> operator+(const Char* lhs, const Zbase<Char, SP, AP>& rhs)
 {
-    return Zbase<T, SP, AP>(lhs) += rhs;
+    return Zbase<Char, SP, AP>(lhs) += rhs;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const Zbase<T, SP, AP> operator+(T lhs, const Zbase<T, SP, AP>& rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+const Zbase<Char, SP, AP> operator+(Char lhs, const Zbase<Char, SP, AP>& rhs)
 {
-    return (Zbase<T, SP, AP>() += lhs) += rhs;
+    return Zbase<Char, SP, AP>(lhs) += rhs;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-const Zbase<T, SP, AP> operator+(const Zbase<T, SP, AP>& lhs, T rhs)
+template <class Char, template <class, class> class SP, class AP> inline
+const Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, Char rhs)
 {
-    return Zbase<T, SP, AP>(lhs) += rhs;
+    return Zbase<Char, SP, AP>(lhs) += rhs;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-void Zbase<T, SP, AP>::swap(Zbase<T, SP, AP>& other)
+template <class Char, template <class, class> class SP, class AP> inline
+void Zbase<Char, SP, AP>::swap(Zbase<Char, SP, AP>& other)
 {
     std::swap(rawStr, other.rawStr);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-void Zbase<T, SP, AP>::reserve(size_t minCapacity) //make unshared and check capacity
+template <class Char, template <class, class> class SP, class AP> inline
+void Zbase<Char, SP, AP>::reserve(size_t minCapacity) //make unshared and check capacity
 {
     if (!canWrite(rawStr, minCapacity))
     {
         //allocate a new string
-        T* newStr = create(length(), std::max(minCapacity, length())); //reserve() must NEVER shrink the string: logical const!
+        Char* newStr = create(length(), std::max(minCapacity, length())); //reserve() must NEVER shrink the string: logical const!
         std::copy(rawStr, rawStr + length() + 1, newStr); //include NULL-termination
 
         destroy(rawStr);
@@ -729,8 +726,8 @@ void Zbase<T, SP, AP>::reserve(size_t minCapacity) //make unshared and check cap
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::assign(const T* source, size_t len)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::assign(const Char* source, size_t len)
 {
     if (canWrite(rawStr, len))
     {
@@ -745,80 +742,60 @@ Zbase<T, SP, AP>& Zbase<T, SP, AP>::assign(const T* source, size_t len)
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator=(const Zbase<T, SP, AP>& source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::append(const Char* source, size_t len)
 {
-    Zbase(source).swap(*this);
+    const size_t thisLen = length();
+    reserve(thisLen + len); //make unshared and check capacity
+
+    std::copy(source, source + len, rawStr + thisLen);
+    rawStr[thisLen + len] = 0;
+    setLength(rawStr, thisLen + len);
     return *this;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator=(Zbase<T, SP, AP>&& tmp)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator=(Zbase<Char, SP, AP> other) //unifying assignment: no need for r-value reference optimization!
 {
-    swap(tmp);
+    swap(other);
     return *this;
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator=(const T* source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator=(const Char* source)
 {
-    return assign(source, zen::strLength(source));
+    return assign(source, strLength(source));
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator=(T source)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator=(Char ch)
 {
-    if (canWrite(rawStr, 1))
-    {
-        rawStr[0] = source;
-        rawStr[1] = 0; //include null-termination
-        setLength(rawStr, 1);
-    }
-    else
-        *this = Zbase(source);
-
-    return *this;
+    return assign(&ch, 1);
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator+=(const Zbase<T, SP, AP>& other)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator+=(const Zbase<Char, SP, AP>& other)
 {
-    const size_t thisLen  = length();
-    const size_t otherLen = other.length();
-    reserve(thisLen + otherLen); //make unshared and check capacity
-
-    std::copy(other.rawStr, other.rawStr + otherLen + 1, rawStr + thisLen); //include null-termination
-    setLength(rawStr, thisLen + otherLen);
-    return *this;
+    return append(other.c_str(), other.length());
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator+=(const T* other)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator+=(const Char* other)
 {
-    const size_t thisLen  = length();
-    const size_t otherLen = zen::strLength(other);
-    reserve(thisLen + otherLen); //make unshared and check capacity
-
-    std::copy(other, other + otherLen + 1, rawStr + thisLen); //include null-termination
-    setLength(rawStr, thisLen + otherLen);
-    return *this;
+    return append(other, strLength(other));
 }
 
 
-template <class T, template <class, class> class SP, class AP> inline
-Zbase<T, SP, AP>& Zbase<T, SP, AP>::operator+=(T ch)
+template <class Char, template <class, class> class SP, class AP> inline
+Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator+=(Char ch)
 {
-    const size_t thisLen = length();
-    reserve(thisLen + 1); //make unshared and check capacity
-    rawStr[thisLen] = ch;
-    rawStr[thisLen + 1] = 0;
-    setLength(rawStr, thisLen + 1);
-    return *this;
+    return append(&ch, 1);
+}
 }
 
 #endif //Z_BASE_H_INCLUDED