first commit

extern/ustl/1.5/sostream.cc

@@ -0,0 +1,168 @@
+// This file is part of the uSTL library, an STL implementation.
+//
+// Copyright (c) 2005 by Mike Sharov <msharov@users.sourceforge.net>
+// This file is free software, distributed under the MIT License.
+
+#include "mistream.h"	// for istream_iterator, referenced in utf8.h
+#include "sostream.h"
+#include "ustring.h"
+#include "ulimits.h"
+#include <stdio.h>
+
+namespace ustl {
+
+/// Creates an output string stream linked to the given memory area.
+ostringstream::ostringstream (void* p, size_t n)
+: ostream (),
+  m_Buffer (),
+  m_Flags (0),
+  m_Width (0),
+  m_Base (10),
+  m_Precision (2)
+{
+    exceptions (goodbit);
+    link (p, n);
+}
+
+/// Creates an output string stream, initializing the buffer with v.
+ostringstream::ostringstream (const string& v)
+: ostream (),
+  m_Buffer (v),
+  m_Flags (0),
+  m_Width (0),
+  m_Base (10),
+  m_Precision (2)
+{
+    exceptions (goodbit);
+    ostream::link (m_Buffer);
+}
+
+/// Copies \p s to the internal buffer.
+void ostringstream::str (const string& s)
+{
+    m_Buffer = s;
+    ostream::link (m_Buffer);
+    SetPos (m_Buffer.size());
+}
+
+/// Writes a single character into the stream.
+void ostringstream::iwrite (uint8_t v)
+{
+    if (remaining() >= 1 || overflow() >= 1)
+	ostream::iwrite (v);
+}
+
+/// Writes the contents of \p buffer of \p size into the stream.
+ostringstream& ostringstream::write (const void* buffer, size_type sz)
+{
+    const char* buf = (const char*) buffer;
+    for (size_type bw = 0; (bw = min(sz, remaining() ? remaining() : overflow(sz))); buf += bw, sz -= bw)
+	ostream::write (buf, bw);
+    return (*this);
+}
+
+/// Simple decimal encoding of \p n into \p fmt.
+inline char* ostringstream::encode_dec (char* fmt, uint32_t n) const
+{
+    do {
+	*fmt++ = '0' + n % 10;
+    } while (n /= 10);
+    return (fmt);
+}
+
+/// Generates a sprintf format string for the given type.
+void ostringstream::fmtstring (char* fmt, const char* typestr, bool bInteger) const
+{
+    *fmt++ = '%';
+    if (m_Width)
+	fmt = encode_dec (fmt, m_Width);
+    if (m_Flags & left)
+	*fmt++ = '-';
+    if (!bInteger) {
+	*fmt++ = '.';
+	fmt = encode_dec (fmt, m_Precision);
+    }
+    while (*typestr)
+	*fmt++ = *typestr++;
+    if (bInteger) {
+	if (m_Base == 16)
+	    fmt[-1] = 'X';
+	else if (m_Base == 8)
+	    fmt[-1] = 'o';
+    } else {
+	if (m_Flags & scientific)
+	    fmt[-1] = 'E';
+    }
+    *fmt = 0;
+}
+
+/// Writes \p v into the stream as utf8
+void ostringstream::iwrite (wchar_t v)
+{
+    char buffer [8];
+    *utf8out(buffer) = v;
+    write (buffer, Utf8Bytes(v));
+}
+
+/// Writes value \p v into the stream as text.
+void ostringstream::iwrite (bool v)
+{
+    static const char tf[2][8] = { "false", "true" };
+    write (tf[v], 5 - v);
+}
+
+/// Equivalent to a vsprintf on the string.
+int ostringstream::vformat (const char* fmt, va_list args)
+{
+#if HAVE_VA_COPY
+    va_list args2;
+#else
+    #define args2 args
+    #undef __va_copy
+    #define __va_copy(x,y)
+#endif
+    size_t rv, space;
+    do {
+	space = remaining();
+	__va_copy (args2, args);
+	rv = vsnprintf (ipos(), space, fmt, args2);
+	if (ssize_t(rv) < 0)
+	    rv = space;
+    } while (rv >= space && rv < overflow(rv + 1));
+    SetPos (pos() + min (rv, space));
+    return (rv);
+}
+
+/// Equivalent to a sprintf on the string.
+int ostringstream::format (const char* fmt, ...)
+{
+    va_list args;
+    va_start (args, fmt);
+    const int rv = vformat (fmt, args);
+    va_end (args);
+    return (rv);
+}
+
+/// Links to string \p l as resizable.
+void ostringstream::link (void* p, size_type n)
+{
+    assert ((p || !n) && "The output string buffer must not be read-only");
+    ostream::link (p, n);
+    m_Buffer.link (p, n);
+}
+
+/// Attempts to create more output space. Returns remaining().
+ostringstream::size_type ostringstream::overflow (size_type n)
+{
+    if (n > remaining()) {
+	const uoff_t oldPos (pos());
+	m_Buffer.reserve (oldPos + n, false);
+	m_Buffer.resize (oldPos + n);
+	ostream::link (m_Buffer);
+	SetPos (oldPos);
+    }
+    verify_remaining ("write", "text", n);
+    return (remaining());
+}
+
+} // namespace ustl