StaticString.h

Go to the documentation of this file.

//
// Copyright 2015 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/Assert.h"
#include "comms/CompileControl.h"
#include "comms/util/StaticVector.h"
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <string>
 
namespace comms
{
 
namespace util
{
 
namespace details
{
 
template <typename TChar>
class StaticStringBase
{
    using VecType = StaticVectorBase<TChar>;
    using CellType = typename VecType::CellType;
protected:
 
    static const auto npos = static_cast<std::size_t>(-1);
 
    StaticStringBase(TChar* buf, std::size_t cap)
      : m_vec(reinterpret_cast<CellType*>(buf), cap)
    {
        endString();
    }
 
    void assign(std::size_t count, TChar ch)
    {
        COMMS_ASSERT(count <= capacity());
        auto countLimit = std::min(count, capacity());
        m_vec.clear();
        std::fill_n(std::back_inserter(m_vec), countLimit, ch);
        endString();
    }
 
    void assign(const StaticStringBase& other)
    {
        assign(other, 0, other.size());
    }
 
    void assign(const StaticStringBase& other, std::size_t pos, std::size_t count)
    {
        COMMS_ASSERT(&other != this);
        auto updatedCount = std::min(other.size() - pos, count);
        auto countLimit = std::min(updatedCount, capacity());
        m_vec.clear();
        std::copy_n(other.cbegin() + pos, countLimit, std::back_inserter(m_vec));
        endString();
    }
 
    void assign(const TChar* str, std::size_t count)
    {
        m_vec.clear();
        auto countLimit = std::min(count, capacity());
        while ((m_vec.size() < countLimit) && (*str != Ends)) {
            m_vec.push_back(*str);
            ++str;
        }
        endString();
    }
 
    void assign(const TChar* str)
    {
        assign(str, capacity());
    }
 
    template <typename TIter>
    void assign(TIter first, TIter last)
    {
        m_vec.assign(first, last);
        endString();
    }
 
    TChar& at(std::size_t pos)
    {
        COMMS_ASSERT(pos < size());
        return operator[](pos);
    }
 
    const TChar& at(std::size_t pos) const
    {
        COMMS_ASSERT(pos < size());
        return operator[](pos);
    }
 
    TChar& operator[](std::size_t pos)
    {
        return m_vec[pos];
    }
 
    const TChar& operator[](std::size_t pos) const
    {
        return m_vec[pos];
    }
 
    TChar& front()
    {
        COMMS_ASSERT(!empty());
        return m_vec.front();
    }
 
    const TChar& front() const
    {
        COMMS_ASSERT(!empty());
        return m_vec.front();
    }
 
    TChar& back()
    {
        COMMS_ASSERT(!empty());
        return m_vec[size() - 1];
    }
 
    const TChar& back() const
    {
        COMMS_ASSERT(!empty());
        return m_vec[size() - 1];
    }
 
    const TChar* data() const
    {
        COMMS_ASSERT(!m_vec.empty());
        return m_vec.data();
    }
 
    TChar* begin()
    {
        return m_vec.begin();
    }
 
    const TChar* cbegin() const
    {
        return m_vec.cbegin();
    }
 
    TChar* end()
    {
        return begin() + size();
    }
 
    const TChar* cend() const
    {
        return cbegin() + size();
    }
 
    bool empty() const
    {
        return size() == 0;
    }
 
    std::size_t size() const
    {
        COMMS_ASSERT(!m_vec.empty());
        return m_vec.size() - 1;
    }
 
    std::size_t capacity() const
    {
        return m_vec.capacity() - 1;
    }
 
    void clear()
    {
        m_vec.clear();
        endString();
    }
 
    void insert(std::size_t idx, std::size_t count, TChar ch)
    {
        COMMS_ASSERT(idx <= size());
        m_vec.insert(m_vec.begin() + idx, count, ch);
    }
 
    void insert(std::size_t idx, const TChar* str)
    {
        COMMS_ASSERT(idx <= size());
        m_vec.insert(m_vec.begin() + idx, str, str + strlen(str));
    }
 
    void insert(std::size_t idx, const TChar* str, std::size_t count)
    {
        COMMS_ASSERT(idx <= size());
        auto endStr = str + count;
        m_vec.insert(m_vec.begin() + idx, str, endStr);
    }
 
    void insert(std::size_t idx, const StaticStringBase& other)
    {
        COMMS_ASSERT(idx <= size());
        m_vec.insert(m_vec.begin() + idx, other.cbegin(), other.cend());
    }
 
    void insert(std::size_t idx, const StaticStringBase& str, std::size_t str_idx, std::size_t count)
    {
        COMMS_ASSERT(idx <= size());
        COMMS_ASSERT(str_idx < str.size());
        auto begIter = str.cbegin() + str_idx;
        auto endIter = begIter + std::min((str.size() - str_idx), count);
        m_vec.insert(m_vec.begin() + idx, begIter, endIter);
    }
 
