BasicString.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include <string>
#include <vector>
#include <algorithm>
#include <memory>
#include <iostream>
#include <initializer_list>
#include "boost/algorithm/string/replace.hpp"
#include "Arp/System/Core/BasicFormatter.hxx"
#include "Arp/System/Core/Impl/BasicStringFormatExceptionHandler.hpp"
 
#ifndef ARP_INSIDE_ARP_H
    #error Never include 'BasicString.hxx' directly, just include 'Arp.h'
#endif
 
namespace Arp
{
 
using Arp::System::Core::Impl::BasicStringFormatExceptionHandler;
 
 
template<class C, class Alloc = std::allocator<C>>
class BasicString
{
public: // usings
    using Allocator         = Alloc;                                                                
    using AllocatorTraits   = std::allocator_traits<Alloc>;
    using CharType          = C;                                                                    
    using SelfType          = BasicString<CharType, Allocator>;                                     
    using BaseString        = std::basic_string<CharType, std::char_traits<CharType>, Allocator>;   
    using StdString         = std::basic_string<CharType, std::char_traits<CharType>, Allocator>;   
    using Tokens            = std::vector<SelfType>;                                                
    using Bytes             = std::vector<byte>;                                                    
 
public: // policy typedefs
    using allocator_type            = Allocator;                                    
    using value_type                = CharType;                                     
    using size_type                 = typename BaseString::size_type;               
    using difference_type           = typename BaseString::difference_type;         
    using reference                 = typename BaseString::reference;               
    using const_reference           = typename BaseString::const_reference;         
    using pointer                   = typename AllocatorTraits::pointer;            
    using const_pointer             = typename AllocatorTraits::const_pointer;      
    using iterator                  = typename BaseString::iterator;                
    using const_iterator            = typename BaseString::const_iterator;          
    using reverse_iterator          = typename BaseString::reverse_iterator;        
    using const_reverse_iterator    = typename BaseString::const_reverse_iterator;  
 
private: // usings
    using BasicFormatterType = BasicFormatter<CharType, Allocator>;
 
public: // construction/destruction
    BasicString() = default;
 
    BasicString(const SelfType& arg) = default;
 
    BasicString(const SelfType& arg, const Allocator& alloc)
        : baseString(arg.baseString, alloc)
    {
    }
 
    explicit BasicString(const Allocator& alloc)
        : baseString(alloc)
    {
    }
 
    BasicString(const SelfType& arg, size_type offset, size_type count = NPos)
        : baseString(arg.baseString, offset, count)
    {
    }
 
    BasicString(const SelfType& arg, size_type offset, size_type count, const Allocator& alloc)
        : baseString(arg.baseString, offset, count, alloc)
    {
    }
 
    BasicString(const CharType* pChars, size_type count)
        : baseString(pChars, count)
    {
    }
 
    BasicString(const CharType* pChars, size_type count, const Allocator& alloc)
        : baseString(pChars, count, alloc)
    {
    }
 
    BasicString(const CharType* pChars)
        : baseString(pChars)
    {
    }
 
    BasicString(const CharType* pChars, const Allocator& alloc)
        : baseString(pChars, alloc)
    {
    }
 
    BasicString(size_type count, CharType c)
        : baseString(count, c)
    {
    }
 
    BasicString(size_type count, CharType c, const Allocator& alloc)
        : baseString(count, c, alloc)
    {
    }
 
    BasicString(SelfType&& arg) noexcept = default;
 
    BasicString(SelfType&& arg, const Allocator& alloc)
        : baseString(std::move(arg.baseString), alloc)
    {
    }
 
    BasicString(std::initializer_list<CharType> arg, const Allocator& alloc = Allocator())
        : baseString(arg, alloc)
    {
    }
 
    BasicString(iterator first, iterator last, const Allocator& alloc = Allocator())
        : baseString(first, last, alloc)
    {
    }
 
    BasicString(const_iterator first, const_iterator last, const Allocator& alloc = Allocator())
        : baseString(first, last, alloc)
    {
    }
 
    explicit BasicString(const Bytes& bytes, const Allocator& alloc = Allocator())
        : baseString(reinterpret_cast<const char*>(bytes.data()), reinterpret_cast<const char*>(bytes.data() + bytes.size()), alloc)
    {
    }
 
    BasicString(const BaseString& arg)
        : baseString(arg)
    {
    }
 
