stackstring.h

Go to the documentation of this file.

 
#ifndef _STACKSTRING_CLASS_HEADER_
#define _STACKSTRING_CLASS_HEADER_
 
namespace A_UTILS_NS
{
#define stack_string_baseData_OUT_OF_RANGE_ASSERT tFalse
struct assert_out_of_range
{
};
 
struct growinheap_out_of_range
{
};
 
template<typename DATASTORE>
struct stack_string_data_handler // empty impl
{
 
};
 
template <> struct stack_string_data_handler<growinheap_out_of_range>
{
    typedef tChar                                   value_type;
    typedef tSize                                   size_type;
 
    stack_string_data_handler()
    {
        Init();
    }
    stack_string_data_handler(const stack_string_data_handler& oHandler) = delete;
    stack_string_data_handler& operator=(const stack_string_data_handler& oHandler) = delete;
 
    stack_string_data_handler(stack_string_data_handler&& oHandler) = delete;
    stack_string_data_handler& operator=(stack_string_data_handler&& oHandler) = delete;
 
    ~stack_string_data_handler()
    {
        Deinit();
    }
 
    tVoid Init()
    {
        m_szCurrentCapacity = 0;
        m_pGrownSize = nullptr;
    }
 
    tVoid Deinit()
    {
        if (m_pGrownSize != nullptr)
        {
            delete [] m_pGrownSize;
            m_pGrownSize = nullptr;
            m_szCurrentCapacity = 0;
        }
    }
 
    size_type GetCapacity(const size_type& szFixCapacity) const
    {
        if (m_pGrownSize != nullptr)
        {
            return m_szCurrentCapacity;
        }
        return szFixCapacity;
    }
 
    size_type GetMaxSize(const size_type& /* szFixCapacity */) const
    {
        // by default, the maximum usable size is one less than the
        // g_npos, which is std::numeric_limits<size_t>::max()
        return (g_npos - 1);
    }
 
    tVoid Resize(value_type* pFixDataArray,
                 const size_type& szFixCapacity,
                 const size_type& szNewCapacity)
    {
        if (szNewCapacity <= GetCapacity(szFixCapacity))
        {
            if (szNewCapacity <= szFixCapacity)
            {
                if (m_pGrownSize)
                {
                    cStringUtil::Copy(pFixDataArray, m_pGrownSize, szNewCapacity, szFixCapacity + 1);
                    delete[] m_pGrownSize;
                    m_pGrownSize = nullptr;
                }
                else
                {
                    pFixDataArray[szNewCapacity] = '\0';
                }
            }
            else
            {
                m_pGrownSize[szNewCapacity] = '\0';
            }
        }
        else
        {
            size_type szNewCapacityAlloc = szNewCapacity + (szNewCapacity * 2) / 3;
            value_type* const pNewStore = new (std::nothrow) value_type[szNewCapacityAlloc + 1] {};
            if (nullptr == pNewStore)
            {
                return;
            }
            
            pNewStore[0] = '\0';
            if (m_pGrownSize)
            {
                cStringUtil::Copy(pNewStore, m_pGrownSize, cStringUtil::InvalidPos, szNewCapacityAlloc + 1);
                delete [] m_pGrownSize;
            }
            else
            {
                cStringUtil::Copy(pNewStore, pFixDataArray, cStringUtil::InvalidPos, szNewCapacityAlloc + 1);
            }
            m_pGrownSize = pNewStore;
            m_szCurrentCapacity = szNewCapacityAlloc;
        }
    }
 
    const value_type* GetCData(const value_type* pFixDataArray) const
    {
        if (m_pGrownSize != nullptr)
        {
            return m_pGrownSize;
        }
        return pFixDataArray;
    }
 
    value_type* GetData(value_type* pFixDataArray)
    {
        if (m_pGrownSize != nullptr)
        {
            return m_pGrownSize;
        }
        return pFixDataArray;
    }
private:
    size_type   m_szCurrentCapacity;
    value_type* m_pGrownSize;
};
 
template <> struct stack_string_data_handler<assert_out_of_range>
{
    typedef tChar                                   value_type;
    typedef tSize                                   size_type;
 
    size_type GetCapacity(const size_type& szFixCapacity) const
    {
        return szFixCapacity;
    }
 
    size_type GetMaxSize(const size_type& szFixCapacity) const
    {
        return szFixCapacity;
    }
 
    tVoid Resize(value_type* pFixDataArray,
        const size_type& szFixCapacity,
        const size_type& szNewCapacity)
    {
        if (szNewCapacity <= GetCapacity(szFixCapacity))
        {
            pFixDataArray[szNewCapacity] = '\0';
        }
        else
        {
            A_UTILS_ASSERT(stack_string_baseData_OUT_OF_RANGE_ASSERT);
        }
    }
 
    const value_type* GetCData(const value_type* pFixDataArray) const
    {
        return pFixDataArray;
    }
 
    value_type* GetData(value_type* pFixDataArray)
    {
        return pFixDataArray;
    }
};
 
template<tSize TSIZE, typename datastoreT>
class stack_string_data
{
private:
    typedef stack_string_data_handler<datastoreT>     datastoreHandler;
public:
    typedef typename datastoreHandler::value_type   value_type;
    typedef typename datastoreHandler::size_type    size_type;
 
