--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/iostreams/copy.hpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,198 @@
+// (C) Copyright Jonathan Turkanis 2003.
+// 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.)
+
+// See http://www.boost.org/libs/iostreams for documentation.
+
+// Contains: The function template copy, which reads data from a Source
+// and writes it to a Sink until the end of the sequence is reached, returning
+// the number of characters transfered.
+
+// The implementation is complicated by the need to handle smart adapters
+// and direct devices.
+
+#ifndef BOOST_IOSTREAMS_COPY_HPP_INCLUDED
+#define BOOST_IOSTREAMS_COPY_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <algorithm> // copy.
+#include <utility> // pair.
+#include <boost/detail/workaround.hpp>
+#include <boost/iostreams/chain.hpp>
+#include <boost/iostreams/constants.hpp>
+#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
+#include <boost/iostreams/detail/buffer.hpp>
+#include <boost/iostreams/detail/closer.hpp>
+#include <boost/iostreams/detail/enable_if_stream.hpp>
+#include <boost/iostreams/detail/ios.hpp> // failure, streamsize.
+#include <boost/iostreams/detail/resolve.hpp>
+#include <boost/iostreams/detail/wrap_unwrap.hpp>
+#include <boost/iostreams/operations.hpp> // read, write, close.
+#include <boost/iostreams/pipeline.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace iostreams {
+
+namespace detail {
+
+template<typename Source, typename Sink>
+std::streamsize copy_impl( Source& src, Sink& snk,
+ std::streamsize /* buffer_size */,
+ mpl::true_, mpl::true_ )
+{ // Copy from a direct Source to a direct Sink.
+ using namespace std;
+ typedef typename char_type_of<Source>::type char_type;
+ typedef pair<char_type*, char_type*> pair_type;
+ pair_type p1 = iostreams::input_sequence(src);
+ pair_type p2 = iostreams::output_sequence(snk);
+ if (p1.second - p1.first < p2.second - p2.first) {
+ std::copy(p1.first, p1.second, p2.first);
+ return static_cast<streamsize>(p1.second - p1.first);
+ } else {
+ throw BOOST_IOSTREAMS_FAILURE("destination too small");
+ }
+}
+
+template<typename Source, typename Sink>
+std::streamsize copy_impl( Source& src, Sink& snk,
+ std::streamsize /* buffer_size */,
+ mpl::true_, mpl::false_ )
+{ // Copy from a direct Source to an indirect Sink.
+ using namespace std;
+ typedef typename char_type_of<Source>::type char_type;
+ typedef pair<char_type*, char_type*> pair_type;
+ pair_type p = iostreams::input_sequence(src);
+ std::streamsize size, total;
+ for ( total = 0, size = static_cast<streamsize>(p.second - p.first);
+ total < size; )
+ {
+ std::streamsize amt =
+ iostreams::write(snk, p.first + total, size - total);
+ total += amt;
+ }
+ return size;
+}
+
+template<typename Source, typename Sink>
+std::streamsize copy_impl( Source& src, Sink& snk,
+ std::streamsize buffer_size,
+ mpl::false_, mpl::true_ )
+{ // Copy from an indirect Source to a direct Sink.
+ using namespace std;
+ typedef typename char_type_of<Source>::type char_type;
+ typedef pair<char_type*, char_type*> pair_type;
+ detail::basic_buffer<char_type> buf(buffer_size);
+ pair_type p = snk.output_sequence();
+ streamsize total = 0;
+ bool done = false;
+ while (!done) {
+ streamsize amt;
+ done = (amt = iostreams::read(src, buf.data(), buffer_size)) == -1;
+ std::copy(buf.data(), buf.data() + amt, p.first + total);
+ if (amt != -1)
+ total += amt;
+ }
+ return total;
+}
+
+template<typename Source, typename Sink>
+std::streamsize copy_impl( Source& src, Sink& snk,
+ std::streamsize buffer_size,
+ mpl::false_, mpl::false_ )
+{ // Copy from an indirect Source to a indirect Sink. This algorithm
+ // can be improved by eliminating the non_blocking_adapter.
+ typedef typename char_type_of<Source>::type char_type;
+ detail::basic_buffer<char_type> buf(buffer_size);
+ non_blocking_adapter<Sink> nb(snk);
+ std::streamsize total = 0;
+ bool done = false;
+ while (!done) {
+ std::streamsize amt;
+ done = (amt = iostreams::read(src, buf.data(), buffer_size)) == -1;
+ if (amt != -1) {
+ iostreams::write(nb, buf.data(), amt);
+ total += amt;
+ }
+ }
+ return total;
+}
+
+template<typename Source, typename Sink>
+std::streamsize copy_impl(Source src, Sink snk, std::streamsize buffer_size)
+{
+ using namespace std;
+ typedef typename char_type_of<Source>::type src_char;
+ typedef typename char_type_of<Sink>::type snk_char;
+ BOOST_STATIC_ASSERT((is_same<src_char, snk_char>::value));
+ bool nothrow = false;
+ external_closer<Source> close_source(src, BOOST_IOS::in, nothrow);
+ external_closer<Sink> close_sink(snk, BOOST_IOS::out, nothrow);
+ streamsize result =
+ copy_impl( src, snk, buffer_size,
+ is_direct<Source>(), is_direct<Sink>() );
+ return result;
+}
+
+} // End namespace detail.
+
+//------------------Definition of copy----------------------------------------//
+
+template<typename Source, typename Sink>
+std::streamsize
+copy( const Source& src, const Sink& snk,
+ std::streamsize buffer_size = default_device_buffer_size
+ BOOST_IOSTREAMS_DISABLE_IF_STREAM(Source)
+ BOOST_IOSTREAMS_DISABLE_IF_STREAM(Sink) )
+{
+ typedef typename char_type_of<Source>::type char_type;
+ return detail::copy_impl( detail::resolve<input, char_type>(src),
+ detail::resolve<output, char_type>(snk),
+ buffer_size );
+}
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
+
+template<typename Source, typename Sink>
+std::streamsize
+copy( Source& src, const Sink& snk,
+ std::streamsize buffer_size = default_device_buffer_size
+ BOOST_IOSTREAMS_ENABLE_IF_STREAM(Source)
+ BOOST_IOSTREAMS_DISABLE_IF_STREAM(Sink) )
+{
+ typedef typename char_type_of<Source>::type char_type;
+ return detail::copy_impl( detail::wrap(src),
+ detail::resolve<output, char_type>(snk),
+ buffer_size );
+}
+
+template<typename Source, typename Sink>
+std::streamsize
+copy( const Source& src, Sink& snk,
+ std::streamsize buffer_size = default_device_buffer_size
+ BOOST_IOSTREAMS_DISABLE_IF_STREAM(Source)
+ BOOST_IOSTREAMS_ENABLE_IF_STREAM(Sink) )
+{
+ typedef typename char_type_of<Source>::type char_type;
+ return detail::copy_impl( detail::resolve<input, char_type>(src),
+ detail::wrap(snk), buffer_size);
+}
+
+template<typename Source, typename Sink>
+std::streamsize
+copy( Source& src, Sink& snk,
+ std::streamsize buffer_size = default_device_buffer_size
+ BOOST_IOSTREAMS_ENABLE_IF_STREAM(Source)
+ BOOST_IOSTREAMS_ENABLE_IF_STREAM(Sink) )
+{
+ return detail::copy_impl(detail::wrap(src), detail::wrap(snk), buffer_size);
+}
+
+#endif // #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //-----------------------//
+
+} } // End namespaces iostreams, boost.
+
+#endif // #ifndef BOOST_IOSTREAMS_COPY_HPP_INCLUDED