    BasicString(BaseString&& arg)
        : baseString(std::move(arg))
    {
    }
 
    ~BasicString() = default;
 
public: // static fields
    static const size_type  NPos = size_type(-1);
    static const SelfType   Empty;
    static const SelfType   NewLine;
 
public: // assignment operator
    SelfType& operator=(SelfType&& right) noexcept = default;
 
    SelfType& operator=(std::initializer_list<CharType> right)
    {
        this->baseString = right;
        return (*this);
    }
 
    SelfType& operator=(const SelfType& right) = default;
 
    SelfType& operator=(const CharType* right)
    {
        this->baseString = right;
        return (*this);
    }
 
    SelfType& operator=(CharType c)
    {
        this->baseString = c;
        return (*this);
    }
 
public: // append operator
    SelfType& operator+=(std::initializer_list<CharType> right)
    {
        this->baseString += right;
        return (*this);
    }
 
    SelfType& operator+=(const SelfType& right)
    {
        this->baseString += right.baseString;
        return (*this);
    }
 
    SelfType& operator+=(const CharType* right)
    {
        this->baseString += right;
        return (*this);
    }
 
    SelfType& operator+=(CharType c)
    {
        this->baseString += c;
        return (*this);
    }
 
public: // assign operations
 
    SelfType& Assign(SelfType&& arg)
    {
        this->baseString = std::move(arg.baseString);
        return *this;
    }
 
    SelfType& Assign(std::initializer_list<CharType> arg)
    {
        this->baseString.assign(arg);
        return *this;
    }
 
    SelfType& Assign(const SelfType& arg)
    {
        this->baseString.assign(arg.baseString);
        return *this;
    }
 
    SelfType& Assign(const SelfType& arg, size_type offset, size_type count = NPos)
    {
        this->baseString.assign(arg.baseString, offset, count);
        return *this;
    }
 
    SelfType& Assign(const BaseString& arg)
    {
        this->baseString.assign(arg);
        return *this;
    }
 
    SelfType& Assign(BaseString&& arg)
    {
        this->baseString.assign(std::move(arg));
        return *this;
    }
 
    SelfType& Assign(const CharType* pChars, size_type count)
    {
        this->baseString.assign(pChars, count);
        return *this;
    }
 
    SelfType& Assign(const CharType* pChars)
    {
        this->baseString.assign(pChars);
        return *this;
    }
 
    SelfType& Assign(size_type count, CharType c)
    {
        this->baseString.assign(count, c);
        return *this;
    }
 
    SelfType& Assign(iterator first, iterator last)
    {
        this->baseString.assign(first, last);
        return *this;
    }
 
    SelfType& Assign(const_iterator first, const_iterator last)
    {
        this->baseString.assign(first, last);
        return *this;
    }
 
    SelfType& Assign(const_pointer first, const_pointer last)
    {
        this->baseString.assign(first, last);
        return *this;
    }
 
public: // append operations
 
    SelfType& Append(std::initializer_list<CharType> arg)
    {
        this->baseString.append(arg);
        return *this;
    }
 
    SelfType& Append(const SelfType& arg)
    {
        this->baseString.append(arg.baseString);
        return *this;
    }
 
    SelfType& Append(const SelfType& arg, size_type offset, size_type count = NPos)
    {
        this->baseString.append(arg.baseString, offset, count);
        return *this;
    }
 
    SelfType& Append(const CharType* pChars, size_type count)
    {
        this->baseString.append(pChars, count);
        return *this;
    }
 
    SelfType& Append(const CharType* pChars)
    {
        this->baseString.append(pChars);
        return *this;
    }
 
    SelfType& Append(size_type count, CharType c)
    {
        this->baseString.append(count, c);
        return *this;
    }
 
    SelfType& Append(iterator first, iterator last)
    {
        this->baseString.append(first, last);
        return *this;
    }
 
    SelfType& Append(const_iterator first, const_iterator last)
    {
        this->baseString.append(first, last);
        return *this;
    }
 
    SelfType& Append(const_pointer first, const_pointer last)
    {
        this->baseString.append(first, last);
        return *this;
    }
 
public: // insert operations
 
    iterator Insert(const_iterator where, std::initializer_list<CharType> arg)
    {
        return this->baseString.insert(where, arg);
    }
 
