sl@0: // (C) Copyright Jonathan Turkanis 2003.
sl@0: // Distributed under the Boost Software License, Version 1.0. (See accompanying
sl@0: // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
sl@0: 
sl@0: // See http://www.boost.org/libs/iostreams for documentation.
sl@0: 
sl@0: // Contains machinery for performing code conversion.
sl@0: 
sl@0: #ifndef BOOST_IOSTREAMS_CODE_CONVERTER_HPP_INCLUDED
sl@0: #define BOOST_IOSTREAMS_CODE_CONVERTER_HPP_INCLUDED
sl@0: 
sl@0: #if defined(_MSC_VER) && (_MSC_VER >= 1020)
sl@0: # pragma once
sl@0: #endif
sl@0: 
sl@0: #include <boost/iostreams/detail/config/wide_streams.hpp>
sl@0: #if defined(BOOST_IOSTREAMS_NO_WIDE_STREAMS) || \
sl@0:     defined(BOOST_IOSTREAMS_NO_LOCALE) \
sl@0:     /**/
sl@0: # error code conversion not supported on this platform
sl@0: #endif
sl@0: 
sl@0: #include <algorithm>                       // max.
sl@0: #include <cstring>                         // memcpy.
sl@0: #include <exception>
sl@0: #include <boost/config.hpp>                // DEDUCED_TYPENAME.
sl@0: #include <boost/iostreams/char_traits.hpp>
sl@0: #include <boost/iostreams/constants.hpp>   // default_filter_buffer_size.
sl@0: #include <boost/iostreams/detail/adapter/concept_adapter.hpp>
sl@0: #include <boost/iostreams/detail/adapter/direct_adapter.hpp>
sl@0: #include <boost/iostreams/detail/buffer.hpp>
sl@0: #include <boost/iostreams/detail/call_traits.hpp>
sl@0: #include <boost/iostreams/detail/codecvt_holder.hpp>
sl@0: #include <boost/iostreams/detail/codecvt_helper.hpp>
sl@0: #include <boost/iostreams/detail/double_object.hpp>
sl@0: #include <boost/iostreams/detail/forward.hpp>
sl@0: #include <boost/iostreams/detail/ios.hpp> // failure, openmode, int types.
sl@0: #include <boost/iostreams/detail/select.hpp>
sl@0: #include <boost/iostreams/traits.hpp>
sl@0: #include <boost/iostreams/operations.hpp>
sl@0: #include <boost/optional.hpp>
sl@0: #include <boost/shared_ptr.hpp>
sl@0: #include <boost/static_assert.hpp>
sl@0: #include <boost/type_traits/is_convertible.hpp>
sl@0: #include <boost/type_traits/is_same.hpp>
sl@0: 
sl@0: // Must come last.
sl@0: #include <boost/iostreams/detail/config/disable_warnings.hpp> // Borland 5.x
sl@0: 
sl@0: namespace boost { namespace iostreams {
sl@0: 
sl@0: struct code_conversion_error : BOOST_IOSTREAMS_FAILURE {
sl@0:     code_conversion_error() 
sl@0:         : BOOST_IOSTREAMS_FAILURE("code conversion error")
sl@0:         { }
sl@0: };
sl@0: 
sl@0: namespace detail {
sl@0: 
sl@0: //--------------Definition of conversion_buffer-------------------------------//
sl@0: 
sl@0: // Buffer and conversion state for reading.
sl@0: template<typename Codecvt, typename Alloc>
sl@0: class conversion_buffer 
sl@0:     : public buffer<
sl@0:                  BOOST_DEDUCED_TYPENAME detail::codecvt_extern<Codecvt>::type,
sl@0:                  Alloc
sl@0:              > 
sl@0: {
sl@0: public:
sl@0:     typedef typename Codecvt::state_type state_type;
sl@0:     conversion_buffer() 
sl@0:         : buffer<
sl@0:               BOOST_DEDUCED_TYPENAME detail::codecvt_extern<Codecvt>::type,
sl@0:               Alloc
sl@0:           >(0) 
sl@0:     { 
sl@0:         reset(); 
sl@0:     }
sl@0:     state_type& state() { return state_; }
sl@0:     void reset() 
sl@0:     { 
sl@0:         if (this->size()) 
sl@0:             this->set(0, 0);
sl@0:         state_ = state_type(); 
sl@0:     }
sl@0: private:
sl@0:     state_type state_;
sl@0: };
sl@0: 
sl@0: //--------------Definition of converter_impl----------------------------------//
sl@0: 
sl@0: // Contains member data, open/is_open/close and buffer management functions.
sl@0: template<typename Device, typename Codecvt, typename Alloc>
sl@0: struct code_converter_impl {
sl@0:     typedef typename codecvt_extern<Codecvt>::type          extern_type;
sl@0:     typedef typename category_of<Device>::type              device_category;
sl@0:     typedef is_convertible<device_category, input>          can_read;
sl@0:     typedef is_convertible<device_category, output>         can_write;
sl@0:     typedef is_convertible<device_category, bidirectional>  is_bidir;
sl@0:     typedef typename 
sl@0:             iostreams::select<  // Disambiguation for Tru64.
sl@0:                 is_bidir, bidirectional,
sl@0:                 can_read, input,
sl@0:                 can_write, output
sl@0:             >::type                                         mode;      
sl@0:     typedef typename
sl@0:             mpl::if_<
sl@0:                 is_direct<Device>,
sl@0:                 direct_adapter<Device>,
sl@0:                 Device
sl@0:             >::type                                         policy_type;
sl@0:     typedef optional< concept_adapter<policy_type> >        storage_type;
sl@0:     typedef is_convertible<device_category, two_sequence>   is_double;
sl@0:     typedef conversion_buffer<Codecvt, Alloc>               buffer_type;
sl@0: 
sl@0:     code_converter_impl() : cvt_(), flags_(0) { }
sl@0: 
sl@0:     ~code_converter_impl()
sl@0:     { 
sl@0:         try { 
sl@0:             if (flags_ & f_open) close(); 
sl@0:         } catch (std::exception&) { /* */ } 
sl@0:     }
sl@0: 
sl@0:     void open(const Device& dev, int buffer_size)
sl@0:     {
sl@0:         if (flags_ & f_open)
sl@0:             throw BOOST_IOSTREAMS_FAILURE("already open");
sl@0:         if (buffer_size == -1)
sl@0:             buffer_size = default_filter_buffer_size;
sl@0:         int max_length = cvt_.get().max_length();
sl@0:         buffer_size = (std::max)(buffer_size, 2 * max_length);
sl@0:         if (can_read::value) {
sl@0:             buf_.first().resize(buffer_size);
sl@0:             buf_.first().set(0, 0);
sl@0:         }
sl@0:         if (can_write::value && !is_double::value) {
sl@0:             buf_.second().resize(buffer_size);
sl@0:             buf_.second().set(0, 0);
sl@0:         }
sl@0:         dev_.reset(concept_adapter<policy_type>(dev));
sl@0:         flags_ |= f_open;
sl@0:     }
sl@0: 
sl@0:     void close(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out)
sl@0:     {
sl@0:         if (which & BOOST_IOS::in) {
sl@0:             iostreams::close(dev(), BOOST_IOS::in);
sl@0:             flags_ |= f_input_closed;
sl@0:         }
sl@0:         if (which & BOOST_IOS::out) {
sl@0:             buf_.second().flush(dev());
sl@0:             iostreams::close(dev(), BOOST_IOS::out);
sl@0:             flags_ |= f_output_closed;
sl@0:         }
sl@0:         if ( !is_double::value || 
sl@0:              (flags_ & f_input_closed) != 0 && 
sl@0:              (flags_ & f_output_closed) != 0 )
sl@0:         {
sl@0:             dev_.reset();
sl@0:             buf_.first().reset();
sl@0:             buf_.second().reset();
sl@0:             flags_ = 0;
sl@0:         }
sl@0:     }
sl@0: 
sl@0:     bool is_open() const { return (flags_ & f_open) != 0;}
sl@0: 
sl@0:     policy_type& dev() { return **dev_; }
sl@0: 
sl@0:     enum {
sl@0:         f_open             = 1,
sl@0:         f_input_closed     = f_open << 1,
sl@0:         f_output_closed    = f_input_closed << 1
sl@0:     };
sl@0: 
sl@0:     codecvt_holder<Codecvt>  cvt_;
sl@0:     storage_type             dev_;
sl@0:     double_object<
sl@0:         buffer_type, 
sl@0:         is_double
sl@0:     >                        buf_;
sl@0:     int                      flags_;
sl@0: };
sl@0: 
sl@0: } // End namespace detail.
sl@0: 
sl@0: //--------------Definition of converter---------------------------------------//
sl@0: 
sl@0: #define BOOST_IOSTREAMS_CONVERTER_PARAMS() , int buffer_size = -1
sl@0: #define BOOST_IOSTREAMS_CONVERTER_ARGS() , buffer_size
sl@0: 
sl@0: template<typename Device, typename Codecvt, typename Alloc>
sl@0: struct code_converter_base {
sl@0:     typedef detail::code_converter_impl<
sl@0:                 Device, Codecvt, Alloc
sl@0:             > impl_type;
sl@0:     code_converter_base() : pimpl_(new impl_type) { }
sl@0:     shared_ptr<impl_type> pimpl_;
sl@0: };
sl@0: 
sl@0: template< typename Device, 
sl@0:           typename Codecvt = detail::default_codecvt, 
sl@0:           typename Alloc = std::allocator<char> >
sl@0: class code_converter 
sl@0:     : protected code_converter_base<Device, Codecvt, Alloc>
sl@0: {
sl@0: private:
sl@0:     typedef detail::code_converter_impl<
sl@0:                 Device, Codecvt, Alloc
sl@0:             >                                                       impl_type;
sl@0:     typedef typename impl_type::policy_type                         policy_type;
sl@0:     typedef typename impl_type::buffer_type                         buffer_type;
sl@0:     typedef typename detail::codecvt_holder<Codecvt>::codecvt_type  codecvt_type;
sl@0:     typedef typename detail::codecvt_intern<Codecvt>::type          intern_type;
sl@0:     typedef typename detail::codecvt_extern<Codecvt>::type          extern_type;
sl@0:     typedef typename detail::codecvt_state<Codecvt>::type           state_type;
sl@0: public:
sl@0:     typedef intern_type                                             char_type;    
sl@0:     struct category 
sl@0:         : impl_type::mode, device_tag, closable_tag, localizable_tag
sl@0:         { };
sl@0:     BOOST_STATIC_ASSERT((
sl@0:         is_same<
sl@0:             extern_type, 
sl@0:             BOOST_DEDUCED_TYPENAME char_type_of<Device>::type
sl@0:         >::value
sl@0:     ));
sl@0: public:
sl@0:     code_converter() { }
sl@0: #if BOOST_WORKAROUND(__GNUC__, < 3)
sl@0:     code_converter(code_converter& rhs) 
sl@0:         : code_converter_base<Device, Codecvt, Alloc>(rhs)
sl@0:         { }
sl@0:     code_converter(const code_converter& rhs) 
sl@0:         : code_converter_base<Device, Codecvt, Alloc>(rhs)
sl@0:         { }
sl@0: #endif
sl@0:     BOOST_IOSTREAMS_FORWARD( code_converter, open_impl, Device,
sl@0:                              BOOST_IOSTREAMS_CONVERTER_PARAMS, 
sl@0:                              BOOST_IOSTREAMS_CONVERTER_ARGS )
sl@0: 
sl@0:         // fstream-like interface.
sl@0: 
sl@0:     bool is_open() const { return this->pimpl_->is_open(); }
sl@0:     void close(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
sl@0:     { impl().close(which); }
sl@0: 
sl@0:         // Device interface.
sl@0: 
sl@0:     std::streamsize read(char_type*, std::streamsize);
sl@0:     std::streamsize write(const char_type*, std::streamsize);
sl@0:     void imbue(const std::locale& loc) { impl().cvt_.imbue(loc); }
sl@0: 
sl@0:         // Direct device access.
sl@0: 
sl@0:     Device& operator*() { return detail::unwrap_direct(dev()); }
sl@0:     Device* operator->() { return &detail::unwrap_direct(dev()); }
sl@0: private:
sl@0:     template<typename T> // Used for forwarding.
sl@0:     void open_impl(const T& t BOOST_IOSTREAMS_CONVERTER_PARAMS()) 
sl@0:     { 
sl@0:         impl().open(t BOOST_IOSTREAMS_CONVERTER_ARGS()); 
sl@0:     }
sl@0: 
sl@0:     const codecvt_type& cvt() { return impl().cvt_.get(); }
sl@0:     policy_type& dev() { return impl().dev(); }
sl@0:     buffer_type& in() { return impl().buf_.first(); }
sl@0:     buffer_type& out() { return impl().buf_.second(); }
sl@0:     impl_type& impl() { return *this->pimpl_; }
sl@0: };
sl@0: 
sl@0: //--------------Implementation of converter-----------------------------------//
sl@0: 
sl@0: // Implementation note: if end of stream contains a partial character,
sl@0: // it is ignored.
sl@0: template<typename Device, typename Codevt, typename Alloc>
sl@0: std::streamsize code_converter<Device, Codevt, Alloc>::read
sl@0:     (char_type* s, std::streamsize n)
sl@0: {
sl@0:     using namespace std;
sl@0:     const extern_type*   next;        // Next external char.
sl@0:     intern_type*         nint;        // Next internal char.
sl@0:     streamsize           total = 0;   // Characters read.
sl@0:     int                  status = iostreams::char_traits<char>::good();
sl@0:     bool                 partial = false;
sl@0:     buffer_type&         buf = in();
sl@0: 
sl@0:     do {
sl@0: 
sl@0:         // Fill buffer.
sl@0:         if (buf.ptr() == buf.eptr() || partial) {
sl@0:             status = buf.fill(dev());
sl@0:             if (buf.ptr() == buf.eptr())
sl@0:                 break;
sl@0:             partial = false;
sl@0:         }
sl@0: 
sl@0:         // Convert.
sl@0:         codecvt_base::result result =
sl@0:             cvt().in( buf.state(),
sl@0:                       buf.ptr(), buf.eptr(), next,
sl@0:                       s + total, s + n, nint );
sl@0:         buf.ptr() += next - buf.ptr();
sl@0:         total = static_cast<streamsize>(nint - s);
sl@0: 
sl@0:         switch (result) {
sl@0:         case codecvt_base::partial:
sl@0:             partial = true;
sl@0:             break;
sl@0:         case codecvt_base::ok:
sl@0:             break;
sl@0:         case codecvt_base::error:
sl@0:             buf.state() = state_type();
sl@0:             throw code_conversion_error();
sl@0:         case codecvt_base::noconv:
sl@0:         default:
sl@0:             buf.state() = state_type();
sl@0:             intern_type c = intern_type();
sl@0:             memcpy(&c, (const void*) buf.ptr(), sizeof(extern_type));
sl@0:             s[total++] = c;
sl@0:             break;
sl@0:         }
sl@0: 
sl@0:     } while (total < n && status != EOF && status != WOULD_BLOCK);
sl@0: 
sl@0:     return total == 0 && status == EOF ? -1 : total;
sl@0: }
sl@0: 
sl@0: template<typename Device, typename Codevt, typename Alloc>
sl@0: std::streamsize code_converter<Device, Codevt, Alloc>::write
sl@0:     (const char_type* s, std::streamsize n)
sl@0: {
sl@0:     using namespace std;
sl@0:     buffer_type&        buf = out();
sl@0:     extern_type*        next;              // Next external char.
sl@0:     const intern_type*  nint;              // Next internal char.
sl@0:     streamsize          total = 0;         // Characters written.
sl@0:     bool                partial = false;
sl@0: 
sl@0:     while (total < n) {
sl@0: 
sl@0:         // Empty buffer.
sl@0:         if (buf.eptr() == buf.end() || partial) {
sl@0:             if (!buf.flush(dev()))
sl@0:                 break;
sl@0:             partial = false;
sl@0:         }
sl@0:        
sl@0:         // Convert.
sl@0:         codecvt_base::result result =
sl@0:             cvt().out( buf.state(),
sl@0:                        s + total, s + n, nint,
sl@0:                        buf.eptr(), buf.end(), next );
sl@0:         int progress = (int) (next - buf.eptr());
sl@0:         buf.eptr() += progress;
sl@0: 
sl@0:         switch (result) {
sl@0:         case codecvt_base::partial:
sl@0:             partial = true; // Fall through.
sl@0:         case codecvt_base::ok:
sl@0:             total = static_cast<streamsize>(nint - s);
sl@0:             break;
sl@0:         case codecvt_base::error:
sl@0:             buf.state() = state_type();
sl@0:             throw code_conversion_error();
sl@0:         case codecvt_base::noconv:
sl@0:             {
sl@0:                 // This can be shortened to two memcpy's.
sl@0:                 const char* c = (const char*) (s + total);
sl@0:                 for ( std::size_t index = 0; 
sl@0:                       index < sizeof(intern_type); 
sl@0:                       index += sizeof(extern_type), 
sl@0:                       ++buf.ptr() ) 
sl@0:                 {
sl@0:                     memcpy(buf.ptr(), c + index, sizeof(extern_type));
sl@0:                     if (buf.eptr() == buf.end())
sl@0:                         buf.flush(dev());
sl@0:                 }
sl@0:                 ++total;
sl@0:             }
sl@0:         }
sl@0:     }
sl@0:     return total;
sl@0: }
sl@0: 
sl@0: //----------------------------------------------------------------------------//
sl@0: 
sl@0: } } // End namespaces iostreams, boost.
sl@0: 
sl@0: #include <boost/iostreams/detail/config/enable_warnings.hpp> // Borland 5.x
sl@0: 
sl@0: #endif // #ifndef BOOST_IOSTREAMS_CODE_CONVERTER_HPP_INCLUDED