8.6

1 files changed, 149 insertions, 229 deletions

diff --git a/zen/string_base.h b/zen/string_base.h
index b54c3b2e..1ee37563 100644
--- a/zen/string_base.h
+++ b/zen/string_base.h
@@ -26,7 +26,7 @@ Allocator Policy:
 */
 class AllocatorOptimalSpeed //exponential growth + min size
 {
-public:
+protected:
     //::operator new/ ::operator delete show same performance characterisics like malloc()/free()!
     static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
     static void  deallocate(void* ptr) { ::free(ptr); }
@@ -38,7 +38,7 @@ public:
 
 class AllocatorOptimalMemory //no wasted memory, but more reallocations required when manipulating string
 {
-public:
+protected:
     static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
     static void  deallocate(void* ptr) { ::free(ptr); }
     static size_t calcCapacity(size_t length) { return length; }
@@ -81,8 +81,9 @@ protected:
 
     Char* clone(Char* ptr)
     {
-        Char* newData = create(length(ptr)); //throw std::bad_alloc
-        std::copy(ptr, ptr + length(ptr) + 1, newData);
+        const size_t len = length(ptr);
+        Char* newData = create(len); //throw std::bad_alloc
+        std::copy(ptr, ptr + len + 1, newData);
         return newData;
     }
 
@@ -207,25 +208,28 @@ private:
     static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
 };
 
+
+template <class Char>
+using DefaultStoragePolicy = StorageRefCountThreadSafe<Char, AllocatorOptimalSpeed>;
+
+
 //################################################################################################################################################################
 
 //perf note: interestingly StorageDeepCopy and StorageRefCountThreadSafe show same performance in FFS comparison
 
-template <class Char,                                                   //Character Type
-          template <class, class> class SP = StorageRefCountThreadSafe, //Storage Policy
-          class AP = AllocatorOptimalSpeed>                             //Allocator Policy
-class Zbase : public SP<Char, AP>
+template <class Char,                                       //Character Type
+          template <class> class SP = DefaultStoragePolicy> //Storage Policy
+class Zbase : public SP<Char>
 {
 public:
     Zbase();
-    Zbase(const Char* source); //implicit conversion from a C-string
-    Zbase(const Char* source, size_t length);
-    Zbase(const Zbase& source);
+    Zbase(const Char* str) : Zbase(str, str + strLength(str)) {} //implicit conversion from a C-string!
+    Zbase(const Char* str, size_t len) : Zbase(str, str + len) {}
+    Zbase(const Zbase& str);
     Zbase(Zbase&& tmp) noexcept;
-    //explicit Zbase(Char source); //dangerous if implicit: Char buffer[]; return buffer[0]; ups... forgot &, but not a compiler error! //-> non-standard extension!!!
-
-    //allow explicit construction from different string type, prevent ambiguity via SFINAE
-    //template <class S> explicit Zbase(const S& other, typename S::value_type = 0);
+    template <class InputIterator>
+    Zbase(InputIterator first, InputIterator last);
+    //explicit Zbase(Char ch); //dangerous if implicit: Char buffer[]; return buffer[0]; ups... forgot &, but not a compiler error! //-> non-standard extension!!!
 
     ~Zbase();
 
@@ -238,19 +242,17 @@ public:
     using const_reference = const Char&;
     using value_type      = Char;
 
-    Zbase(const_iterator first, const_iterator last);
-    Char*       begin();
-    Char*       end  ();
-    const Char* begin() const;
-    const Char* end  () const;
-    const Char* cbegin() const { return begin(); }
-    const Char* cend  () const { return end(); }
+    iterator begin();
+    iterator end  ();
+    const_iterator begin () const { return rawStr_; }
+    const_iterator end   () const { return rawStr_ + length(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend  () const { return end  (); }
 
     //std::string functions
     size_t length() const;
     size_t size  () const { return length(); }
-    const Char* c_str() const { return rawStr; } //C-string format with 0-termination
-    const Char* data()  const { return rawStr; } //internal representation, 0-termination not guaranteed
+    const Char* c_str() const { return rawStr_; } //C-string format with 0-termination
     const Char operator[](size_t pos) const;
     bool empty() const { return length() == 0; }
     void clear();
@@ -261,20 +263,24 @@ public:
     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 Char* source, size_t len);
-    Zbase& append(const Char* source, size_t len);
+    Zbase& assign(const Char* str, size_t len) { return assign(str, str + len); }
+    Zbase& append(const Char* str, size_t len) { return append(str, str + len); }
+
+    template <class InputIterator> Zbase& assign(InputIterator first, InputIterator last);
+    template <class InputIterator> Zbase& append(InputIterator first, InputIterator last);
+
     void resize(size_t newSize, Char fillChar = 0);
-    void swap(Zbase& other);
+    void swap(Zbase& str) { std::swap(rawStr_, str.rawStr_); }
     void push_back(Char val) { operator+=(val); } //STL access
     void pop_back();
 
-    Zbase& operator=(const Zbase& source);
+    Zbase& operator=(const Zbase& str);
     Zbase& operator=(Zbase&& tmp) noexcept;
-    Zbase& operator=(const Char* source);
-    Zbase& operator=(Char source);
-    Zbase& operator+=(const Zbase& other);
-    Zbase& operator+=(const Char* other);
-    Zbase& operator+=(Char ch);
+    Zbase& operator=(const Char* str)   { return assign(str, strLength(str)); }
+    Zbase& operator=(Char ch)           { return assign(&ch, 1); }
+    Zbase& operator+=(const Zbase& str) { return append(str.c_str(), str.length()); }
+    Zbase& operator+=(const Char* str)  { return append(str, strLength(str)); }
+    Zbase& operator+=(Char ch)          { return append(&ch, 1); }
 
     static const size_t npos = static_cast<size_t>(-1);
 
@@ -284,32 +290,32 @@ private:
     Zbase& operator+=(int) = delete; //
     void   push_back (int) = delete; //
 
-    Char* rawStr;
+    Char* rawStr_;
 };
 
-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> inline bool operator==(const Char*                lhs, const Zbase<Char, SP, AP>& rhs) { return operator==(rhs, lhs); }
+template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
+template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Char*            rhs);
+template <class Char, template <class> class SP> inline bool operator==(const Char*            lhs, const Zbase<Char, SP>& rhs) { return operator==(rhs, lhs); }
 
-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 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 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 Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, rhs); }
+template <class Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Char*            rhs) { return !operator==(lhs, rhs); }
+template <class Char, template <class> class SP> inline bool operator!=(const Char*            lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, 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 Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
+template <class Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Char*            rhs);
+template <class Char, template <class> class SP> bool operator<(const Char*            lhs, const Zbase<Char, SP>& rhs);
 
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Zbase<Char, SP, AP>& rhs) { return Zbase<Char, SP, AP>(lhs) += rhs; }
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs, const Char*                rhs) { return Zbase<Char, SP, AP>(lhs) += rhs; }
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs,       Char                 rhs) { return Zbase<Char, SP, AP>(lhs) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Char*            rhs) { return Zbase<Char, SP>(lhs) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs,       Char             rhs) { return Zbase<Char, SP>(lhs) += rhs; }
 
 //don't use unified first argument but save one move-construction in the r-value case instead!
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Zbase<Char, SP, AP>& rhs) { return std::move(lhs += rhs); } //the move *is* needed!!!
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Char*                rhs) { return std::move(lhs += rhs); } //lhs, is an l-value parameter...
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs,       Char                 rhs) { return std::move(lhs += rhs); } //and not a local variable => no copy elision
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Zbase<Char, SP>& rhs) { return std::move(lhs += rhs); } //the move *is* needed!!!
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Char*            rhs) { return std::move(lhs += rhs); } //lhs, is an l-value parameter...
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs,       Char             rhs) { return std::move(lhs += rhs); } //and not a local variable => no copy elision
 
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(      Char          lhs, const Zbase<Char, SP, AP>& rhs) { return Zbase<Char, SP, AP>(&lhs, 1) += rhs; }
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(const Char*         lhs, const Zbase<Char, SP, AP>& rhs) { return Zbase<Char, SP, AP>(lhs    ) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(      Char        lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(&lhs, 1) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Char*       lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs    ) += rhs; }
 
 
 