    TChar* insert(const TChar* pos, TChar ch)
    {
        return m_vec.insert(pos, ch);
    }
 
    TChar* insert(const TChar* pos, std::size_t count, TChar ch)
    {
        return m_vec.insert(pos, count, ch);
    }
 
    template <typename TIter>
    TChar* insert(const TChar* pos, TIter first, TIter last)
    {
        return m_vec.insert(pos, first, last);
    }
 
    void erase(std::size_t idx, std::size_t count)
    {
        COMMS_ASSERT(idx < size());
        auto begIter = begin() + idx;
        auto endIter = begIter + std::min(count, size() - idx);
        m_vec.erase(begIter, endIter);
        COMMS_ASSERT(!m_vec.empty()); // Must contain '\0'
    }
 
    TChar* erase(const TChar* pos)
    {
        return m_vec.erase(pos, pos + 1);
    }
 
    TChar* erase(const TChar* first, const TChar* last)
    {
        return m_vec.erase(first, last);
    }
 
    void push_back(TChar ch)
    {
        static constexpr bool The_string_is_full = false;
        static_cast<void>(The_string_is_full);
        COMMS_ASSERT((size() < capacity()) || The_string_is_full);
        m_vec.insert(end(), ch);
    }
 
    void pop_back()
    {
        static constexpr bool The_string_is_empty = false;
        static_cast<void>(The_string_is_empty);
        COMMS_ASSERT((!empty()) || The_string_is_empty);
        m_vec.erase(end() - 1, end());
    }
 
    int compare(
        std::size_t pos1,
        std::size_t count1,
        const StaticStringBase& other,
        std::size_t pos2,
        std::size_t count2) const
    {
        COMMS_ASSERT(pos1 <= size());
        COMMS_ASSERT(pos2 <= other.size());
        count1 = std::min(count1, size() - pos1);
        count2 = std::min(count2, other.size() - pos2);
        auto minCount = std::min(count1, count2);
        for (auto idx = 0U; idx < minCount; ++idx) {
            auto thisCh = (*this)[pos1 + idx];
            auto otherCh = other[pos2 + idx];
            auto diff = static_cast<int>(thisCh) - static_cast<int>(otherCh);
            if (diff != 0) {
                return diff;
            }
        }
 
        return static_cast<int>(count1) - static_cast<int>(count2);
    }
 
    int compare(std::size_t pos, std::size_t count, const TChar* str) const
    {
        COMMS_ASSERT(pos <= size());
        count = std::min(count, size() - pos);
        for (auto idx = 0U; idx < count; ++idx) {
            auto ch = (*this)[pos + idx];
            auto diff = static_cast<int>(ch) - static_cast<int>(*str);
            if (diff != 0) {
                return diff;
            }
 
            if (*str == Ends) {
                return 1;
            }
            ++str;
        }
 
        if (*str != Ends) {
            return 0 - static_cast<int>(*str);
        }
 
        return 0;
    }
 
    int compare(
        std::size_t pos1,
        std::size_t count1,
        const char* str,
        std::size_t count2) const
    {
        COMMS_ASSERT(pos1 <= size());
        count1 = std::min(count1, size() - pos1);
        auto minCount = std::min(count1, count2);
        for (auto idx = 0U; idx < minCount; ++idx) {
            auto thisCh = (*this)[pos1 + idx];
            auto diff = static_cast<int>(thisCh) - static_cast<int>(*str);
            if (diff != 0) {
                return diff;
            }
 
            ++str;
        }
 
        return static_cast<int>(count1) - static_cast<int>(count2);
    }
 
    template <typename TIter>
    void replace(
        const TChar* first,
        const TChar* last,
        TIter first2,
        TIter last2)
    {
        COMMS_ASSERT(first <= end());
        COMMS_ASSERT(last <= end());
        COMMS_ASSERT(first <= last);
        auto begIter = begin() + std::distance(cbegin(), first);
        auto endIter = begin() + std::distance(cbegin(), last);
        for (auto iter = begIter; iter != endIter; ++iter) {
            if (last2 <= first2) {
                m_vec.erase(iter, endIter);
                return;
            }
 
            COMMS_GNU_WARNING_PUSH
#if COMMS_IS_GCC_11_OR_ABOVE
            COMMS_GNU_WARNING_DISABLE("-Wstringop-overflow")
#endif // #if COMMS_IS_GCC_12
            *iter = static_cast<TChar>(*first2); // Wrong warning reported by gcc-12
            COMMS_GNU_WARNING_POP
            ++first2;
        }
 
        m_vec.insert(last, first2, last2);
    }
 
