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

 #ifndef BOOST_IOSTREAMS_INVERT_HPP_INCLUDED

 #define BOOST_IOSTREAMS_INVERT_HPP_INCLUDED

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

 # pragma once

 #endif              

 #include <algorithm>                             // copy, min.  

 #include <cassert>

 #include <boost/config.hpp>                      // BOOST_DEDUCED_TYPENAME.       

 #include <boost/detail/workaround.hpp>           // default_filter_buffer_size.

 #include <boost/iostreams/char_traits.hpp>

 #include <boost/iostreams/compose.hpp>

 #include <boost/iostreams/constants.hpp>

 #include <boost/iostreams/device/array.hpp>

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

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

 #include <boost/mpl/if.hpp>

 #include <boost/ref.hpp>

 #include <boost/shared_ptr.hpp>

 #include <boost/type_traits/is_convertible.hpp>

 // Must come last.

 #include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.

 namespace boost { namespace iostreams {

 //

 // Template name: inverse.

 // Template paramters:

 //      Filter - A filter adapter which 

 // Description: Returns an instance of an appropriate specialization of inverse.

 //

 template<typename Filter>

 class inverse {

 private:

     typedef typename category_of<Filter>::type   base_category;

     typedef reference_wrapper<Filter>            filter_ref;

 public:

     typedef typename char_type_of<Filter>::type  char_type;

     typedef typename int_type_of<Filter>::type   int_type;

     typedef char_traits<char_type>               traits_type;

     typedef typename 

             mpl::if_<

                 is_convertible<

                     base_category,

                     input

                 >,

                 output,

                 input

             >::type                              mode;

     struct category 

         : mode, 

           filter_tag, 

           multichar_tag, 

           closable_tag 

         { };

     explicit inverse( const Filter& filter, 

                       std::streamsize buffer_size = 

                           default_filter_buffer_size) 

         : pimpl_(new impl(filter, buffer_size))

         { }

     template<typename Source>

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

     {

         typedef detail::counted_array_sink<char_type>  array_sink;

         typedef composite<filter_ref, array_sink>      filtered_array_sink;

         assert((flags() & f_write) == 0);

         if (flags() == 0) {

             flags() = f_read;

             buf().set(0, 0);

         }

         filtered_array_sink snk(filter(), array_sink(s, n));

         int_type status;

         for ( status = traits_type::good();

               snk.second().count() < n && status == traits_type::good(); )

         {

             status = buf().fill(src);

             buf().flush(snk);

         }

         return snk.second().count() == 0 &&

                status == traits_type::eof() 

                    ? 

                -1

                    : 

                snk.second().count();

     }

     template<typename Sink>

     std::streamsize write(Sink& dest, const char* s, std::streamsize n)

     {

         typedef detail::counted_array_source<char_type>  array_source;

         typedef composite<filter_ref, array_source>      filtered_array_source;

         assert((flags() & f_read) == 0);

         if (flags() == 0) {

             flags() = f_write;

             buf().set(0, 0);

         }

         filtered_array_source src(filter(), array_source(s, n));

         for (bool good = true; src.second().count() < n && good; ) {

             buf().fill(src);

             good = buf().flush(dest);

         }

         return src.second().count();

     }

     template<typename Device>

     void close( Device& dev, 

                 BOOST_IOS::openmode which = 

                     BOOST_IOS::in | BOOST_IOS::out )

     {

         if ((which & BOOST_IOS::out) != 0 && (flags() & f_write) != 0)

             buf().flush(dev);

         flags() = 0;

     }

 private:

     filter_ref filter() { return boost::ref(pimpl_->filter_); }

     detail::buffer<char_type>& buf() { return pimpl_->buf_; }

     int& flags() { return pimpl_->flags_; }

     enum flags_ {

         f_read = 1, f_write = 2

     };

     struct impl {

         impl(const Filter& filter, std::streamsize n) 

             : filter_(filter), buf_(n), flags_(0)

         { buf_.set(0, 0); }

         Filter                     filter_;

         detail::buffer<char_type>  buf_;

         int                        flags_;

     };

     shared_ptr<impl> pimpl_;

 };

 //

 // Template name: invert.

 // Template paramters:

 //      Filter - A model of InputFilter or OutputFilter.

 // Description: Returns an instance of an appropriate specialization of inverse.

 //

 template<typename Filter>

 inverse<Filter> invert(const Filter& f) { return inverse<Filter>(f); }

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

 } } // End namespaces iostreams, boost.

 #include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.

 #endif // #ifndef BOOST_IOSTREAMS_INVERT_HPP_INCLUDED