    SelfType& Insert(size_type offset, const SelfType& arg)
    {
        this->baseString.insert(offset, arg.baseString);
        return *this;
    }
 
    SelfType& Insert(size_type offset, const SelfType& arg, size_type argOffset, size_type count = NPos)
    {
        this->baseString.insert(offset, arg.baseString, argOffset, count);
        return *this;
    }
 
    SelfType& Insert(size_type offset, const CharType* pChars, size_type count)
    {
        this->baseString.insert(offset, pChars, count);
        return *this;
    }
 
    SelfType& Insert(size_type offset, const CharType* pChars)
    {
        this->baseString.insert(offset, pChars);
        return *this;
    }
 
    SelfType& Insert(size_type offset, size_type count, CharType c)
    {
        this->baseString.insert(offset, count, c);
        return *this;
    }
 
    iterator Insert(const_iterator where, CharType c)
    {
        return this->baseString.insert(where, c);
    }
 
    iterator Insert(const_iterator where, size_type count, CharType c)
    {
        return this->baseString.insert(where, count, c);
    }
 
    iterator Insert(const_iterator where, iterator first, iterator last)
    {
        return this->baseString.insert(where, first, last);
    }
 
    iterator Insert(const_iterator where, const_iterator first, const_iterator last)
    {
        return this->baseString.insert(where, first, last);
    }
 
    iterator Insert(const_iterator where, const_pointer first, const_pointer last)
    {
        return this->baseString.insert(where, first, last);
    }
 
public: // erase operations
 
    SelfType& Erase(size_type offset = 0)
    {
        this->baseString.erase(offset);
        return (*this);
    }
 
    SelfType& Erase(size_type offset, size_type count)
    {
        this->baseString.erase(offset, count);
        return (*this);
    }
 
    iterator Erase(const_iterator where)
    {
        return this->baseString.erase(where);
    }
 
    iterator Erase(const_iterator first, const_iterator last)
    {
        return this->baseString.erase(first, last);
    }
 
public: // replace operation
 
    SelfType& Replace(const_iterator first, const_iterator last, std::initializer_list<CharType> chars)
    {
        this->baseString.replace(first, last, chars);
        return *this;
    }
 
    SelfType& Replace(size_type offset, size_type length, const SelfType& arg)
    {
        this->baseString.replace(offset, length, arg.baseString);
        return (*this);
    }
 
    SelfType& Replace(size_type offset, size_type length, const SelfType& arg, size_type offsetArg, size_type count = NPos)
    {
        this->baseString.replace(offset, length, arg.baseString, offsetArg, count);
        return (*this);
    }
 
    SelfType& Replace(size_type offset, size_type length, const CharType* pChars, size_type count)
    {
        this->baseString.replace(offset, length, pChars, offset, count);
        return (*this);
    }
 
    SelfType& Replace(size_type offset, size_type length, const CharType* pChars)
    {
        this->baseString.replace(offset, length, pChars);
        return (*this);
    }
 
    SelfType& Replace(size_type offset, size_type length, size_type count, CharType c)
    {
        this->baseString.replace(offset, length, count, c);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, const SelfType& arg)
    {
        this->baseString.replace(first, last, arg.baseString);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, const CharType* pChars, size_type count)
    {
        this->baseString.replace(first, last, pChars, count);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, const CharType* pChars)
    {
        this->baseString.replace(first, last, pChars);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, size_type count, CharType c)
    {
        this->baseString.replace(first, last, count, c);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, iterator first2, iterator last2)
    {
        this->baseString.replace(first, last, first2, last2);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, const_iterator first2, const_iterator last2)
    {
        this->baseString.replace(first, last, first2, last2);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, const_pointer first2, const_pointer last2)
    {
        this->baseString.replace(first, last, first2, last2);
        return (*this);
    }
 
    SelfType& Replace(const_iterator first, const_iterator last, pointer first2, pointer last2)
    {
        this->baseString.replace(first, last, first2, last2);
        return (*this);
    }
 
public: // replace_all operations
 
    SelfType& ReplaceAll(const SelfType& pattern, const SelfType& replacement)
    {
        boost::replace_all(this->baseString, pattern.baseString, replacement.baseString);
        return (*this);
    }
 
public: // support of range based for loops
 
    iterator begin()
    {
        return this->baseString.begin();
    }
 
