// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) // (C) Copyright 2003-2007 Jonathan Turkanis // 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_CLOSE_HPP_INCLUDED #define BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED #if defined(_MSC_VER) # pragma once #endif #include // DEDUCED_TYPENAME, MSVC. #include #include #include #include #include // BOOST_IOS #include #include #include #include #include #include #include #include #include #include // Must come last. #include namespace boost { namespace iostreams { template void close(T& t); template void close(T& t, BOOST_IOS::openmode which); template void close(T& t, Sink& snk, BOOST_IOS::openmode which); namespace detail { template void close_all(T& t) { try { boost::iostreams::close(t, BOOST_IOS::in); } catch (...) { try { boost::iostreams::close(t, BOOST_IOS::out); } catch (...) { } throw; } boost::iostreams::close(t, BOOST_IOS::out); } template void close_all(T& t, Sink& snk) { try { boost::iostreams::close(t, snk, BOOST_IOS::in); } catch (...) { try { boost::iostreams::close(t, snk, BOOST_IOS::out); } catch (...) { } throw; } boost::iostreams::close(t, snk, BOOST_IOS::out); } } // End namespace detail. } } // End namespaces iostreams, boost. namespace boost { namespace iostreams { namespace detail { template struct close_impl; } // End namespace detail. template void close(T& t) { detail::close_all(t); } template void close(T& t, BOOST_IOS::openmode which) { #ifdef BOOST_IOSTREAMS_STRICT BOOST_ASSERT(which == BOOST_IOS::in || which == BOOST_IOS::out); #else if (which == (BOOST_IOS::in | BOOST_IOS::out)) { detail::close_all(t); return; } #endif detail::close_impl::close(detail::unwrap(t), which); } template void close(T& t, Sink& snk, BOOST_IOS::openmode which) { #ifdef BOOST_IOSTREAMS_STRICT BOOST_ASSERT(which == BOOST_IOS::in || which == BOOST_IOS::out); #else if (which == (BOOST_IOS::in | BOOST_IOS::out)) { detail::close_all(t, snk); return; } #endif detail::close_impl::close(detail::unwrap(t), snk, which); } namespace detail { //------------------Definition of close_impl----------------------------------// struct close_boost_stream { }; struct close_filtering_stream { }; template struct close_tag { typedef typename category_of::type category; typedef typename detail::unwrapped_type::type unwrapped; typedef typename iostreams::select< mpl::not_< is_convertible >, any_tag, mpl::or_< is_boost_stream, is_boost_stream_buffer >, close_boost_stream, mpl::or_< is_filtering_stream, is_filtering_streambuf >, close_filtering_stream, mpl::or_< is_convertible, is_convertible >, two_sequence, else_, closable_tag >::type type; }; template struct close_impl : mpl::if_< is_custom, operations, close_impl::type> >::type { }; template<> struct close_impl { template static void close(T& t, BOOST_IOS::openmode which) { if (which == BOOST_IOS::out) iostreams::flush(t); } template static void close(T& t, Sink& snk, BOOST_IOS::openmode which) { if (which == BOOST_IOS::out) { non_blocking_adapter nb(snk); iostreams::flush(t, nb); } } }; template<> struct close_impl { template static void close(T& t) { t.close(); } template static void close(T& t, BOOST_IOS::openmode which) { if (which == BOOST_IOS::out) t.close(); } }; template<> struct close_impl { template static void close(T& t, BOOST_IOS::openmode which) { typedef typename category_of::type category; const bool in = is_convertible::value && !is_convertible::value; if (in == (which == BOOST_IOS::in) && t.is_complete()) t.pop(); } }; template<> struct close_impl { template static void close(T& t, BOOST_IOS::openmode which) { typedef typename category_of::type category; const bool in = is_convertible::value && !is_convertible::value; if (in == (which == BOOST_IOS::in)) t.close(); } template static void close(T& t, Sink& snk, BOOST_IOS::openmode which) { typedef typename category_of::type category; const bool in = is_convertible::value && !is_convertible::value; if (in == (which == BOOST_IOS::in)) { non_blocking_adapter nb(snk); t.close(nb); } } }; template<> struct close_impl { template static void close(T& t, BOOST_IOS::openmode which) { t.close(which); } template static void close(T& t, Sink& snk, BOOST_IOS::openmode which) { non_blocking_adapter nb(snk); t.close(nb, which); } }; } // End namespace detail. } } // End namespaces iostreams, boost. #include #endif // #ifndef BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED