UT_StringStreamImpl.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_StringStreamImpl.h ( UT Library, C++)
 *
 * COMMENTS:
 */


#ifndef __UT_StringStreamImpl__
#define __UT_StringStreamImpl__

#ifndef __UT_StringStream__
#error UT_StringStreamImpl.h should only be included by UT_StringStream.h
#endif

#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Math.h>
#include <limits>

inline
UT_StringStreamBuffer::UT_StringStreamBuffer(
    std::ios_base::openmode mode,
    const char *buf,
    exint len)
    : myGPos(-1), myPPos(-1)
{
    if(buf)
    {
        if(len >= 0)
            myBuffer.append(buf, len);
        else
            myBuffer.strcpy(buf);
    }
    else if(len > 0)
    {
        // +1 to avoid reallocating when adding a terminating null
        myBuffer.reserve(len + 1);
    }

    char *start = const_cast<char *>(buffer());
    if(mode & std::ios_base::in)
        setg64(start, start, start + length());
    else
        setg(nullptr, nullptr, nullptr);

    if(mode & std::ios_base::out)
    {
        setp64(start, start, start + length());
        updateppos(length());
    }
    else
        setp(nullptr, nullptr);
}

inline void
UT_StringStreamBuffer::reset()
{
    myBuffer.clear();
    init();
}

inline const UT_WorkBuffer &
UT_StringStreamBuffer::str()
{
    updateBufferEnd();
    return myBuffer;
}

inline void
UT_StringStreamBuffer::swap(UT_WorkBuffer &buf)
{
    updateBufferEnd();
    buf.swap(myBuffer);
    init();
}

inline void
UT_StringStreamBuffer::stealIntoString(UT_String &s)
{
    updateBufferEnd();
    myBuffer.stealIntoString(s);
    init();
}

inline void
UT_StringStreamBuffer::stealIntoStringHolder(UT_StringHolder &s)
{
    updateBufferEnd();
    s = std::move(myBuffer);
    init();
}

inline std::streambuf::pos_type
UT_StringStreamBuffer::seekoff(
    std::streambuf::off_type offset,
    std::ios_base::seekdir dir,
    std::ios_base::openmode mode)
{
    pos_type result(-1);
    if((mode & std::ios_base::in) && gptr())
    {
        exint pos;
        if(dir == std::ios_base::beg)
            pos = offset;
        else if(dir == std::ios_base::cur)
            pos = ((myGPos < 0) ? (gptr() - buffer()) : myGPos) + offset;
        else if(dir == std::ios_base::end)
            pos = length() + offset;
        else
            pos = -1;
        if(pos >= 0)
        {
            updategpos(pos);
            result = pos;
        }
    }
    if((mode & std::ios_base::out) && pptr())
    {
        exint pos;
        if(dir == std::ios_base::beg)
            pos = offset;
        else if(dir == std::ios_base::cur)
            pos = ((myPPos < 0) ? (pptr() - buffer()) : myPPos) + offset;
        else if(dir == std::ios_base::end)
            pos = length() + offset;
        else
            pos = -1;
        if(pos >= 0)
        {
            updateppos(pos);
            result = pos;
        }
    }
    return result;
}

inline std::streambuf::pos_type
UT_StringStreamBuffer::seekpos(
    std::streambuf::pos_type pos,
    std::ios_base::openmode mode)
{
    pos_type result(-1);
    if(pos >= 0)
    {
        if((mode & std::ios_base::in) && gptr())
        {
            updategpos(pos);
            result = pos;
        }
        if((mode & std::ios_base::out) && pptr())
        {
            updateppos(pos);
            result = pos;
        }
    }
    return result;
}

inline std::streambuf::int_type
UT_StringStreamBuffer::underflow()
{
    const char *cur = gptr();
    if(cur)
    {
        updategpos((myGPos < 0) ? (cur - buffer()) : myGPos);
        cur = gptr();
        if(cur < egptr())
            return *cur;
    }
    return traits_type::eof();
}

inline std::streamsize
UT_StringStreamBuffer::xsgetn(
    std::streambuf::char_type *dst,
    std::streamsize num)
{
    const char *cur = gptr();
    if(!cur)
        return traits_type::eof();

    if(myGPos < 0)
    {
        const char *start = buffer();
        exint pos = cur - start; 
        exint avail = length() - pos;
        if(num > avail)
            num = avail;
        if(num > 0)
        {
            ::memcpy(dst, start + pos, num);
            updategpos(pos + num);
            return num;
        }
    }
    return 0;
}

inline std::streamsize
UT_StringStreamBuffer::showmanyc()
{
    const char *cur = gptr();
    if(!cur)
        return traits_type::eof();

    if(myGPos < 0)
        return egptr() - cur;
    return 0;
}

inline std::streambuf::int_type
UT_StringStreamBuffer::pbackfail(std::streambuf::int_type c)
{
    const char *cur = gptr();
    if(cur)
    {
        const char *start = buffer();
        exint pos = ((myGPos < 0) ? (cur - start) : myGPos) - 1;
        if(pos >= 0 && pos < length() && start[pos] == c)
        {
            updategpos(pos);
            return c;
        }
    }
    return traits_type::eof();
}

inline std::streambuf::int_type
UT_StringStreamBuffer::overflow(int_type c)
{
    if(c != traits_type::eof())
    {
        char ch = char(c);
        if(xsputn(&ch, 1) > 0)
            return c;
    } 
    return traits_type::eof();
}

inline std::streamsize
UT_StringStreamBuffer::xsputn(
    const std::streambuf::char_type *src,
    std::streamsize num)
{
    const char *old_start = buffer();
    const char *cur_g = gptr();
    exint pos = (myPPos < 0) ? (pptr() - old_start) : myPPos;
    exint end = pos + num;
    exint old_len = length();
    exint len = old_len;
    if(end > old_len)
    {
        // +1 to avoid reallocating when adding a terminating null
        reserve(end + 1);
        len = end;
    }
    char *buf = myBuffer.lock(0, end);
    if(pos > old_len)
        ::memset(buf + old_len, 0, pos - old_len);
    ::memcpy(buf + pos, src, num);
    myBuffer.releaseSetLength(len);
    if(cur_g && end > old_len)
        updategpos((myGPos < 0) ? (cur_g - old_start) : myGPos);
    updateppos(pos + num);
    return num;
}

inline void
UT_StringStreamBuffer::init()
{
    char *start = const_cast<char*>(buffer());
    char *end = start + length();
    if(gptr())
    {
        myGPos = -1;
        setg64(start, start, end);
    }
    if(pptr())
    {
        myPPos = -1;
        setp64(start, end, end);
    }
}

namespace
{
    // Visual C++ streambuf implementation has a 32-bit limit.
    // We clamp the buffer size to stay within this limit.
    static inline void
    utClampBuf(char *&start, char *&cur, char *&end)
    {
        const exint size_limit = std::numeric_limits<int>::max();
        if(end - start <= size_limit)
            return;

        // reduce the buffer size
        // allow some backup room but keep cur within the buffer
        const exint backup_limit = 1024;
        if(cur - start > backup_limit)
        {
            start = cur - backup_limit;
            if(end - start <= size_limit)
                return;
        }
        end = start + size_limit;
    }
}

inline void
UT_StringStreamBuffer::setg64(char *start, char *cur, char *end)
{
    UT_ASSERT(start && cur && end && start <= cur && cur <= end);
    utClampBuf(start, cur, end);
    setg(start, cur, end);
}

inline void
UT_StringStreamBuffer::setp64(char *start, char *cur, char *end)
{
    UT_ASSERT(start && cur && end && start <= cur && cur <= end);
    utClampBuf(start, cur, end);
    setp(start, end);

    // The streambuf designers did the moronic thing and left gbump()/pbump()
    // with an int argument, thereby negating all benefits of using ptrdiff_t
    // for the streamsize, even on a 64-bit platform. Sigh.
    // Since utClampBuf limits the buffer size to std::numeric_limits<int>,
    // we can use pbump() once instead of bumping by increments until the
    // desired offset is reached.
    pbump(cur - start);
}

inline void
UT_StringStreamBuffer::updategpos(exint pos)
{
    UT_ASSERT(gptr() && pos >= 0);
    char *start = const_cast<char*>(buffer());
    if(pos > length())
    {
        myGPos = pos;
        setg64(start, start, start);
    }
    else
    {
        myGPos = -1;
        setg64(start, start + pos, start + length());
    }
}

inline void
UT_StringStreamBuffer::updateppos(exint pos)
{
    UT_ASSERT(pptr() && pos >= 0);
    char *start = const_cast<char*>(buffer());
    if(pos > length())
    {
        myPPos = pos;
        setp64(start, start, start);
    }
    else
    {
        myPPos = -1;
        setp64(start, start + pos, start + length());
    }
}

// Taken from UTbumpAlloc but with modifications to suit UT_WorkBuffer
// and minimize allocations for large writes.
namespace
{
    static inline exint
    utBumpAlloc(exint current_size)
    {
        static exint big_alloc_threshold = 1024 * 1024;
        exint bump;

        // Less than the static buffer, leave as-is until exhausted and we move
        // to heap storage.
        if (current_size < UT_INITIAL_BUFFER_SIZE)
            return current_size;

        // Less than a page, go up to a page.
        if (current_size < 4096)
            return 4096;

        // As the buffer get bigger, we make larger allocations, assuming that
        // we're racing to write data, at which point the writes become
        // more and more time-critical.
        if (current_size < big_alloc_threshold)
            bump = current_size / 8;
        else if (current_size < big_alloc_threshold * 8)
            bump = current_size / 4;
        else
            bump = current_size / 2;

        current_size += bump;
        return current_size;
    }
}

inline void
UT_StringStreamBuffer::reserve(exint bytes)
{
    exint a = myBuffer.getAllocatedSize();
    if(bytes > a)
    {
        const char *old_start = buffer();
        const char *cur_g = gptr();
        const char *cur_p = pptr();
        myBuffer.reserve(SYSmax(bytes, utBumpAlloc(a)));
        if(cur_g)
            updategpos((myGPos < 0) ? (cur_g - old_start) : myGPos);
        if(cur_p)
            updateppos((myPPos < 0) ? (cur_p - old_start) : myPPos);
    }
}

inline void
UT_StringStreamBuffer::updateBufferEnd()
{
#if 0
    if(pptr())
    {
        exint len = length();
        reserve(len + 1); // to ensure lock() doesn't reallocate!
        (void) myBuffer.lock(0, len);
        myBuffer.releaseSetLength(len); // just to force null termination
    }
#endif
}

#endif // UT_StringStreamImpl