Function append

Summary

#include <include/EASTL/string.h>

(1) this_type & append(const this_type &x)

(2) this_type & append(const this_type &x, size_type position, size_type n=npos)

(3) this_type & append(const value_type *p, size_type n)

(4) this_type & append(const value_type *p)

(5) this_type & append(size_type n, value_type c)

(6) this_type & append(const value_type *pBegin, const value_type *pEnd)

Function overload

#include <include/EASTL/string.h>

this_type & append(const this_type &x)

template <typename T, typename Allocator>
inline basic_string<T, Allocator>& basic_string<T, Allocator>::append(const this_type& x)
{
    return append(x.internalLayout().BeginPtr(), x.internalLayout().EndPtr());
}

#include <include/EASTL/string.h>

this_type & append(const this_type &x, size_type position, size_type n=npos)

template <typename T, typename Allocator>
inline basic_string<T, Allocator>& basic_string<T, Allocator>::append(const this_type& x, size_type position, size_type n)
{
    #if EASTL_STRING_OPT_RANGE_ERRORS
        if(EASTL_UNLIKELY(position >= x.internalLayout().GetSize())) // position must be < x.mpEnd, but position + n may be > mpEnd.
            ThrowRangeException();
    #endif
        return append(x.internalLayout().BeginPtr() + position,
                      x.internalLayout().BeginPtr() + position + eastl::min_alt(n, x.internalLayout().GetSize() - position));
}

#include <include/EASTL/string.h>

this_type & append(const value_type *p, size_type n)

template <typename T, typename Allocator>
inline basic_string<T, Allocator>& basic_string<T, Allocator>::append(const value_type* p, size_type n)
{
    return append(p, p + n);
}

#include <include/EASTL/string.h>

this_type & append(const value_type *p)

template <typename T, typename Allocator>
inline basic_string<T, Allocator>& basic_string<T, Allocator>::append(const value_type* p)
{
    return append(p, p + CharStrlen(p));
}

#include <include/EASTL/string.h>

this_type & append(size_type n, value_type c)

template <typename T, typename Allocator>
basic_string<T, Allocator>& basic_string<T, Allocator>::append(size_type n, value_type c)
{
    if (n > 0)
    {
        const size_type nSize = internalLayout().GetSize();
        const size_type nCapacity = capacity();
        if((nSize + n) > nCapacity)
            reserve(GetNewCapacity(nCapacity, (nSize + n) - nCapacity));
        pointer pNewEnd = CharStringUninitializedFillN(internalLayout().EndPtr(), n, c);
        *pNewEnd = 0;
        internalLayout().SetSize(nSize + n);
    }
    return *this;
}

#include <include/EASTL/string.h>

this_type & append(const value_type *pBegin, const value_type *pEnd)

template <typename T, typename Allocator>
basic_string<T, Allocator>& basic_string<T, Allocator>::append(const value_type* pBegin, const value_type* pEnd)
{
    if(pBegin != pEnd)
    {
        const size_type nOldSize  = internalLayout().GetSize();
        const size_type n         = (size_type)(pEnd - pBegin);
        const size_type nCapacity = capacity();
        const size_type nNewSize = nOldSize + n;
        if(nNewSize > nCapacity)
        {
            const size_type nLength = GetNewCapacity(nCapacity, nNewSize - nCapacity);
            pointer pNewBegin = DoAllocate(nLength + 1);
            pointer pNewEnd = CharStringUninitializedCopy(internalLayout().BeginPtr(), internalLayout().EndPtr(), pNewBegin);
            pNewEnd         = CharStringUninitializedCopy(pBegin,  pEnd,  pNewEnd);
           *pNewEnd         = 0;
            DeallocateSelf();
            internalLayout().SetHeapBeginPtr(pNewBegin);
            internalLayout().SetHeapCapacity(nLength);
            internalLayout().SetHeapSize(nNewSize);
        }
        else
        {
            pointer pNewEnd = CharStringUninitializedCopy(pBegin, pEnd, internalLayout().EndPtr());
            *pNewEnd = 0;
            internalLayout().SetSize(nNewSize);
        }
    }
    return *this;
}

Add Discussion as Guest