// (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