    void replace(
        const TChar* first,
        const TChar* last,
        const TChar* str)
    {
        COMMS_ASSERT(first <= end());
        COMMS_ASSERT(last <= end());
        COMMS_ASSERT(first <= last);
        auto begIter = begin() + std::distance(cbegin(), first);
        auto endIter = begin() + std::distance(cbegin(), last);
        for (auto iter = begIter; iter != endIter; ++iter) {
            if (*str == Ends) {
                m_vec.erase(iter, endIter);
                return;
            }
 
            *iter = *str;
            ++str;
        }
 
        auto remCapacity = capacity() - size();
        auto endStr = str + remCapacity;
        auto lastStrIter = std::find(str, endStr, TChar(Ends));
        m_vec.insert(last, str, lastStrIter);
    }
 
    void replace(
        const TChar* first,
        const TChar* last,
        std::size_t count2,
        TChar ch)
    {
        COMMS_ASSERT(first <= end());
        COMMS_ASSERT(last <= end());
        COMMS_ASSERT(first <= last);
        auto dist = static_cast<std::size_t>(std::distance(first, last));
        auto fillDist = std::min(dist, count2);
        auto fillIter = begin() + std::distance(cbegin(), first);
        std::fill_n(fillIter, fillDist, ch);
        if (count2 <= dist) {
            m_vec.erase(first + fillDist, last);
            return;
        }
 
        m_vec.insert(last, count2 - fillDist, ch);
    }
 
    std::size_t copy(TChar* dest, std::size_t count, std::size_t pos) const
    {
        COMMS_ASSERT(pos <= size());
        count = std::min(count, size() - pos);
        std::copy_n(cbegin() + pos, count, dest);
        return count;
    }
 
    void resize(std::size_t count)
    {
        resize(count, Ends);
    }
 
    void resize(std::size_t count, TChar ch)
    {
        if (count <= size()) {
            m_vec.erase(cbegin() + count, cend());
            COMMS_ASSERT(m_vec[size()] == Ends);
            COMMS_ASSERT(size() == count);
            return;
        }
 
        m_vec.insert(end(), count - size(), ch);
    }
 
    void swap(StaticStringBase& other)
    {
        m_vec.swap(other.m_vec);
    }
 
    std::size_t find(const TChar* str, std::size_t pos, std::size_t count) const
    {
        COMMS_ASSERT(pos <= size());
        auto remCount = size() - pos;
        if (remCount < count) {
            return npos;
        }
 
        auto maxPos = size() - count;
        for (auto idx = pos; idx <= maxPos; ++idx) {
            auto thisStrBeg = &m_vec[idx];
            auto thisStrEnd = thisStrBeg + count;
            if (std::equal(thisStrBeg, thisStrEnd, str)) {
                return idx;
            }
        }
        return npos;
    }
 
    std::size_t find(const TChar* str, std::size_t pos) const
    {
        COMMS_ASSERT(pos <= size());
        auto maxStrCount = size() - pos;
        auto maxStrEnd = str + maxStrCount;
        auto iter = std::find(str, maxStrEnd, TChar(Ends));
        if (iter == maxStrEnd) {
            return npos;
        }
 
        auto strCount = static_cast<std::size_t>(std::distance(str, iter));
        return find(str, pos, strCount);
    }
 
    std::size_t find(TChar ch, std::size_t pos) const
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = cbegin() + pos;
        auto iter = std::find(begIter, cend(), ch);
        if (iter == cend()) {
            return npos;
        }
 
        return static_cast<std::size_t>(std::distance(cbegin(), iter));
    }
 
    std::size_t rfind(const TChar* str, std::size_t pos, std::size_t count) const
    {
        if ((empty()) || (size() < count)) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto startIdx = static_cast<int>(std::min(pos, size() - count));
        for (auto idx = startIdx; 0 <= idx; --idx) {
            auto thisStrBeg = &m_vec[static_cast<std::size_t>(idx)];
            auto thisStrEnd = thisStrBeg + count;
            if (std::equal(thisStrBeg, thisStrEnd, str)) {
                return static_cast<std::size_t>(idx);
            }
        }
        return npos;
    }
 
    std::size_t rfind(const TChar* str, std::size_t pos) const
    {
        return rfind(str, pos, strlen(str));
    }
 
    std::size_t rfind(TChar ch, std::size_t pos) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto begIter = std::reverse_iterator<const TChar*>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const TChar*>(cbegin());
        COMMS_ASSERT(static_cast<std::size_t>(std::distance(begIter, endIter)) == (pos + 1));
        auto iter = std::find(begIter, endIter, ch);
        if (iter == endIter) {
            return npos;
        }
 
        return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
    }
 
    std::size_t find_first_of(const TChar* str, std::size_t pos, std::size_t count) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto endStr = str + count;
        for (auto iter = cbegin() + pos; iter != cend(); ++iter) {
            auto foundIter = std::find(str, endStr, *iter);
            if (foundIter != endStr) {
                return static_cast<std::size_t>(std::distance(cbegin(), iter));
            }
        }
 
