1 files changed, 10 insertions, 9 deletions
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
index e77624b..7884ebe 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
@@ -1,66 +1,66 @@
 //
 // basic_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_BASIC_STREAMBUF_HPP
 #define BOOST_ASIO_BASIC_STREAMBUF_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <algorithm>
 #include <cstring>
 #include <stdexcept>
 #include <streambuf>
 #include <vector>
-#include <boost/limits.hpp>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Automatically resizable buffer class based on std::streambuf.
 /**
  * The @c basic_streambuf class is derived from @c std::streambuf to associate
  * the streambuf's input and output sequences with one or more character
  * arrays. These character arrays are internal to the @c basic_streambuf
  * object, but direct access to the array elements is provided to permit them
  * to be used efficiently with I/O operations. Characters written to the output
  * sequence of a @c basic_streambuf object are appended to the input sequence
  * of the same object.
  *
  * The @c basic_streambuf class's public interface is intended to permit the
  * following implementation strategies:
  *
  * @li A single contiguous character array, which is reallocated as necessary
  * to accommodate changes in the size of the character sequence. This is the
  * implementation approach currently used in Asio.
  *
  * @li A sequence of one or more character arrays, where each array is of the
  * same size. Additional character array objects are appended to the sequence
  * to accommodate changes in the size of the character sequence.
  *
  * @li A sequence of one or more character arrays of varying sizes. Additional
  * character array objects are appended to the sequence to accommodate changes
  * in the size of the character sequence.
  *
  * The constructor for basic_streambuf accepts a @c size_t argument specifying
  * the maximum of the sum of the sizes of the input sequence and output
  * sequence. During the lifetime of the @c basic_streambuf object, the following
  * invariant holds:
@@ -186,86 +186,87 @@ public:
           (pptr() - gptr()) * sizeof(char_type)));
   }
 
   /// Get a list of buffers that represents the output sequence, with the given
   /// size.
   /**
    * Ensures that the output sequence can accommodate @c n characters,
    * reallocating character array objects as necessary.
    *
    * @returns An object of type @c mutable_buffers_type that satisfies
    * MutableBufferSequence requirements, representing character array objects
    * at the start of the output sequence such that the sum of the buffer sizes
    * is @c n.
    *
    * @throws std::length_error If <tt>size() + n > max_size()</tt>.
    *
    * @note The returned object is invalidated by any @c basic_streambuf member
    * function that modifies the input sequence or output sequence.
    */
   mutable_buffers_type prepare(std::size_t n)
   {
     reserve(n);
     return boost::asio::buffer(boost::asio::mutable_buffer(
           pptr(), n * sizeof(char_type)));
   }
 
   /// Move characters from the output sequence to the input sequence.
   /**
    * Appends @c n characters from the start of the output sequence to the input
    * sequence. The beginning of the output sequence is advanced by @c n
    * characters.
    *
    * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
    * no intervening operations that modify the input or output sequence.
    *
-   * @throws std::length_error If @c n is greater than the size of the output
-   * sequence.
+   * @note If @c n is greater than the size of the output sequence, the entire
+   * output sequence is moved to the input sequence and no error is issued.
    */
   void commit(std::size_t n)
   {
     if (pptr() + n > epptr())
       n = epptr() - pptr();
     pbump(static_cast<int>(n));
     setg(eback(), gptr(), pptr());
   }
 
   /// Remove characters from the input sequence.
   /**
    * Removes @c n characters from the beginning of the input sequence.
    *
-   * @throws std::length_error If <tt>n > size()</tt>.
+   * @note If @c n is greater than the size of the input sequence, the entire
+   * input sequence is consumed and no error is issued.
    */
   void consume(std::size_t n)
   {
     if (egptr() < pptr())
       setg(&buffer_[0], gptr(), pptr());
     if (gptr() + n > pptr())
       n = pptr() - gptr();
     gbump(static_cast<int>(n));
   }
 
 protected:
   enum { buffer_delta = 128 };
 
   /// Override std::streambuf behaviour.
   /**
    * Behaves according to the specification of @c std::streambuf::underflow().
    */
   int_type underflow()
   {
     if (gptr() < pptr())
     {
       setg(&buffer_[0], gptr(), pptr());
       return traits_type::to_int_type(*gptr());
     }
     else
     {
       return traits_type::eof();
     }
   }
 
   /// Override std::streambuf behaviour.
   /**
    * Behaves according to the specification of @c std::streambuf::overflow(),
    * with the specialisation that @c std::length_error is thrown if appending
    * the character to the input sequence would require the condition
@@ -295,76 +296,76 @@ protected:
 
     return traits_type::not_eof(c);
   }
 
   void reserve(std::size_t n)
   {
     // Get current stream positions as offsets.
     std::size_t gnext = gptr() - &buffer_[0];
     std::size_t pnext = pptr() - &buffer_[0];
     std::size_t pend = epptr() - &buffer_[0];
 
     // Check if there is already enough space in the put area.
     if (n <= pend - pnext)
     {
       return;
     }
 
     // Shift existing contents of get area to start of buffer.
     if (gnext > 0)
     {
       pnext -= gnext;
       std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
     }
 
     // Ensure buffer is large enough to hold at least the specified size.
     if (n > pend - pnext)
     {
       if (n <= max_size_ && pnext <= max_size_ - n)
       {
         pend = pnext + n;
         buffer_.resize((std::max<std::size_t>)(pend, 1));
       }
       else
       {
         std::length_error ex("boost::asio::streambuf too long");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
     }
 
     // Update stream positions.
     setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
     setp(&buffer_[0] + pnext, &buffer_[0] + pend);
   }
 
 private:
   std::size_t max_size_;
   std::vector<char_type, Allocator> buffer_;
 
   // Helper function to get the preferred size for reading data.
   friend std::size_t read_size_helper(
       basic_streambuf& sb, std::size_t max_size)
   {
     return std::min<std::size_t>(
         std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
         std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
   }
 };
 
 // Helper function to get the preferred size for reading data. Used for any
 // user-provided specialisations of basic_streambuf.
 template <typename Allocator>
 inline std::size_t read_size_helper(
     basic_streambuf<Allocator>& sb, std::size_t max_size)
 {
   return std::min<std::size_t>(512,
       std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
 }
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_BASIC_STREAMBUF_HPP