    const_iterator begin() const
    {
        return this->baseString.begin();
    }
 
    iterator end()
    {
        return this->baseString.end();
    }
 
    const_iterator end() const
    {
        return this->baseString.end();
    }
 
public: // container operations
 
    iterator Begin()
    {
        return this->baseString.begin();
    }
 
    const_iterator Begin() const
    {
        return this->baseString.begin();
    }
 
    iterator End()
    {
        return this->baseString.end();
    }
 
    const_iterator End() const
    {
        return this->baseString.end();
    }
 
    reverse_iterator ReverseBegin()
    {
        return this->baseString.rbegin();
    }
 
    const_reverse_iterator ReverseBegin() const
    {
        return this->baseString.rbegin();
    }
 
    reverse_iterator ReverseEnd()
    {
        return this->baseString.rend();
    }
 
    const_reverse_iterator ReverseEnd() const
    {
        return this->baseString.rend();
    }
 
    const_iterator ConstBegin() const
    {
        return this->baseString.cbegin();
    }
 
    const_iterator ConstEnd() const
    {
        return this->baseString.cend();
    }
 
    const_reverse_iterator ConstReverseBegin() const
    {
        return this->baseString.crbegin();
    }
 
    const_reverse_iterator ConstReverseEnd() const
    {
        return this->baseString.crend();
    }
 
    void ShrinkToFit()
    {
        this->baseString.shrink_to_fit();
    }
 
    void PushBack(CharType c)
    {
        this->baseString.push_back(c);
    }
 
    void PopBack()
    {
        if(!this->IsEmpty())
        {
            this->baseString.pop_back();
        }
    }
 
    reference Front()
    {
        return this->baseString.front();
    }
 
    const_reference Front() const
    {
        return this->baseString.front();
    }
 
    reference Back()
    {
        return this->baseString.back();
    }
 
    const_reference Back() const
    {
        return this->baseString.back();
    }
 
    reference At(size_type offset)
    {
        return this->baseString.at(offset);
    }
 
    const_reference At(size_type offset) const
    {
        return this->baseString.at(offset);
    }
 
    reference operator[](size_type offset)
    {
        return this->baseString[offset];
    }
 
    const_reference operator[](size_type offset) const
    {
        return this->baseString[offset];
    }
 
public: // Size/Length operations
 
    size_type Length() const
    {
        return this->baseString.length();
    }
 
    size_type Size() const
    {
        return this->baseString.size();
    }
 
    size_type MaxSize() const
    {
        return this->baseString.max_size();
    }
 
    size_type Capacity() const
    {
        return this->baseString.capacity();
    }
 
    bool IsEmpty() const
    {
        return this->baseString.empty();
    }
 
    void Resize(size_type newSize)
    {
        this->baseString.resize(newSize);
    }
 
    void Resize(size_type newSize, CharType c)
    {
        this->baseString.resize(newSize, c);
    }
 
    void Reserve(size_type newCapacity = 0)
    {
        this->baseString.reserve(newCapacity);
    }
 
    void Clear()
    {
        this->baseString.clear();
    }
 
public: // Find operations
 
    size_type Find(const SelfType& pattern, size_type offset = 0) const
    {
        return this->baseString.find(pattern.baseString, offset);
    }
 
    size_type Find(const CharType* pChars, size_type offset, size_type count) const
    {
        return this->baseString.find(pChars, offset, count);
    }
 
    size_type Find(const CharType* pChars, size_type offset = 0) const
    {
        return this->baseString.find(pChars, offset);
    }
 
    size_type Find(CharType c, size_type offset = 0) const
    {
        return this->baseString.find(c, offset);
    }
 
    size_type ReverseFind(const SelfType& pattern, size_type offset = NPos) const
    {
        return this->baseString.rfind(pattern.baseString, offset);
    }
 
    size_type ReverseFind(const CharType* pChars, size_type offset, size_type count) const
    {
        return this->baseString.rfind(pChars, offset, count);
    }
 
    size_type ReverseFind(const CharType* pChars, size_type offset = NPos) const
    {
        return this->baseString.rfind(pChars, offset);
    }
 
    size_type ReverseFind(CharType c, size_type offset = NPos) const
    {
        return this->baseString.rfind(c, offset);
    }
 
    size_type FindFirstOf(const SelfType& chars, size_type offset = 0) const
    {
        return this->baseString.find_first_of(chars.baseString, offset);
    }
 