        return npos;
    }
 
    std::size_t find_first_of(const TChar* str, std::size_t pos) const
    {
        return find_first_of(str, pos, strlen(str));
    }
 
    std::size_t find_first_not_of(const TChar* str, std::size_t pos, std::size_t count) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto endStr = str + count;
        for (auto iter = cbegin() + pos; iter != cend(); ++iter) {
            auto found = std::none_of(str, endStr,
                [iter](TChar ch) -> bool
                {
                    return *iter == ch;
                });
 
            if (found) {
                return static_cast<std::size_t>(std::distance(cbegin(), iter));
            }
        }
 
        return npos;
    }
 
    std::size_t find_first_not_of(const TChar* str, std::size_t pos) const
    {
        return find_first_not_of(str, pos, strlen(str));
    }
 
    std::size_t find_first_not_of(TChar ch, std::size_t pos) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto iter = std::find_if(cbegin() + pos, cend(),
            [ch](TChar nextCh) -> bool
            {
                return ch != nextCh;
            });
 
        if (iter == cend()) {
            return npos;
        }
 
        return static_cast<std::size_t>(std::distance(cbegin(), iter));
    }
 
    std::size_t find_last_of(const TChar* str, std::size_t pos, std::size_t count) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto endStr = str + count;
 
        auto begIter = std::reverse_iterator<const TChar*>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const TChar*>(cbegin());
        for (auto iter = begIter; iter != endIter; ++iter) {
            auto foundIter = std::find(str, endStr, *iter);
            if (foundIter != endStr) {
                return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
            }
        }
 
        return npos;
    }
 
    std::size_t find_last_of(const TChar* str, std::size_t pos) const
    {
        return find_last_of(str, pos, strlen(str));
    }
 
    std::size_t find_last_not_of(const TChar* str, std::size_t pos, std::size_t count) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto endStr = str + count;
        auto begIter = std::reverse_iterator<const TChar*>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const TChar*>(cbegin());
        for (auto iter = begIter; iter != endIter; ++iter) {
            auto found = std::none_of(str, endStr,
                [iter](TChar ch) -> bool
                {
                    return *iter == ch;
                });
 
            if (found) {
                return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
            }
        }
 
        return npos;
    }
 
    std::size_t find_last_not_of(const TChar* str, std::size_t pos) const
    {
        return find_last_not_of(str, pos, strlen(str));
    }
 
    std::size_t find_last_not_of(TChar ch, std::size_t pos) const
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto begIter = std::reverse_iterator<const TChar*>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const TChar*>(cbegin());
        auto iter = std::find_if(begIter, endIter,
            [ch](TChar nextCh) -> bool
            {
                return ch != nextCh;
            });
 
        if (iter == endIter) {
            return npos;
        }
 
        return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
    }
 
    bool operator<(const TChar* str) const
    {
        for (auto idx = 0U; idx < size(); ++idx) {
            if (*str == Ends) {
                return false;
            }
 
            auto ch = m_vec[idx];
 
            if (ch < *str) {
                return true;
            }
 
            if (ch != *str) {
                break;
            }
 
            ++str;
        }
 
        return *str > Ends;
    }
 
    bool operator>(const TChar* str) const
    {
        for (auto idx = 0U; idx < size(); ++idx) {
            if (*str == Ends) {
                return true;
            }
 
            auto ch = m_vec[idx];
            if (*str < ch) {
                return true;
            }
 
            if (ch != *str) {
                break;
            }
 
            ++str;
        }
        return false;
    }
 
    bool operator==(const TChar* str) const
    {
        for (auto idx = 0U; idx < size(); ++idx) {
            if (*str == Ends) {
                return false;
            }
 
            auto ch = m_vec[idx];
            if (*str != ch) {
                return false;
            }
 
            ++str;
        }
 
        return (*str == Ends);
    }
 
private:
    void endString()
    {
        m_vec.push_back(TChar(Ends));
    }
 
    std::size_t strlen(const TChar* str) const
    {
        auto* strTmp = str;
        while (*strTmp != Ends) {
            ++strTmp;
 
        }
        return static_cast<std::size_t>(std::distance(str, strTmp));
    }
 
    static const TChar Ends = static_cast<TChar>('\0');
    StaticVectorBase<TChar> m_vec;
};
 
template <typename TChar, std::size_t TSize>
struct StaticStringStorageBase
{
    using StorageType = std::array<TChar, TSize>;
    StorageType m_data;
};
 
}  // namespace details
 