    stack_string_data()
    {
    }
 
    virtual ~stack_string_data()
    {
    }
 
    stack_string_data(const stack_string_data& oStackData)
    {
    }
 
    stack_string_data& operator=(const stack_string_data& oStackData)
    {
        return *this;
    }
 
    stack_string_data(stack_string_data&& oStackData)
    {
    }
 
    stack_string_data& operator=(stack_string_data&& oStackData)
    {
        return *this;
    }
 
    size_type capacity() const
    {
        return m_oDataHandler.GetCapacity(TSIZE);
    }
    size_type max_size() const
    {
        return m_oDataHandler.GetMaxSize(TSIZE);
    }
    tVoid resize(size_type szNewSize)
    {
        m_oDataHandler.Resize(&m_oData[0], TSIZE, szNewSize);
    }
 
    value_type* data()
    {
        return m_oDataHandler.GetData(&m_oData[0]);
    }
 
    const value_type* cdata() const
    {
        return m_oDataHandler.GetCData(&m_oData[0]);
    }
private:
    datastoreHandler m_oDataHandler;
    value_type       m_oData[TSIZE + 1];
};
 
template <tSize TSIZE, typename datastoreType = assert_out_of_range>
class stack_string_base : public stack_string_data<TSIZE, datastoreType>
{
    public:// public definitions
        //StorageType
        typedef stack_string_base<TSIZE, datastoreType>   _myType;
        typedef stack_string_data<TSIZE, datastoreType>   _myBase;
        typedef typename _myBase::value_type             value_type;
        typedef typename _myBase::size_type              size_type;
        typedef simple_pointer_iterator<value_type>       iterator;
        typedef simple_pointer_iterator<const value_type> const_iterator;
 
        typedef std::reverse_iterator<iterator>          reverse_iterator;
        typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 
        //bring base methods into scope
        using _myBase::capacity;
        using _myBase::data;
        using _myBase::cdata;
        using _myBase::resize;
 
    public:
        static const tSize   InvalidPos = g_npos;
    public:
        stack_string_base() : _myBase()
        {
            clear();
        }
 
        stack_string_base(const _myType& strValue) : stack_string_base()
        {
            assign(strValue);
        }
 
        stack_string_base& operator=(const _myType& strValue)
        {
            assign(strValue);
            return *this;
        }
 
        template <tSize T2, typename dT2>
        stack_string_base(const stack_string_base<T2, dT2>& strValue) : stack_string_base()
        {
            assign(strValue);
        }
 
        template <tSize T2, typename dT2>
        stack_string_base& operator=(const stack_string_base<T2, dT2>& strValue)
        {
            assign(strValue);
            return *this;
        }
 
        stack_string_base(_myType&& strValue) : stack_string_base()
        {
            //we can not move it !! its not on heap
            assign(strValue);
        }
 
        stack_string_base& operator=(_myType&& strValue)
        {
            assign(strValue);
            return *this;
        }
 
        template <tSize T2, typename dT2>
        stack_string_base(stack_string_base<T2, dT2>&& strValue) : stack_string_base()
        {
            //we can not move it !! its not on heap
            assign(strValue);
        }
 
        template <tSize T2, typename dT2>
        stack_string_base& operator=(stack_string_base<T2, dT2>&& strValue)
        {
            assign(strValue);
            return *this;
        }
 
        ~stack_string_base()
        {
        }
 
        iterator begin()
        {
            return iterator(data());
        }
 
        iterator end()
        {
            return iterator(&(data()[length()]));
        }
 
        reverse_iterator rbegin()
        {
            return reverse_iterator(&(data()[length()]));
        }
 
        reverse_iterator rend()
        {
            return reverse_iterator(data());
        }
 
        const_iterator cbegin() const
        {
            return const_iterator(data());
        }
 
        const_iterator cend() const
        {
            return const_iterator(&(data()[length()]));
        }
 
        const_reverse_iterator crbegin() const
        {
            return const_reverse_iterator(&(data()[length()]));
        }
 
        const_reverse_iterator crend() const
        {
            return const_reverse_iterator(data());
        }
 
        const value_type* c_str() const
        {
            return cdata();
        }
 
        size_type length() const
        {
            return cStringUtil::GetLength(c_str());
        }
 
        tVoid clear()
        {
            data()[0] = '\0';
        }
 
        _myType& append(size_type szCount, value_type c)
        {
            if (szCount != InvalidPos)
            {
                size_type szMax           = capacity();
                size_type szCurrentLength = length();
                if (szCurrentLength + szCount > capacity())
                {
                    resize(szCurrentLength + szCount);
                    //check whether alloc failed
                    if ((szCurrentLength + szCount) > capacity())
                    {
                        return *this;
                    }
                    szMax = capacity();
                }
                size_type nIdx = szCurrentLength;
                for (;nIdx < szCurrentLength + szCount && nIdx < szMax;
                     ++nIdx)
                {
                    data()[nIdx] = c;
                }
                data()[nIdx] = '\0';
            }
            return *this;
        }
 
        template <tSize T2, typename dT2>
        _myType& append(const stack_string_base<T2, dT2>& strValue, size_type nPos, size_type nLength)
        {
            size_type szCurrentLength = length();
            size_type szToAppendLength = strValue.length();
            if (nLength != InvalidPos)
            {
                if (nLength < szToAppendLength)
                {
                    szToAppendLength = nLength;
                }
            }
            if (nPos >= szToAppendLength)
            {
                return *this;
            }
            size_type szMax = capacity();
            if (szCurrentLength + szToAppendLength > capacity())
            {
                resize(szCurrentLength + szToAppendLength);
                //check whether alloc failed
                if (szCurrentLength + szToAppendLength > capacity())
                {
                    return *this;
                }
                szMax = capacity();
            }
            cStringUtil::Copy(&(data()[szCurrentLength]), &(strValue.c_str()[nPos]), szToAppendLength, (szMax + 1) - szCurrentLength);
            return *this;
        }
 
        template <tSize T2, typename dT2>
        _myType& append(const stack_string_base<T2, dT2>& strValue, size_type nLength = InvalidPos)
        {
            return append(strValue, 0, nLength);
        }
 
        template <tSize T2, typename dT2>
        _myType& assign(const stack_string_base<T2, dT2>& strValue)
        {
            return assign(strValue.c_str(), 0, strValue.length());
        }
 
        template <tSize T2, typename dT2>
        _myType& assign(const stack_string_base<T2, dT2>& strValue, tSize nPos, tSize nLength)
        {
            return assign(strValue.c_str(), nPos, nLength);
        }
 
        _myType& assign(const value_type* pChar, tSize nLength = InvalidPos)
        {
            return assign(pChar, 0, nLength);
        }
 
        _myType& assign(size_type nCount, value_type cCharacter)
        {
            if (nCount > capacity())
            {
                resize(nCount);
                //check whether alloc failed
                if (nCount > capacity())
                {
                    return *this;
                }
            }
 
            if (nCount > 0)
            {
                cStringUtil::Repeat(data(), capacity() + 1, nCount, cCharacter);
            }
            else
            {
                clear();
            }
            return *this;
        }
 
        _myType& assign(const value_type* strValue, tSize nPos, tSize nLength)
        {
            tSize szLengthToAppend = cStringUtil::GetLength(strValue);
            if (nPos == InvalidPos)
            {
                nPos = 0;
            }
            if (nPos >= szLengthToAppend)
            {
                clear();
                return *this;
            }
            else
            {
                szLengthToAppend -= nPos;
            }
            if (nLength != InvalidPos)
            {
                if (nLength < szLengthToAppend)
                {
                    szLengthToAppend = nLength;
                }
            }
            if (capacity() < szLengthToAppend)
            {
                resize(szLengthToAppend);
                //check whether alloc failed
                if (capacity() < szLengthToAppend)
                {
                    return *this;
                }
            }
            cStringUtil::Copy(data(), &strValue[nPos], szLengthToAppend, capacity() + 1);
            return *this;
        }
 
        const value_type& operator[](size_type nIdx) const
        {
            return cdata()[nIdx];
        }
 
        value_type& operator[](size_type nIdx)
        {
            return data()[nIdx];
        }
 