    size_type FindFirstOf(const CharType* pChars, size_type offset, size_type count) const
    {
        return this->baseString.find_first_of(pChars, offset, count);
    }
 
    size_type FindFirstOf(const CharType* pChars, size_type offset = 0) const
    {
        return this->baseString.find_first_of(pChars, offset);
    }
 
    size_type FindFirstOf(CharType c, size_type offset = 0) const
    {
        return this->baseString.find_first_of(c, offset);
    }
 
    size_type FindLastOf(const SelfType& chars, size_type pos = NPos) const
    {
        return this->baseString.find_last_of(chars.baseString, pos);
    }
 
    size_type FindLastOf(const CharType* pChars, size_type pos, size_type count) const
    {
        return this->baseString.find_last_of(pChars, pos, count);
    }
 
    size_type FindLastOf(const CharType* pChars, size_type pos = NPos) const
    {
        return this->baseString.find_last_of(pChars, pos);
    }
 
    size_type FindLastOf(CharType c, size_type pos = NPos) const
    {
        return this->baseString.find_last_of(c, pos);
    }
 
    size_type FindFirstNotOf(const SelfType& chars, size_type offset = 0) const
    {
        return this->baseString.find_first_not_of(chars.baseString, offset);
    }
 
    size_type FindFirstNotOf(const CharType* pChars, size_type offset, size_type count) const
    {
        return this->baseString.find_first_not_of(pChars, offset, count);
    }
 
    size_type FindFirstNotOf(const CharType *pChars, size_type offset = 0) const
    {
        return this->baseString.find_first_not_of(pChars, offset);
    }
 
    size_type FindFirstNotOf(CharType c, size_type offset = 0) const
    {
        return this->baseString.find_first_not_of(c, offset);
    }
 
    size_type FindLastNotOf(const SelfType& chars, size_type pos = NPos) const
    {
        return this->baseString.find_last_not_of(chars.baseString, pos);
    }
 
    size_type FindLastNotOf(const CharType *pChars, size_type pos, size_type count) const
    {
        return this->baseString.find_last_not_of(pChars, pos, count);
    }
 
    size_type FindLastNotOf(const CharType *pChars, size_type pos = NPos) const
    {
        return this->baseString.find_last_not_of(pChars, pos);
    }
 
    size_type FindLastNotOf(CharType c, size_type pos = NPos) const
    {
        return this->baseString.find_last_not_of(c, pos);
    }
 
public: // Compare operations
 
    int Compare(const SelfType& other) const
    {
        return this->baseString.compare(other.baseString);
    }
 
    int Compare(size_type offset, size_type count, const SelfType& other) const
    {
        return this->baseString.compare(offset, count, other.baseString);
    }
 
    int Compare(size_type offset, size_type count, const SelfType& other, size_type offsetOther, size_type countOther = NPos) const
    {
        return this->baseString.compare(offset, count, other.baseString, offsetOther, countOther);
    }
 
    int Compare(const CharType *pOther) const
    {
        return this->baseString.compare(pOther);
    }
 
    int Compare(size_type offset, size_type count, const CharType *pOther) const
    {
        return this->baseString.compare(offset, count, pOther);
    }
 
    int Compare(size_type offset, size_type count, const CharType *pOther, size_type countOther) const
    {
        return this->baseString.compare(offset, count, pOther, countOther);
    }
 
public: // misc operations (none std)
 
    bool StartWith(const CharType *pChars)const
    {
        return this->Find(pChars) == 0;
    }
 
    bool StartWith(const SelfType& pattern)const
    {
        return this->Find(pattern) == 0;
    }
 
    bool EndWith(const CharType* pChars)const
    {
        return this->EndWith(SelfType(pChars));
    }
 
    bool EndWith(const SelfType& pattern)const
    {
        size_t thisLength = this->baseString.length();
        size_t patternLength = pattern.baseString.length();
 
        if (thisLength < patternLength)
        {
            return false;
        }
        // else
        return (this->baseString.compare(thisLength - patternLength, patternLength, pattern.baseString) == 0);
    }
 
public: // Format operations
    template<typename... Args>
    static SelfType Format(const SelfType& format, const Args& ... args)
    {
        return Format(format.CStr(), args...);
    }
 
