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

 // To do: add support for random-access.

 #ifndef BOOST_IOSTREAMS_COMBINE_HPP_INCLUDED

 #define BOOST_IOSTREAMS_COMBINE_HPP_INCLUDED

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

 # pragma once

 #endif              

 #include <boost/config.hpp> // NO_STD_LOCALE, DEDUCED_TYPENAME.

 #ifndef BOOST_NO_STD_LOCALE

 # include <locale>

 #endif

 #include <boost/iostreams/detail/ios.hpp>   

 #include <boost/iostreams/detail/wrap_unwrap.hpp>       

 #include <boost/iostreams/traits.hpp>         

 #include <boost/iostreams/operations.hpp>        

 #include <boost/mpl/if.hpp>    

 #include <boost/static_assert.hpp>  

 #include <boost/type_traits/is_convertible.hpp>

 #include <boost/type_traits/is_same.hpp> 

 namespace boost { namespace iostreams {

 namespace detail {

 //

 // Template name: combined_device.

 // Description: Model of Device defined in terms of a Source/Sink pair.

 // Template paramters:

 //      Source - A model of Source, with the same char_type and traits_type

 //          as Sink.

 //      Sink - A model of Sink, with the same char_type and traits_type

 //          as Source.

 //

 template<typename Source, typename Sink>

 class combined_device {

 public:

     typedef typename char_type_of<Source>::type char_type;

     struct category

         : bidirectional, 

           device_tag, 

           closable_tag, 

           localizable_tag

         { };

     combined_device(const Source& src, const Sink& snk);

     std::streamsize read(char_type* s, std::streamsize n);

     std::streamsize write(const char_type* s, std::streamsize n);

     void close(BOOST_IOS::openmode);

     #ifndef BOOST_NO_STD_LOCALE

         void imbue(const std::locale& loc);

     #endif

 private:

     typedef typename char_type_of<Sink>::type sink_char_type;

     BOOST_STATIC_ASSERT((is_same<char_type, sink_char_type>::value));

     Source  src_;

     Sink    sink_;

 };

 //

 // Template name: combined_filter.

 // Description: Model of Device defined in terms of a Source/Sink pair.

 // Template paramters:

 //      InputFilter - A model of InputFilter, with the same char_type as 

 //          OutputFilter.

 //      OutputFilter - A model of OutputFilter, with the same char_type as 

 //          InputFilter.

 //

 template<typename InputFilter, typename OutputFilter>

 class combined_filter {

 private:

     typedef typename category_of<InputFilter>::type    in_category;

     typedef typename category_of<OutputFilter>::type   out_category;

 public:

     typedef typename char_type_of<InputFilter>::type   char_type;

     struct category 

         : multichar_bidirectional_filter_tag,

           closable_tag, 

           localizable_tag

         { };

     combined_filter(const InputFilter& in, const OutputFilter& out);

     template<typename Source>

     std::streamsize read(Source& src, char_type* s, std::streamsize n)

     { return boost::iostreams::read(in_, src, s, n); }

     template<typename Sink>

     std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)

     { return boost::iostreams::write(out_, snk, s, n); }

     template<typename Sink>

     void close(Sink& snk, BOOST_IOS::openmode which)

         {

             if (which & BOOST_IOS::in)

                 iostreams::close(in_, snk, which);

             if (which & BOOST_IOS::out)

                 iostreams::close(out_, snk, which);

         }

     #ifndef BOOST_NO_STD_LOCALE

         void imbue(const std::locale& loc);

     #endif

 private:

     typedef typename char_type_of<OutputFilter>::type  output_char_type;

     BOOST_STATIC_ASSERT((is_same<char_type, output_char_type>::value));

     InputFilter   in_;

     OutputFilter  out_;

 };

 template<typename In, typename Out>

 struct combination_traits 

     : mpl::if_<

           is_device<In>,

           combined_device<

               typename wrapped_type<In>::type,

               typename wrapped_type<Out>::type

           >,

           combined_filter<

               typename wrapped_type<In>::type,

               typename wrapped_type<Out>::type

           >

       >

     { };

 } // End namespace detail.

 template<typename In, typename Out>

 struct combination : detail::combination_traits<In, Out>::type {

     typedef typename detail::combination_traits<In, Out>::type  base_type;

     typedef typename detail::wrapped_type<In>::type          in_type;

     typedef typename detail::wrapped_type<Out>::type         out_type;

     combination(const in_type& in, const out_type& out)

         : base_type(in, out) { }

 };

 namespace detail {

 // Workaround for VC6 ETI bug.

 template<typename In, typename Out>

 struct combine_traits {

     typedef combination<

                 BOOST_DEDUCED_TYPENAME detail::unwrapped_type<In>::type, 

                 BOOST_DEDUCED_TYPENAME detail::unwrapped_type<Out>::type

             > type;

 };

 } // End namespace detail.

 //

 // Template name: combine.

 // Description: Takes a Source/Sink pair or InputFilter/OutputFilter pair and

 //      returns a Reource or Filter which performs input using the first member

 //      of the pair and output using the second member of the pair.

 // Template paramters:

 //      In - A model of Source or InputFilter, with the same char_type as Out.

 //      Out - A model of Sink or OutputFilter, with the same char_type as In.

 //

 template<typename In, typename Out>

 typename detail::combine_traits<In, Out>::type

 combine(const In& in, const Out& out) 

 { 

     typedef typename detail::combine_traits<In, Out>::type return_type;

     return return_type(in, out); 

 }

 //----------------------------------------------------------------------------//

 namespace detail {

 //--------------Implementation of combined_device-----------------------------//

 template<typename Source, typename Sink>

 inline combined_device<Source, Sink>::combined_device

     (const Source& src, const Sink& snk)

     : src_(src), sink_(snk) { }

 template<typename Source, typename Sink>

 inline std::streamsize

 combined_device<Source, Sink>::read(char_type* s, std::streamsize n)

 { return iostreams::read(src_, s, n); }

 template<typename Source, typename Sink>

 inline std::streamsize

 combined_device<Source, Sink>::write(const char_type* s, std::streamsize n)

 { return iostreams::write(sink_, s, n); }

 template<typename Source, typename Sink>

 inline void

 combined_device<Source, Sink>::close(BOOST_IOS::openmode which)

 { 

     if (which & BOOST_IOS::in)

         iostreams::close(src_, which); 

     if (which & BOOST_IOS::out)

         iostreams::close(sink_, which); 

 }

 #ifndef BOOST_NO_STD_LOCALE

     template<typename Source, typename Sink>

     void combined_device<Source, Sink>::imbue(const std::locale& loc)

     {

         iostreams::imbue(src_, loc);

         iostreams::imbue(sink_, loc);

     }

 #endif

 //--------------Implementation of filter_pair---------------------------------//

 template<typename InputFilter, typename OutputFilter>

 inline combined_filter<InputFilter, OutputFilter>::combined_filter

     (const InputFilter& in, const OutputFilter& out) : in_(in), out_(out)

     { }

 #ifndef BOOST_NO_STD_LOCALE

     template<typename InputFilter, typename OutputFilter>

     void combined_filter<InputFilter, OutputFilter>::imbue

         (const std::locale& loc)

     {

         iostreams::imbue(in_, loc);

         iostreams::imbue(out_, loc);

     }

 #endif

 } // End namespace detail.

 } } // End namespaces iostreams, boost.

 #endif // #ifndef BOOST_IOSTREAMS_COMBINE_HPP_INCLUDED