BasicString.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include <string>
#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: // typedefs
    typedef Alloc                                                               Allocator; 
    typedef C                                                                   CharType; 
    typedef BasicString<CharType, Allocator>                                    SelfType; 
    typedef std::basic_string<CharType, std::char_traits<CharType>, Allocator>  BaseString; 

public: // policy typedefs
    typedef Allocator                                                           allocator_type; 
    typedef CharType                                                            value_type; 
    typedef typename BaseString::size_type                                      size_type; 
    typedef typename BaseString::difference_type                                difference_type; 
    typedef typename BaseString::reference                                      reference; 
    typedef typename BaseString::const_reference                                const_reference; 
    typedef typename Allocator::pointer                                         pointer; 
    typedef typename Allocator::const_pointer                                   const_pointer; 
    typedef typename BaseString::iterator                                       iterator; 
    typedef typename BaseString::const_iterator                                 const_iterator; 
    typedef typename BaseString::reverse_iterator                               reverse_iterator; 
    typedef typename BaseString::const_reverse_iterator                         const_reverse_iterator; 

private: // usings
    using BasicFormatterType = BasicFormatter<CharType, Allocator>;

public: // construction/destruction
    BasicString()
        : baseString()
    {
    }

    BasicString(const SelfType& arg)
        : baseString(arg.baseString)
    {
    }

    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)
        : baseString(arg.baseString)
    {
    }

    BasicString(SelfType&& arg, const Allocator& alloc)
        : baseString(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)
    {
    }

    BasicString(const BaseString& arg)
        : baseString(arg)
    {
    }

    BasicString(BaseString&& arg)
        : baseString(arg)
    {
    }

    ~BasicString()
    {
    }

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)
    {
        this->baseString = right.baseString;
        return (*this);
    }

    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: // 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 = 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(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;
    }

    ARP_DEPRECATED("Do not use this operation, is is not part of the C++ standard and will be removed in future.")
    iterator Insert(const_iterator where)
    {
        return this->baseString.insert(where);
    }

    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 offset = NPos) const
    {
        return this->baseString.find_last_of(chars.baseString, offset);
    }

    size_type FindLastOf(const CharType* pChars, size_type offset, size_type count) const
    {
        return this->baseString.find_last_of(pChars, offset, count);
    }

    size_type FindLastOf(const CharType* pChars, size_type offset = NPos) const
    {
        return this->baseString.find_last_of(pChars, offset);
    }

    size_type FindLastOf(CharType c, size_type offset = NPos) const
    {
        return this->baseString.find_last_of(c, offset);
    }

    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 offset = NPos) const
    {
        return this->baseString.find_last_not_of(chars.baseString, offset);
    }

    size_type FindLastNotOf(const CharType *pChars, size_type offset, size_type count) const
    {
        return this->baseString.find_last_not_of(pChars, offset, count);
    }

    size_type FindLastNotOf(const CharType *pChars, size_type offset = NPos) const
    {
        return this->baseString.find_last_not_of(pChars, offset);
    }

    size_type FindLastNotOf(CharType c, size_type offset = NPos) const
    {
        return this->baseString.find_last_not_of(c, offset);
    }

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;
    }

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
    const BaseString& GetBaseString()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);
    }

    // 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)
{
    left.swap(right);
}

template<class CharType, class Alloc>
inline std::ostream& operator<<(std::ostream& os, const BasicString<CharType, Alloc>& right)
{
    os << right.GetBaseString();
    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.GetBaseString() + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType left,
    const BasicString<CharType, Alloc>& right)
{
    return left + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetBaseString() + right;
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    const CharType right)
{
    return left.GetBaseString() + right;
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const BasicString<CharType, Alloc>& left,
    BasicString<CharType, Alloc>&& right)
{
    return left.GetBaseString() + right.GetBaseString();
}

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.GetBaseString() + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType* left,
    BasicString<CharType, Alloc>&& right)
{
    return left + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    const CharType left,
    BasicString<CharType, Alloc>&& right)
{
    return left + right.GetBaseString();
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    const CharType* right)
{
    return left.GetBaseString() + right;
}

template<class CharType, class Alloc>
inline BasicString<CharType, Alloc> operator+(
    BasicString<CharType, Alloc>&& left,
    const CharType right)
{
    return left.GetBaseString() + right;
}

template<class CharType, class Alloc>
inline bool operator==(
    const BasicString<CharType, Alloc>& left,
    const BasicString<CharType, Alloc>& right)
{
    return left.GetBaseString() == right.GetBaseString();
}

template<class CharType, class Alloc>
inline bool operator==(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left == right.GetBaseString();
}

template<class CharType, class Alloc>
inline bool operator==(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetBaseString() == 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.GetBaseString() < right.GetBaseString();
}

template<class CharType, class Alloc>
inline bool operator<(
    const CharType* left,
    const BasicString<CharType, Alloc>& right)
{
    return left < right.GetBaseString();
}

template<class CharType, class Alloc>
inline bool operator<(
    const BasicString<CharType, Alloc>& left,
    const CharType* right)
{
    return left.GetBaseString() < 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.GetBaseString());
    }
};


} // end of namespace std