        template <tSize T2, typename dT2>
        _myType& insert(tSize szInsertPos,
                        const stack_string_base<T2, dT2>& strValue,
                        tSize szFromPos,
                        tSize szLength)
        {
            tSize szLengthToInsert = strValue.length();
            tSize szLengthMyLength = length();
 
            //check for valid insertpos
            if (szInsertPos == InvalidPos)
            {
                szInsertPos = 0;
            }
            else if (szInsertPos > szLengthMyLength)
            {
                szInsertPos = szLengthMyLength;
            }
 
            //check for valid pos of given value
            if (szFromPos == InvalidPos)
            {
                szFromPos = 0;
            }
            else if (szFromPos >= szLengthToInsert)
            {
                return *this;
            }
            //check for valid insert Length
            szLengthToInsert = cStringUtil::GetLength(&strValue[szFromPos]);
            if (szLength < szLengthToInsert && szLength != InvalidPos)
            {
                szLengthToInsert = szLength;
            }
 
            if (szLengthMyLength + szLengthToInsert > capacity())
            {
                resize(szLengthMyLength + szLengthToInsert);
                //check whether alloc failed
                if (szLengthMyLength + szLengthToInsert > capacity())
                {
                    return *this;
                }
            }
 
            const tChar* pFromChar = &strValue[szFromPos];
            cStringUtil::PushFront(&(data()[szInsertPos]), (capacity() + 1) - szInsertPos, pFromChar, szLengthToInsert);
            return *this;
        }
 
        _myType& erase(size_type nPos, size_type szLength = InvalidPos)
        {
            cStringUtil::Delete(data(), nPos, szLength);
            return *this;
        }
 
        template <tSize T2, typename dT2>
        size_type find(const stack_string_base<T2, dT2>& strValue, size_type nStartPos = 0) const
        {
            size_type szCurrentLength = length();
            size_type szFindLength    = strValue.length();
            if (nStartPos == InvalidPos)
            {
                nStartPos = 0;
            }
            if (nStartPos > szCurrentLength)
            {
                return InvalidPos;
            }
            if (szFindLength == 0)
            {
                return nStartPos;
            }
            value_type aToken[2];
            aToken[0] = strValue[0];
            aToken[1] = '\0';
            size_type szCurrentBeginPos = nStartPos;
            while (szCurrentBeginPos + szFindLength <= szCurrentLength)
            {
                size_type szFirstOf = cStringUtil::FindFirstOfToken(c_str(), aToken, szCurrentBeginPos);
                if (szFirstOf != InvalidPos)
                {
                    szCurrentBeginPos = szFirstOf;
                    if (cStringUtil::IsEqual(&(c_str()[szCurrentBeginPos]), strValue.c_str(), szFindLength))
                    {
                        return szCurrentBeginPos;
                    }
                    else
                    {
                        szCurrentBeginPos++;
                    }
                }
                else
                {
                    return InvalidPos;
                }
            }
            return InvalidPos;
        }
 
        _myType substr(size_type nPos, size_type nLength = InvalidPos) const
        {
            _myType strRes;
            size_type szCurrentLength = length();
            if (nPos == InvalidPos)
            {
                nPos = 0;
            }
            if (nPos >= szCurrentLength)
            {
                return strRes;
            }
            if (nLength == InvalidPos)
            {
                nLength = szCurrentLength - nPos;
            }
            strRes.assign(&(cdata()[nPos]), nLength);
            return strRes;
        }
 
        template <tSize T2, typename dT2>
        void swap(stack_string_base<T2, dT2>& strValue)
        {
            stack_string_base<T2, dT2> strSwapValue;
            strSwapValue.assign(*this);
            assign(strValue);
            strValue.assign(strSwapValue);
        }
 
        size_type rfind(tChar cValue, size_type nStartPos = InvalidPos) const
        {
            value_type aToken[2];
            aToken[0] = cValue;
            aToken[1] = '\0';
            return cStringUtil::RFindFirstOfToken(c_str(), aToken, nStartPos);
        }
 
        template <tSize T2, typename dT2>
        size_type find_first_of(const stack_string_base<T2, dT2>& strValue, size_type nStartPos = 0) const
        {
            return cStringUtil::FindFirstOfToken(c_str(), strValue.c_str(), nStartPos);
        }
 
        template <tSize T2, typename dT2>
        size_type find_first_not_of(const stack_string_base<T2, dT2>& strValue, size_type nStartPos = 0) const
        {
            return cStringUtil::FindFirstNotOfToken(c_str(), strValue.c_str(), nStartPos);
        }
};
 
} // namespace A_UTILS_NS
 
 
 
 
#endif // _STACKSTRING_CLASS_HEADER_