comparison DEPENDENCIES/generic/include/boost/log/detail/attachable_sstream_buf.hpp @ 16:2665513ce2d3

Add boost headers

+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   attachable_sstream_buf.hpp
+ * \author Andrey Semashev
+ * \date   29.07.2007
+ *
+ * \brief  This header is the Boost.Log library implementation, see the library documentation
+ *         at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html.
+ */
+
+#ifndef BOOST_LOG_ATTACHABLE_SSTREAM_BUF_HPP_INCLUDED_
+#define BOOST_LOG_ATTACHABLE_SSTREAM_BUF_HPP_INCLUDED_
+
+#include <memory>
+#include <string>
+#include <streambuf>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/log/detail/config.hpp>
+#include <boost/log/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+BOOST_LOG_OPEN_NAMESPACE
+
+namespace aux {
+
+//! A streambuf that puts the formatted data to an external string
+template<
+    typename CharT,
+    typename TraitsT = std::char_traits< CharT >,
+    typename AllocatorT = std::allocator< CharT >
+>
+class basic_ostringstreambuf :
+    public std::basic_streambuf< CharT, TraitsT >
+{
+    //! Self type
+    typedef basic_ostringstreambuf< CharT, TraitsT, AllocatorT > this_type;
+    //! Base type
+    typedef std::basic_streambuf< CharT, TraitsT > base_type;
+
+    //! Buffer size
+    enum { buffer_size = 16 };
+
+public:
+    //! Character type
+    typedef typename base_type::char_type char_type;
+    //! Traits type
+    typedef typename base_type::traits_type traits_type;
+    //! String type
+    typedef std::basic_string< char_type, traits_type, AllocatorT > string_type;
+    //! Int type
+    typedef typename base_type::int_type int_type;
+
+private:
+    //! A reference to the string that will be filled
+    string_type* m_Storage;
+    //! A buffer used to temporarily store output
+    char_type m_Buffer[buffer_size];
+
+public:
+    //! Constructor
+    explicit basic_ostringstreambuf() : m_Storage(0)
+    {
+        base_type::setp(m_Buffer, m_Buffer + (sizeof(m_Buffer) / sizeof(*m_Buffer)));
+    }
+    //! Constructor
+    explicit basic_ostringstreambuf(string_type& storage) : m_Storage(boost::addressof(storage))
+    {
+        base_type::setp(m_Buffer, m_Buffer + (sizeof(m_Buffer) / sizeof(*m_Buffer)));
+    }
+
+    //! Clears the buffer to the initial state
+    void clear()
+    {
+        register char_type* pBase = this->pbase();
+        register char_type* pPtr = this->pptr();
+        if (pBase != pPtr)
+            this->pbump(static_cast< int >(pBase - pPtr));
+    }
+
+    //! Detaches the buffer from the string
+    void detach()
+    {
+        if (m_Storage)
+        {
+            this_type::sync();
+            m_Storage = 0;
+        }
+    }
+
+    //! Attaches the buffer to another string
+    void attach(string_type& storage)
+    {
+        detach();
+        m_Storage = boost::addressof(storage);
+    }
+
+    //! Returns a pointer to the attached string
+    string_type* storage() const { return m_Storage; }
+
+protected:
+    //! Puts all buffered data to the string
+    int sync()
+    {
+        BOOST_ASSERT(m_Storage != 0);
+        register char_type* pBase = this->pbase();
+        register char_type* pPtr = this->pptr();
+        if (pBase != pPtr)
+        {
+            m_Storage->append(pBase, pPtr);
+            this->pbump(static_cast< int >(pBase - pPtr));
+        }
+        return 0;
+    }
+    //! Puts an unbuffered character to the string
+    int_type overflow(int_type c)
+    {
+        BOOST_ASSERT(m_Storage != 0);
+        basic_ostringstreambuf::sync();
+        if (!traits_type::eq_int_type(c, traits_type::eof()))
+        {
+            m_Storage->push_back(traits_type::to_char_type(c));
+            return c;
+        }
+        else
+            return traits_type::not_eof(c);
+    }
+    //! Puts a character sequence to the string
+    std::streamsize xsputn(const char_type* s, std::streamsize n)
+    {
+        BOOST_ASSERT(m_Storage != 0);
+        basic_ostringstreambuf::sync();
+        typedef typename string_type::size_type string_size_type;
+        register const string_size_type max_storage_left =
+            m_Storage->max_size() - m_Storage->size();
+        if (static_cast< string_size_type >(n) < max_storage_left)
+        {
+            m_Storage->append(s, static_cast< string_size_type >(n));
+            return n;
+        }
+        else
+        {
+            m_Storage->append(s, max_storage_left);
+            return static_cast< std::streamsize >(max_storage_left);
+        }
+    }
+
+    //! Copy constructor (closed)
+    BOOST_DELETED_FUNCTION(basic_ostringstreambuf(basic_ostringstreambuf const& that))
+    //! Assignment (closed)
+    BOOST_DELETED_FUNCTION(basic_ostringstreambuf& operator= (basic_ostringstreambuf const& that))
+};
+
+} // namespace aux
+
+BOOST_LOG_CLOSE_NAMESPACE // namespace log
+
+} // namespace boost
+
+#include <boost/log/detail/footer.hpp>
+
+#endif // BOOST_LOG_ATTACHABLE_SSTREAM_BUF_HPP_INCLUDED_