@@ -324,82 +330,51 @@ template <class Char, template <class, class> class SP, class AP> inline Zbase<C
 
 
 //################################# implementation ########################################
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::Zbase()
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase()
 {
     //resist the temptation to avoid this allocation by referening a static global: NO performance advantage, MT issues!
-    rawStr    = this->create(0);
-    rawStr[0] = 0;
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::Zbase(const Char* source)
-{
-    const size_t sourceLen = strLength(source);
-    rawStr = this->create(sourceLen);
-    std::copy(source, source + sourceLen + 1, rawStr); //include null-termination
+    rawStr_    = this->create(0);
+    rawStr_[0] = 0;
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::Zbase(const Char* source, size_t sourceLen)
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>::Zbase(InputIterator first, InputIterator last)
 {
-    rawStr = this->create(sourceLen);
-    std::copy(source, source + sourceLen, rawStr);
-    rawStr[sourceLen] = 0;
+    rawStr_ = this->create(std::distance(first, last));
+    *std::copy(first, last, rawStr_) = 0;
 }
 
 
-template <class Char, template <class, class> class SP, class AP>
-Zbase<Char, SP, AP>::Zbase(const_iterator first, const_iterator last)
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase(const Zbase<Char, SP>& str)
 {
-    assert(first <= last);
-    const size_t sourceLen = last - first;
-    rawStr = this->create(sourceLen);
-    std::copy(first, last, rawStr);
-    rawStr[sourceLen] = 0;
+    rawStr_ = this->clone(str.rawStr_);
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::Zbase(const Zbase<Char, SP, AP>& source)
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase(Zbase<Char, SP>&& tmp) noexcept
 {
-    rawStr = this->clone(source.rawStr);
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::Zbase(Zbase<Char, SP, AP>&& tmp) noexcept
-{
-    rawStr = tmp.rawStr;
-    tmp.rawStr = nullptr; //usually nullptr would violate the class invarants, but it is good enough for the destructor!
+    rawStr_ = tmp.rawStr_;
+    tmp.rawStr_ = nullptr; //usually nullptr would violate the class invarants, but it is good enough for the destructor!
     //caveat: do not increment ref-count of an unshared string! We'd lose optimization opportunity of reusing its memory!
 }
 
-/*
-template <class Char, template <class, class> class SP, class AP>
-template <class S> inline
-Zbase<Char, SP, AP>::Zbase(const S& other, typename S::value_type)
-{
-    const size_t sourceLen = other.size();
-    rawStr = this->create(sourceLen);
-    std::copy(other.c_str(), other.c_str() + sourceLen, rawStr);
-    rawStr[sourceLen] = 0;
-}
-*/
 
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>::~Zbase()
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::~Zbase()
 {
     static_assert(noexcept(this->~Zbase()), ""); //has exception spec of compiler-generated destructor by default
 
-    this->destroy(rawStr); //rawStr may be nullptr; see move constructor!
+    this->destroy(rawStr_); //rawStr_ may be nullptr; see move constructor!
 }
 
 
-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
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(const Zbase& str, size_t pos) const
 {
     assert(pos <= length());
     const size_t len = length();
@@ -410,8 +385,8 @@ size_t Zbase<Char, 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 Char* str, size_t pos) const
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(const Char* str, size_t pos) const
 {
     assert(pos <= length());
     const size_t len = length();
@@ -422,8 +397,8 @@ size_t Zbase<Char, SP, AP>::find(const Char* str, 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
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(Char ch, size_t pos) const
 {
     assert(pos <= length());
     const size_t len = length();
@@ -433,8 +408,8 @@ size_t Zbase<Char, SP, AP>::find(Char 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
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::rfind(Char ch, size_t pos) const
 {
     assert(pos == npos || pos <= length());
     const size_t len = length();
@@ -444,8 +419,8 @@ size_t Zbase<Char, SP, AP>::rfind(Char ch, 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
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::rfind(const Char* str, size_t pos) const
 {
     assert(pos == npos || pos <= length());
     const size_t strLen = strLength(str);
@@ -457,126 +432,112 @@ size_t Zbase<Char, SP, AP>::rfind(const Char* str, size_t pos) const
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-void Zbase<Char, SP, AP>::resize(size_t newSize, Char fillChar)
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::resize(size_t newSize, Char fillChar)
 {
     const size_t oldSize = length();
-    if (this->canWrite(rawStr, newSize))
+    if (this->canWrite(rawStr_, newSize))
     {
         if (oldSize < newSize)
-            std::fill(rawStr + oldSize, rawStr + newSize, fillChar);
-        rawStr[newSize] = 0;
-        this->setLength(rawStr, newSize);
+            std::fill(rawStr_ + oldSize, rawStr_ + newSize, fillChar);
+        rawStr_[newSize] = 0;
+        this->setLength(rawStr_, newSize);
     }
     else
     {
         Char* newStr = this->create(newSize);
         if (oldSize < newSize)
         {
-            std::copy(rawStr, rawStr + oldSize, newStr);
+            std::copy(rawStr_, rawStr_ + oldSize, newStr);
             std::fill(newStr + oldSize, newStr + newSize, fillChar);
         }
         else
-            std::copy(rawStr, rawStr + newSize, newStr);
+            std::copy(rawStr_, rawStr_ + newSize, newStr);
         newStr[newSize] = 0;
 
-        this->destroy(rawStr);
-        rawStr = newStr;
+        this->destroy(rawStr_);
+        rawStr_ = newStr;
     }
 }
 
 
-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)
+template <class Char, template <class> class SP> inline
+bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
 {
     return lhs.length() == rhs.length() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); //respect embedded 0
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-bool operator==(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
+template <class Char, template <class> class SP> inline
+bool operator==(const Zbase<Char, SP>& lhs, const Char* rhs)
 {
     return lhs.length() == strLength(rhs) && std::equal(lhs.begin(), lhs.end(), rhs); //respect embedded 0
 }
 
 
-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)
+template <class Char, template <class> class SP> inline
+bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
 {
     return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
                                         rhs.begin(), rhs.end());
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-bool operator<(const Zbase<Char, SP, AP>& lhs, const Char* rhs)
+template <class Char, template <class> class SP> inline
+bool operator<(const Zbase<Char, SP>& lhs, const Char* rhs)
 {
     return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
                                         rhs, rhs + strLength(rhs));
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-bool operator<(const Char* lhs, const Zbase<Char, SP, AP>& rhs)
+template <class Char, template <class> class SP> inline
+bool operator<(const Char* lhs, const Zbase<Char, SP>& rhs)
 {
     return std::lexicographical_compare(lhs, lhs + strLength(lhs), //respect embedded 0
                                         rhs.begin(), rhs.end());
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-size_t Zbase<Char, SP, AP>::length() const
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::length() const
 {
-    return SP<Char, AP>::length(rawStr);
+    return SP<Char>::length(rawStr_);
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-const Char Zbase<Char, SP, AP>::operator[](size_t pos) const
+template <class Char, template <class> class SP> inline
+const Char Zbase<Char, SP>::operator[](size_t pos) const
 {
     assert(pos < length()); //design by contract! no runtime check!
-    return rawStr[pos];
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-const Char* Zbase<Char, SP, AP>::begin() const
-{
-    return rawStr;
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-const Char* Zbase<Char, SP, AP>::end() const
-{
-    return rawStr + length();
+    return rawStr_[pos];
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-Char* Zbase<Char, SP, AP>::begin()
+template <class Char, template <class> class SP> inline
+auto Zbase<Char, SP>::begin() -> iterator
 {
     reserve(length()); //make unshared!
-    return rawStr;
+    return rawStr_;
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-Char* Zbase<Char, SP, AP>::end()
+template <class Char, template <class> class SP> inline
+auto Zbase<Char, SP>::end() -> iterator
 {
     return begin() + length();
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-void Zbase<Char, SP, AP>::clear()
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::clear()
 {
     if (!empty())
     {
-        if (this->canWrite(rawStr, 0))
+        if (this->canWrite(rawStr_, 0))
         {
-            rawStr[0] = 0;              //keep allocated memory
-            this->setLength(rawStr, 0); //
+            rawStr_[0] = 0;              //keep allocated memory
+            this->setLength(rawStr_, 0); //
         }
         else
             *this = Zbase();
@@ -584,111 +545,70 @@ void Zbase<Char, SP, AP>::clear()
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-void Zbase<Char, SP, AP>::swap(Zbase<Char, SP, AP>& other)
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::reserve(size_t minCapacity) //make unshared and check capacity
 {
-    std::swap(rawStr, other.rawStr);
-}
-
-
-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 (!this->canWrite(rawStr, minCapacity))
+    if (!this->canWrite(rawStr_, minCapacity))
     {
         //allocate a new string
         const size_t len = length();
         Char* newStr = this->create(len, std::max(len, minCapacity)); //reserve() must NEVER shrink the string: logical const!
-        std::copy(rawStr, rawStr + len + 1, newStr); //include 0-termination
+        std::copy(rawStr_, rawStr_ + len + 1, newStr); //include 0-termination
 
-        this->destroy(rawStr);
-        rawStr = newStr;
+        this->destroy(rawStr_);
+        rawStr_ = newStr;
     }
 }
 
 
-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)
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>& Zbase<Char, SP>::assign(InputIterator first, InputIterator last)
 {
-    if (this->canWrite(rawStr, len))
+    const size_t len = std::distance(first, last);
+    if (this->canWrite(rawStr_, len))
     {
-        std::copy(source, source + len, rawStr);
-        rawStr[len] = 0; //include null-termination
-        this->setLength(rawStr, len);
+        *std::copy(first, last, rawStr_) = 0;
+        this->setLength(rawStr_, len);
     }
     else
-        *this = Zbase(source, len);
+        *this = Zbase(first, last);
 
     return *this;
 }
 
 
-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)
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>& Zbase<Char, SP>::append(InputIterator first, InputIterator last)
 {
+    const size_t len = std::distance(first, last);
     const size_t thisLen = length();
     reserve(thisLen + len); //make unshared and check capacity
 
-    std::copy(source, source + len, rawStr + thisLen);
-    rawStr[thisLen + len] = 0;
-    this->setLength(rawStr, thisLen + len);
+    *std::copy(first, last, rawStr_ + thisLen) = 0;
+    this->setLength(rawStr_, thisLen + len);
     return *this;
 }
 
 
-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)
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>& Zbase<Char, SP>::operator=(const Zbase<Char, SP>& str)
 {
-    Zbase<Char, SP, AP>(other).swap(*this);
+    Zbase<Char, SP>(str).swap(*this);
     return *this;
 }
 
 
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator=(Zbase<Char, SP, AP>&& tmp) noexcept
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>& Zbase<Char, SP>::operator=(Zbase<Char, SP>&& tmp) noexcept
 {
     swap(tmp); //don't use unifying assignment but save one move-construction in the r-value case instead!
     return *this;
 }
 
-
-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, strLength(source));
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator=(Char ch)
-{
-    return assign(&ch, 1);
-}
-
-
-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)
-{
-    return append(other.c_str(), other.length());
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator+=(const Char* other)
-{
-    return append(other, strLength(other));
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-Zbase<Char, SP, AP>& Zbase<Char, SP, AP>::operator+=(Char ch)
-{
-    return append(&ch, 1);
-}
-
-
-template <class Char, template <class, class> class SP, class AP> inline
-void Zbase<Char, SP, AP>::pop_back()
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::pop_back()
 {
     const size_t len = length();
     assert(len > 0);