    template<typename... Args>
    static SelfType Format(const char* format, const Args& ... args)
    {
        return BasicFormatterType::FormatCommon(&BasicStringFormatExceptionHandler::Invoke, format, args...);
    }
 
public: // Misc operations
    ARP_DEPRECATED("Use GetStdString() instead.")
    const BaseString& GetBaseString()const
    {
        return this->baseString;
    }
 
    const StdString& GetStdString()const
    {
        return this->baseString;
    }
 
    const CharType* CStr() const
    {
        return this->baseString.c_str();
    }
 
    operator const CharType*() const
    {
        return this->baseString.data();
    }
 
    operator const BaseString& () const
    {
        return this->baseString;
    }
 
    SelfType Substr(size_type offset = 0, size_type count = NPos) const
    {
        return SelfType(this->baseString.substr(offset, count));
    }
 
    Allocator GetAllocator() const
    {
        return this->baseString.get_allocator();
    }
 
    void Swap(SelfType& other)
    {
        this->baseString.swap(other.baseString);
    }
 
    Bytes ToBytes()const
    {
        return Bytes(reinterpret_cast<const byte*>(this->CStr()), reinterpret_cast<const byte*>(this->CStr() + this->Size()));
    }
 
    SelfType TrimLeft()const
    {
        auto left = std::find_if(this->baseString.begin(), this->baseString.end(), [](char c)
        {
            return !std::isspace<char>(c, std::locale::classic());
        });
        return SelfType(left, this->baseString.end());
    }
 
    SelfType TrimRight()const
    {
        auto right = std::find_if(this->baseString.rbegin(), this->baseString.rend(), [](char c)
        {
            return !std::isspace<char>(c, std::locale::classic());
        });
        return SelfType(this->baseString.begin(), right.base());
    }
 
    SelfType Trim()const
    {
        auto left = std::find_if(this->baseString.begin(), this->baseString.end(), [](char c)
        {
            return !std::isspace<char>(c, std::locale::classic());
        });
 
        // check if string only consists of whitespaces
        if (left == this->baseString.end())
        {
            return Empty;
        }
 
        auto right = std::find_if(this->baseString.rbegin(), this->baseString.rend(), [](char c)
        {
            return !std::isspace<char>(c, std::locale::classic());
        });
        return SelfType(left, right.base());
    }
 
    Tokens Split(char delimiter, bool trimTokens = true, bool removeEmptyTokens = true)const
    {
        char delimiters[] = { delimiter };
        return this->Split(delimiters, 1, trimTokens, removeEmptyTokens);
    }
 
    Tokens Split(const char delimiters[], size_t delimitersCount, bool trimTokens = true, bool removeEmptyTokens = true)const
    {
        Tokens tokens;
 
        size_t last = 0;
        size_t length = this->Length();
 
        for (size_t first = 0; first < length; first = last + 1)
        {
            size_t position = this->FindFirstOf(delimiters, first, delimitersCount);
            last = (position != NPos) ? position : this->Length();
 
            SelfType token = this->Substr(first, last - first);
            if (trimTokens)
            {
                token = token.Trim();
            }
            if (!removeEmptyTokens || !token.IsEmpty())
            {
                tokens.push_back(token);
            }
        }
 
        if (!removeEmptyTokens && (this->FindLastOf(delimiters, NPos, delimitersCount) == (length - 1)))
        {
            tokens.push_back(Empty);
        }
 
        return tokens;
    }
 
    Tokens SplitByWord(const SelfType& delimiter, bool trimTokens = true, bool removeEmptyTokens = true)const
    {
        Tokens tokens;
 
        size_t last = 0;
        size_t length = this->Length();
        size_t delimiterLength = delimiter.Length();
 
        for (size_t first = 0; first < length; first = last + delimiterLength)
        {
            size_t position = this->Find(delimiter, first);
            last = (position != NPos) ? position : length;
 
            SelfType token = this->Substr(first, last - first);
            if (trimTokens)
            {
                token = token.Trim();
            }
            if (!token.IsEmpty() || !removeEmptyTokens)
            {
                tokens.push_back(token);
            }
        }
 
        if (!removeEmptyTokens && this->EndWith(delimiter))
        {
            tokens.push_back(Empty);
        }
 
        return tokens;
    }
 