template <std::size_t TSize, typename TChar = char>
class StaticString :
    public details::StaticStringStorageBase<TChar, TSize + 1>,
    public details::StaticStringBase<TChar>
{
    using StorageBase = details::StaticStringStorageBase<TChar, TSize + 1>;
    using Base = details::StaticStringBase<TChar>;
 
public:
    using value_type = TChar;
    using size_type = std::size_t;
    using difference_type = typename StorageBase::StorageType::difference_type;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using iterator = pointer;
    using const_iterator = const_pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    static const decltype(Base::npos) npos = Base::npos;
 
    StaticString()
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
    }
 
    StaticString(size_type count, value_type ch)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(count, ch);
    }
 
    template <std::size_t TOtherSize>
    StaticString(
        const StaticString<TOtherSize, TChar>& other,
        size_type pos,
        size_type count = npos)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(other, pos, count);
    }
 
    StaticString(const_pointer str, size_type count)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(str, count);
    }
 
    StaticString(const_pointer str)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(str);
    }
 
    template <typename TIter>
    StaticString(TIter first, TIter last)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(first, last);
    }
 
    StaticString(const StaticString& other)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(other);
    }
 
    template <std::size_t TOtherSize>
    explicit StaticString(const StaticString<TOtherSize, TChar>& other)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(other);
    }
 
    StaticString(std::initializer_list<value_type> init)
      : Base(StorageBase::m_data.data(), StorageBase::m_data.size())
    {
        assign(init.begin(), init.end());
    }
 
    StaticString& operator=(const StaticString& other)
    {
        return assign(other);
    }
 
    template <std::size_t TOtherSize>
    StaticString& operator=(const StaticString<TOtherSize, TChar>& other)
    {
        return assign(other);
    }
 
    StaticString& operator=(const_pointer str)
    {
        return assign(str);
    }
 
    StaticString& operator=(value_type ch)
    {
        return assign(1, ch);
    }
 
    StaticString& operator=(std::initializer_list<value_type> init)
    {
        return assign(init);
    }
 
    StaticString& assign(size_type count, value_type ch)
    {
        Base::assign(count, ch);
        return *this;
    }
 
    template <typename TOtherSize>
    StaticString& assign(const StaticString& other)
    {
        if (&other != this) {
            Base::assign(other);
        }
        return *this;
    }
 
    template <std::size_t TOtherSize>
    StaticString& assign(const StaticString<TOtherSize, TChar>& other)
    {
        Base::assign(other);
        return *this;
    }
 
    template <std::size_t TOtherSize>
    StaticString& assign(
        const StaticString<TOtherSize, TChar>& other,
        size_type pos,
        size_type count = npos)
    {
        Base::assign(other, pos, count);
        return *this;
    }
 
    StaticString& assign(const_pointer str, size_type count)
    {
        Base::assign(str, count);
        return *this;
    }
 
    StaticString& assign(const_pointer str)
    {
        Base::assign(str);
        return *this;
    }
 
    template <typename TIter>
    StaticString& assign(TIter first, TIter last)
    {
        Base::assign(first, last);
        return *this;
    }
 
    StaticString& assign(std::initializer_list<value_type> init)
    {
        return assign(init.begin(), init.end());
    }
 
    reference at(size_type pos)
    {
        return Base::at(pos);
    }
 
    const_reference at(size_type pos) const
    {
        return Base::at(pos);
    }
 
    reference operator[](size_type pos)
    {
        return Base::operator[](pos);
    }
 
    const_reference operator[](size_type pos) const
    {
        return Base::operator[](pos);
    }
 
    reference front()
    {
        return Base::front();
    }
 
    const_reference front() const
    {
        return Base::front();
    }
 
    reference back()
    {
        return Base::back();
    }
 
    const_reference back() const
    {
        return Base::back();
    }
 
    const_pointer data() const
    {
        return Base::data();
    }
 
    const_pointer c_str() const
    {
        return data();
    }
 
    iterator begin()
    {
        return Base::begin();
    }
 
    const_iterator begin() const
    {
        return cbegin();
    }
 
    const_iterator cbegin() const
    {
        return Base::cbegin();
    }
 
    iterator end()
    {
        return Base::end();
    }
 
    const_iterator end() const
    {
        return cend();
    }
 
    const_iterator cend() const
    {
        return Base::cend();
    }
 
    reverse_iterator rbegin()
    {
        return reverse_iterator(end());
    }
 
    const_reverse_iterator rbegin() const
    {
        return crbegin();
    }
 
    const_reverse_iterator crbegin() const
    {
        return reverse_iterator(cend());
    }
 
    reverse_iterator rend()
    {
        return reverse_iterator(begin());
    }
 
    const_reverse_iterator rend() const
    {
        return crend();
    }
 
    const_reverse_iterator crend() const
    {
        return reverse_iterator(cbegin());
    }
 
    bool empty() const
    {
        return Base::empty();
    }
 
    size_type size() const
    {
        return Base::size();
    }
 
    size_type length() const
    {
        return size();
    }
 
    size_type max_size() const
    {
        return capacity();
    }
 
    void reserve(size_type)
    {
    }
 
    size_type capacity() const
    {
        return Base::capacity();
    }
 
    void shrink_to_fit()
    {
    }
 
    void clear()
    {
        Base::clear();
    }
 
    StaticString& insert(size_type idx, size_type count, value_type ch)
    {
        Base::insert(idx, count, ch);
        return *this;
    }
 
    StaticString& insert(size_type idx, const_pointer str)
    {
        Base::insert(idx, str);
        return *this;
    }
 
    StaticString& insert(size_type idx, const_pointer str, size_type count)
    {
        Base::insert(idx, str, count);
        return *this;
    }
 
    template <std::size_t TAnySize>
    StaticString& insert(size_type idx, const StaticString<TAnySize, TChar>& str)
    {
        Base::insert(idx, str);
        return *this;
    }
 
    template <std::size_t TAnySize>
    StaticString& insert(
        size_type idx,
        const StaticString<TAnySize, TChar>& str,
        size_type str_idx,
        size_type count = npos)
    {
        Base::insert(idx, str, str_idx, count);
        return *this;
    }
 
    iterator insert(const_iterator pos, value_type ch)
    {
        return Base::insert(pos, ch);
    }
 
    iterator insert(const_iterator pos, size_type count, value_type ch)
    {
        return Base::insert(pos, count, ch);
    }
 
    template <typename TIter>
    iterator insert(const_iterator pos, TIter first, TIter last)
    {
        return Base::insert(pos, first, last);
    }
 
    iterator insert(const_iterator pos, std::initializer_list<value_type> init)
    {
        return insert(pos, init.begin(), init.end());
    }
 
    StaticString& erase(std::size_t idx, std::size_t count = npos)
    {
        Base::erase(idx, count);
        return *this;
    }
 
    iterator erase(const_iterator pos)
    {
        return Base::erase(pos);
    }
 
    iterator erase(const_iterator first, const_iterator last)
    {
        return Base::erase(first, last);
    }
 
    void push_back(value_type ch)
    {
        Base::push_back(ch);
    }
 
    void pop_back()
    {
        Base::pop_back();
    }
 
    StaticString& append(size_type count, value_type ch)
    {
        return insert(size(), count, ch);
    }
 
    template <std::size_t TAnySize>
    StaticString& append(const StaticString<TAnySize, TChar>& other)
    {
        return insert(size(), other);
    }
 
    template <std::size_t TAnySize>
    StaticString& append(
        const StaticString<TAnySize, TChar>& other,
        size_type pos,
        size_type count = npos)
    {
        return insert(size(), other, pos, count);
    }
 
    StaticString& append(const TChar* str, size_type count)
    {
        return insert(size(), str, count);
    }
 
    StaticString& append(const TChar* str)
    {
        return insert(size(), str);
    }
 
    template <typename TIter>
    StaticString& append(TIter first, TIter last)
    {
        insert(end(), first, last);
        return *this;
    }
 
    StaticString& append(std::initializer_list<value_type> init)
    {
        insert(end(), init.begin(), init.end());
        return *this;
    }
 
    template <std::size_t TAnySize>
    StaticString& operator+=(const StaticString<TAnySize, TChar>& other)
    {
        return append(other);
    }
 
    StaticString& operator+=(value_type ch)
    {
        return append(1U, ch);
    }
 
    StaticString& operator+=(const_pointer str)
    {
        return append(str);
    }
 
    StaticString& operator+=(std::initializer_list<value_type> init)
    {
        return append(init);
    }
 
    template <std::size_t TAnySize>
    int compare(const StaticString<TAnySize, TChar>& other) const
    {
        return compare(0, size(), other);
    }
 
    template <std::size_t TAnySize>
    int compare(
        size_type pos,
        size_type count,
        const StaticString<TAnySize, TChar>& other) const
    {
        return compare(pos, count, other, 0, other.size());
    }
 
    template <std::size_t TAnySize>
    int compare(
        size_type pos1,
        size_type count1,
        const StaticString<TAnySize, TChar>& other,
        size_type pos2,
        size_type count2 = npos) const
    {
        return Base::compare(pos1, count1, other, pos2, count2);
    }
 
    int compare(const_pointer str) const
    {
        return compare(0, size(), str);
    }
 
    int compare(size_type pos, size_type count, const_pointer str) const
    {
        return Base::compare(pos, count, str);
    }
 
    int compare(size_type pos, size_type count1, const_pointer str, size_type count2) const
    {
        return Base::compare(pos, count1, str, count2);
    }
 
    template <std::size_t TAnySize>
    StaticString& replace(
        size_type pos,
        size_type count,
        const StaticString<TAnySize, TChar>& other)
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = begin() + pos;
        auto remCount = static_cast<std::size_t>(std::distance(begIter, end()));
        auto endIter = begIter + std::min(count, remCount);
        return replace(begIter, endIter, other.begin(), other.end());
    }
 
    template <std::size_t TAnySize>
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        const StaticString<TAnySize, TChar>& other)
    {
        return replace(first, last, other.begin(), other.end());
    }
 
    template <std::size_t TAnySize>
    StaticString& replace(
        size_type pos,
        size_type count,
        const StaticString<TAnySize, TChar>& other,
        size_type pos2,
        size_type count2 = npos)
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = begin() + pos;
        auto remCount = static_cast<std::size_t>(std::distance(begIter, end()));
        auto endIter = begIter + std::min(count, remCount);
 
        COMMS_ASSERT(pos2 <= other.size());
        auto begIter2 = other.begin() + pos2;
        auto remCount2 = static_cast<std::size_t>(std::distance(begIter2, other.end()));
        auto endIter2 = begIter2 + std::min(count2, remCount2);
 
        return replace(begIter, endIter, begIter2, endIter2);
    }
 
    template <typename TIter>
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        TIter first2,
        TIter last2)
    {
        Base::replace(first, last, first2, last2);
        return *this;
    }
 
    StaticString& replace(
        size_type pos,
        size_type count,
        const_pointer str,
        size_type count2)
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = cbegin() + pos;
        auto endIter = begIter + std::min(count, size() - pos);
        return replace(begIter, endIter, str, str + count2);
    }
 
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        const_pointer str,
        size_type count2)
    {
        return replace(first, last, str, str + count2);
    }
 
    StaticString& replace(
        size_type pos,
        size_type count,
        const_pointer str)
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = cbegin() + pos;
        auto endIter = begIter + std::min(count, size() - pos);
        return replace(begIter, endIter, str);
    }
 
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        const_pointer str)
    {
        Base::replace(first, last, str);
        return *this;
    }
 
    StaticString& replace(
        size_type pos,
        size_type count,
        size_type count2,
        value_type ch)
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = cbegin() + pos;
        auto endIter = begIter + std::min(count, size() - pos);
        return replace(begIter, endIter, count2, ch);
    }
 
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        size_type count2,
        value_type ch)
    {
        Base::replace(first, last, count2, ch);
        return *this;
    }
 
    StaticString& replace(
        const_iterator first,
        const_iterator last,
        std::initializer_list<value_type> init)
    {
        return replace(first, last, init.begin(), init.end());
    }
 
    StaticString substr(size_type pos = 0, size_type count = npos) const
    {
        COMMS_ASSERT(pos <= size());
        auto begIter = cbegin() + pos;
        auto endIter = begIter + std::min(count, size() - pos);
        return StaticString(cbegin() + pos, endIter);
    }
 
    size_type copy(pointer dest, size_type count, size_type pos = 0) const
    {
        return Base::copy(dest, count, pos);
    }
 
    void resize(size_type count)
    {
        Base::resize(count);
    }
 
    void resize(size_type count, value_type ch)
    {
        Base::resize(count, ch);
    }
 
    template <std::size_t TAnySize>
    void swap(StaticString<TAnySize, TChar>& other)
    {
        Base::swap(other);
    }
 
    template <std::size_t TAnySize>
    size_type find(const StaticString<TAnySize, TChar>& str, size_type pos = 0) const
    {
        COMMS_ASSERT(pos <= size());
        return find(str.cbegin(), pos, str.size());
    }
 
    size_type find(const_pointer str, size_type pos, size_type count) const
    {
        return Base::find(str, pos, count);
    }
 
    size_type find(const_pointer str, size_type pos = 0) const
    {
        return Base::find(str, pos);
    }
 
    size_type find(value_type ch, size_type pos = 0) const
    {
        return Base::find(ch, pos);
    }
 
    template <std::size_t TAnySize>
    size_type rfind(const StaticString<TAnySize, TChar>& str, size_type pos = npos) const
    {
        return rfind(str.cbegin(), pos, str.size());
    }
 
    size_type rfind(const_pointer str, size_type pos, size_type count) const
    {
        return Base::rfind(str, pos, count);
    }
 
    size_type rfind(const_pointer str, size_type pos = npos) const
    {
        return Base::rfind(str, pos);
    }
 
    size_type rfind(value_type ch, size_type pos = npos) const
    {
        return Base::rfind(ch, pos);
    }
 
    template <std::size_t TAnySize>
    size_type find_first_of(const StaticString<TAnySize, TChar>& str, size_type pos = 0) const
    {
        COMMS_ASSERT(pos <= size());
        return find_first_of(str.cbegin(), pos, str.size());
    }
 
    size_type find_first_of(const_pointer str, size_type pos, size_type count) const
    {
        return Base::find_first_of(str, pos, count);
    }
 
    size_type find_first_of(const_pointer str, size_type pos = 0) const
    {
        return Base::find_first_of(str, pos);
    }
 
    size_type find_first_of(value_type ch, size_type pos = 0) const
    {
        return find(ch, pos);
    }
 
    template <std::size_t TAnySize>
    size_type find_first_not_of(const StaticString<TAnySize, TChar>& str, size_type pos = 0) const
    {
        COMMS_ASSERT(pos <= size());
        return find_first_not_of(str.cbegin(), pos, str.size());
    }
 
    size_type find_first_not_of(const_pointer str, size_type pos, size_type count) const
    {
        return Base::find_first_not_of(str, pos, count);
    }
 
    size_type find_first_not_of(const_pointer str, size_type pos = 0) const
    {
        return Base::find_first_not_of(str, pos);
    }
 
    size_type find_first_not_of(value_type ch, size_type pos = 0) const
    {
        return Base::find_first_not_of(ch, pos);
    }
 
    template <std::size_t TAnySize>
    size_type find_last_of(const StaticString<TAnySize, TChar>& str, size_type pos = npos) const
    {
        return find_last_of(str.cbegin(), pos, str.size());
    }
 
    size_type find_last_of(const_pointer str, size_type pos, size_type count) const
    {
        return Base::find_last_of(str, pos, count);
    }
 
    size_type find_last_of(const_pointer str, size_type pos = npos) const
    {
        return Base::find_last_of(str, pos);
    }
 
    size_type find_last_of(value_type ch, size_type pos = npos) const
    {
        return rfind(ch, pos);
    }
 
    template <std::size_t TAnySize>
    size_type find_last_not_of(const StaticString<TAnySize, TChar>& str, size_type pos = npos) const
    {
        return find_last_not_of(str.cbegin(), pos, str.size());
    }
 
    size_type find_last_not_of(const_pointer str, size_type pos, size_type count) const
    {
        return Base::find_last_not_of(str, pos, count);
    }
 
    size_type find_last_not_of(const_pointer str, size_type pos = npos) const
    {
        return Base::find_last_not_of(str, pos);
    }
 
    size_type find_last_not_of(value_type ch, size_type pos = npos) const
    {
        return Base::find_last_not_of(ch, pos);
    }
 
    bool operator<(const_pointer str) const
    {
        return Base::operator<(str);
    }
 
    bool operator>(const_pointer str) const
    {
        return Base::operator>(str);
    }
 
    bool operator==(const_pointer str) const
    {
        return Base::operator==(str);
    }
};
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator<(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return std::lexicographical_compare(str1.begin(), str1.end(), str2.begin(), str2.end());
}
 
template <std::size_t TSize1, typename TChar>
bool operator<(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return (str2 > str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator<(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return str1.operator<(str2);
}
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator<=(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return !(str2 < str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator<=(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return !(str2 < str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator<=(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return !(str1 > str2);
}
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator>(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return (str2 < str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator>(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return (str2 < str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator>(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return str1.operator<(str2);
}
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator>=(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return !(str1 < str2);
}
 
template <std::size_t TSize1, typename TChar>
bool operator>=(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return !(str1 < str2);
}
 
template <std::size_t TSize1, typename TChar>
bool operator>=(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return !(str1 < str2);
}
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator==(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return
        (str1.size() == str2.size()) &&
        std::equal(str1.begin(), str1.end(), str2.begin());
}
 
template <std::size_t TSize1, typename TChar>
bool operator==(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return str2.operator==(str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator==(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return str1.operator==(str2);
}
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
bool operator!=(const StaticString<TSize1, TChar>& str1, const StaticString<TSize2, TChar>& str2)
{
    return !(str1 == str2);
}
 
template <std::size_t TSize1, typename TChar>
bool operator!=(const TChar* str1, const StaticString<TSize1, TChar>& str2)
{
    return !(str2 == str1);
}
 
template <std::size_t TSize1, typename TChar>
bool operator!=(const StaticString<TSize1, TChar>& str1, const TChar* str2)
{
    return !(str1 == str2);
}
 
namespace details
{
 
template <typename T>
struct IsStaticString
{
    static const bool Value = false;
};
 
template <std::size_t TSize>
struct IsStaticString<comms::util::StaticString<TSize> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
static constexpr bool isStaticString()
{
    return details::IsStaticString<T>::Value;
}
 
}  // namespace util
 
}  // namespace comms
 
namespace std
{
 
template <std::size_t TSize1, std::size_t TSize2, typename TChar>
void swap(comms::util::StaticString<TSize1, TChar>& str1, comms::util::StaticString<TSize2, TChar>& str2)
{
    str1.swap(str2);
}
 
}  // namespace std