    // warning 4996 occurs, to avoid use _SCL_SECURE_NO_WARNINGS
    //size_type Copy(CharType* pChars, size_type count, size_type offset = 0) const
    //{
    //    return this->baseString.copy(pChars, count, offset);
    //}
 
private: // fields
    BaseString  baseString;
};
 
// initializing of static fields
template <class CharType, class Alloc>
const BasicString<CharType, Alloc> BasicString<CharType, Alloc>::Empty;
 
template <class CharType, class Alloc>
const BasicString<CharType, Alloc> BasicString<CharType, Alloc>::NewLine((CharType)'\n', (CharType)'\r');
 
// inline global operators and functions of class BasicString<CharType, Alloc>
 
template<class CharType, class Alloc>
inline void swap(BasicString<CharType, Alloc>& left, BasicString<CharType, Alloc>& right)noexcept
{
    left.Swap(right);
}
 
template<class CharType, class Alloc>
inline std::ostream& operator<<(std::ostream& os, const BasicString<CharType, Alloc>& right)
{
    os << right.GetStdString();
    return os;
}
 
template<class CharType, class Alloc>
inline std::istream& operator>>(std::istream& is, BasicString<CharType, Alloc>& right)
{
    std::basic_string<CharType, std::char_traits<CharType>, Alloc> baseString;
    is >> baseString;
    right.Assign(baseString);
    return is;
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return left.GetStdString() + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType left,
    const BasicString<CharType, Alloc>& right)
{
    return left + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetStdString() + right;
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    const CharType right)
{
    return left.GetStdString() + right;
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    BasicString<CharType, Alloc>&& right)
{
    return left.GetStdString() + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    const BasicString<CharType, Alloc>& right)
{
    return (std::move(left.Append(right)));
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    BasicString<CharType, Alloc>&& right)
{
    return left.GetStdString() + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType* left,
    BasicString<CharType, Alloc>&& right)
{
    return left + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType left,
    BasicString<CharType, Alloc>&& right)
{
    return left + right.GetStdString();
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    const CharType* right)
{
    return left.GetStdString() + right;
}
 
template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    const CharType right)
{
    return left.GetStdString() + right;
}
 
template<class CharType, class Alloc>
inline bool operator==(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return left.GetStdString() == right.GetStdString();
}
 
template<class CharType, class Alloc>
inline bool operator==(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left == right.GetStdString();
}
 
template<class CharType, class Alloc>
inline bool operator==(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetStdString() == right;
}
 
template<class CharType, class Alloc>
inline bool operator!=(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(left == right));
}
 
template<class CharType, class Alloc>
inline bool operator!=(
    const CharType *left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(left == right));
}
 
template<class CharType, class Alloc>
inline bool operator!=(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return (!(left == right));
}
 
template<class CharType, class Alloc>
inline bool operator<(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return left.GetStdString() < right.GetStdString();
}
 
template<class CharType, class Alloc>
inline bool operator<(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left < right.GetStdString();
}
 
template<class CharType, class Alloc>
inline bool operator<(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetStdString() < right;
}
 
template<class CharType, class Alloc>
inline bool operator>(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return (right < left);
}
 
template<class CharType, class Alloc>
inline bool operator>(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return (right < left);
}
 
template<class CharType, class Alloc>
inline bool operator>(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return (right < left);
}
 
template<class CharType, class Alloc>
inline bool operator<=(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(right < left));
}
 
template<class CharType, class Alloc>
inline bool operator<=(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(right < left));
}
 
template<class CharType, class Alloc>
inline bool operator<=(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return (!(right < left));
}
 
template<class CharType, class Alloc>
inline bool operator>=(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(left < right));
}
 
template<class CharType, class Alloc>
inline bool operator>=(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return (!(left < right));
}
 
template<class CharType, class Alloc>
inline bool operator>=(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return (!(left < right));
}
 
} // end of namesapce Arp
 
// standard template specializations of class BasicString<C,Alloc>
namespace std
{
 
template<class C, class Alloc>
struct hash<Arp::BasicString<C, Alloc>>
{
private:
    typedef typename Arp::BasicString<C, Alloc>::BaseString    BaseString;
 
public:
    typedef Arp::BasicString<C, Alloc>  argument_type;
    typedef size_t                      result_type;
 
public:
    result_type operator()(const argument_type& key) const
    {
        return std::hash<BaseString>()(key.GetStdString());
    }
};
 
 
} // end of namespace std