[ceph.git] / ceph / src / boost / libs / iostreams / include / boost / iostreams / detail / restrict_impl.hpp

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

 * File:        boost/iostreams/detail/restrict_impl.hpp
 * Date:        Sun Jan 06 12:57:30 MST 2008
 * Copyright:   2007-2008 CodeRage, LLC
 * Author:      Jonathan Turkanis
 * Contact:     turkanis at coderage dot com
 *
 * If included with the macro BOOST_IOSTREAMS_RESTRICT undefined, defines the 
 * class template boost::iostreams::restriction. If included with the macro
 * BOOST_IOSTREAMS_RESTRICT defined as an identifier, defines the overloaded
 * function template boost::iostreams::BOOST_IOSTREAMS_RESTRICT, and object 
 * generator for boost::iostreams::restriction.
 *
 * This design allows <boost/iostreams/restrict.hpp> and 
 * <boost/iostreams/slice.hpp> to share an implementation.
 */

#if !defined(BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED) && \
    !defined(BOOST_IOSTREAMS_RESTRICT)
# define BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED
                    
//------------------Implementation of restriction-----------------------------//

# include <algorithm>          // min.
# include <utility>            // pair.
# include <boost/cstdint.hpp>  // intmax_t.
# include <boost/config.hpp>   // DEDUCED_TYPENAME.
# include <boost/iostreams/categories.hpp>
# include <boost/iostreams/char_traits.hpp>
# include <boost/iostreams/detail/adapter/device_adapter.hpp>
# include <boost/iostreams/detail/adapter/filter_adapter.hpp>
# include <boost/iostreams/detail/call_traits.hpp>
# include <boost/iostreams/detail/enable_if_stream.hpp>
# include <boost/iostreams/detail/error.hpp>
# include <boost/iostreams/detail/ios.hpp>     // failure.
# include <boost/iostreams/detail/select.hpp>
# include <boost/iostreams/operations.hpp>
# include <boost/iostreams/skip.hpp>
# include <boost/iostreams/traits.hpp>         // mode_of, is_direct.
# include <boost/mpl/bool.hpp>
# include <boost/static_assert.hpp>
# include <boost/throw_exception.hpp>
# include <boost/type_traits/is_convertible.hpp>

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

namespace boost { namespace iostreams {

namespace detail {

//
// Template name: restricted_indirect_device.
// Description: Provides an restricted view of an indirect Device.
// Template parameters:
//      Device - An indirect model of Device that models either Source or
//          SeekableDevice.
//
template<typename Device>
class restricted_indirect_device : public device_adapter<Device> {
private:
    typedef typename detail::param_type<Device>::type  param_type;
public:
    typedef typename char_type_of<Device>::type  char_type;
    typedef typename mode_of<Device>::type       mode;
    BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
    struct category
        : mode,
          device_tag,
          closable_tag,
          flushable_tag,
          localizable_tag,
          optimally_buffered_tag
        { };
    restricted_indirect_device( param_type dev, stream_offset off,
                                stream_offset len = -1 );
    std::streamsize read(char_type* s, std::streamsize n);
    std::streamsize write(const char_type* s, std::streamsize n);
    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
private:
    stream_offset beg_, pos_, end_;
};

//
// Template name: restricted_direct_device.
// Description: Provides an restricted view of a Direct Device.
// Template parameters:
//      Device - A model of Direct and Device.
//
template<typename Device>
class restricted_direct_device : public device_adapter<Device> {
public:
    typedef typename char_type_of<Device>::type  char_type;
    typedef std::pair<char_type*, char_type*>    pair_type;
    typedef typename mode_of<Device>::type       mode;
    BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
    struct category
        : mode_of<Device>::type,
          device_tag,
          direct_tag,
          closable_tag,
          localizable_tag
        { };
    restricted_direct_device( const Device& dev, stream_offset off,
                              stream_offset len = -1 );
    pair_type input_sequence();
    pair_type output_sequence();
private:
    pair_type sequence(mpl::true_);
    pair_type sequence(mpl::false_);
    char_type *beg_, *end_;
};

//
// Template name: restricted_filter.
// Description: Provides an restricted view of a Filter.
// Template parameters:
//      Filter - An indirect model of Filter.
//
template<typename Filter>
class restricted_filter : public filter_adapter<Filter> {
public:
    typedef typename char_type_of<Filter>::type char_type;
    typedef typename mode_of<Filter>::type      mode;
    BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
    struct category
        : mode,
          filter_tag,
          multichar_tag,
          closable_tag,
          localizable_tag,
          optimally_buffered_tag
        { };
    restricted_filter( const Filter& flt, stream_offset off, 
                       stream_offset len = -1 );

    template<typename Source>
    std::streamsize read(Source& src, char_type* s, std::streamsize n)
    {
        using namespace std;
        if (!open_)
            open(src, BOOST_IOS::in);
        std::streamsize amt =
            end_ != -1 ?
                (std::min) (n, static_cast<std::streamsize>(end_ - pos_)) :
                n;
        std::streamsize result = 
            iostreams::read(this->component(), src, s, amt);
        if (result != -1)
            pos_ += result;
        return result;
    }

    template<typename Sink>
    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
    {
        if (!open_)
            open(snk, BOOST_IOS::out);
        if (end_ != -1 && pos_ + n >= end_) {
            if(pos_ < end_)
                pos_ += iostreams::write(this->component(),
                    snk, s, end_ - pos_);
            boost::throw_exception(bad_write());
        }
        std::streamsize result = 
            iostreams::write(this->component(), snk, s, n);
        pos_ += result;
        return result;
    }

    template<typename Device>
    std::streampos seek(Device& dev, stream_offset off, BOOST_IOS::seekdir way)
    {
        stream_offset next;
        if (way == BOOST_IOS::beg) {
            next = beg_ + off;
        } else if (way == BOOST_IOS::cur) {
            next = pos_ + off;
        } else if (end_ != -1) {
            next = end_ + off;
        } else {
            // Restriction is half-open; seek relative to the actual end.
            pos_ = this->component().seek(dev, off, BOOST_IOS::end);
            if (pos_ < beg_)
                boost::throw_exception(bad_seek());
            return offset_to_position(pos_ - beg_);
        }
        if (next < beg_ || (end_ != -1 && next >= end_))
            boost::throw_exception(bad_seek());
        pos_ = this->component().seek(dev, next, BOOST_IOS::cur);
        return offset_to_position(pos_ - beg_);
    }

    template<typename Device>
    void close(Device& dev) 
    { 
        open_ = false;
        detail::close_all(this->component(), dev); 
    }

    template<typename Device>
    void close(Device& dev, BOOST_IOS::openmode which) 
    { 
        open_ = false;
        iostreams::close(this->component(), dev, which); 
    }
private:
    template<typename Device>
    void open(Device& dev, BOOST_IOS::openmode which)
    {
        typedef typename is_convertible<mode, dual_use>::type is_dual_use;
        open_ = true;
        which = is_dual_use() ? which : (BOOST_IOS::in | BOOST_IOS::out);
        iostreams::skip(this->component(), dev, beg_, which);
    }

    stream_offset  beg_, pos_, end_;
    bool           open_;
};

template<typename T>
struct restriction_traits
    : iostreams::select<  // Disambiguation for Tru64.
          is_filter<T>,  restricted_filter<T>,
          is_direct<T>,  restricted_direct_device<T>,
          else_,         restricted_indirect_device<T>
      >
    { };

} // End namespace detail.

template<typename T>
struct restriction : public detail::restriction_traits<T>::type {
    typedef typename detail::param_type<T>::type          param_type;
    typedef typename detail::restriction_traits<T>::type  base_type;
    restriction(param_type t, stream_offset off, stream_offset len = -1)
        : base_type(t, off, len)
        { }
};

namespace detail {

//--------------Implementation of restricted_indirect_device------------------//

template<typename Device>
restricted_indirect_device<Device>::restricted_indirect_device
    (param_type dev, stream_offset off, stream_offset len)
    : device_adapter<Device>(dev), beg_(off), pos_(off), 
      end_(len != -1 ? off + len : -1)
{
    if (len < -1 || off < 0)
        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
    iostreams::skip(this->component(), off);
}

template<typename Device>
inline std::streamsize restricted_indirect_device<Device>::read
    (char_type* s, std::streamsize n)
{
    using namespace std;
    std::streamsize amt =
        end_ != -1 ?
            (std::min) (n, static_cast<std::streamsize>(end_ - pos_)) :
            n;
    std::streamsize result = iostreams::read(this->component(), s, amt);
    if (result != -1)
        pos_ += result;
    return result;
}

template<typename Device>
inline std::streamsize restricted_indirect_device<Device>::write
    (const char_type* s, std::streamsize n)
{
    if (end_ != -1 && pos_ + n >= end_) {
        if(pos_ < end_)
            pos_ += iostreams::write(this->component(), s, end_ - pos_);
        boost::throw_exception(bad_write());
    }
    std::streamsize result = iostreams::write(this->component(), s, n);
    pos_ += result;
    return result;
}

template<typename Device>
std::streampos restricted_indirect_device<Device>::seek
    (stream_offset off, BOOST_IOS::seekdir way)
{
    stream_offset next;
    if (way == BOOST_IOS::beg) {
        next = beg_ + off;
    } else if (way == BOOST_IOS::cur) {
        next = pos_ + off;
    } else if (end_ != -1) {
        next = end_ + off;
    } else {
        // Restriction is half-open; seek relative to the actual end.
        pos_ = iostreams::seek(this->component(), off, BOOST_IOS::end);
        if (pos_ < beg_)
            boost::throw_exception(bad_seek());
        return offset_to_position(pos_ - beg_);
    }
    if (next < beg_ || (end_ != -1 && next > end_))
        boost::throw_exception(bad_seek());
    pos_ = iostreams::seek(this->component(), next - pos_, BOOST_IOS::cur);
    return offset_to_position(pos_ - beg_);
}

//--------------Implementation of restricted_direct_device--------------------//

template<typename Device>
restricted_direct_device<Device>::restricted_direct_device
    (const Device& dev, stream_offset off, stream_offset len)
    : device_adapter<Device>(dev), beg_(0), end_(0)
{
    std::pair<char_type*, char_type*> seq =
        sequence(is_convertible<category, input>());
    if ( off < 0 || len < -1 || 
         (len != -1 && off + len > seq.second - seq.first) )
    {
        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
    }
    beg_ = seq.first + off;
    end_ = len != -1 ? 
        seq.first + off + len :
        seq.second;
}

template<typename Device>
typename restricted_direct_device<Device>::pair_type
restricted_direct_device<Device>::input_sequence()
{
    BOOST_STATIC_ASSERT((is_convertible<category, input>::value));
    return std::make_pair(beg_, end_);
}

template<typename Device>
typename restricted_direct_device<Device>::pair_type
restricted_direct_device<Device>::output_sequence()
{
    BOOST_STATIC_ASSERT((is_convertible<category, output>::value));
    return std::make_pair(beg_, end_);
}

template<typename Device>
typename restricted_direct_device<Device>::pair_type
restricted_direct_device<Device>::sequence(mpl::true_)
{ return iostreams::input_sequence(this->component()); }

template<typename Device>
typename restricted_direct_device<Device>::pair_type
restricted_direct_device<Device>::sequence(mpl::false_)
{ return iostreams::output_sequence(this->component()); }

//--------------Implementation of restricted_filter---------------------------//

template<typename Filter>
restricted_filter<Filter>::restricted_filter
    (const Filter& flt, stream_offset off, stream_offset len)
    : filter_adapter<Filter>(flt), beg_(off),
      pos_(off), end_(len != -1 ? off + len : -1), open_(false)
{
    if (len < -1 || off < 0)
        boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
}

} // End namespace detail.

} } // End namespaces iostreams, boost.

#elif defined(BOOST_IOSTREAMS_RESTRICT)

namespace boost { namespace iostreams {

//--------------Implementation of restrict/slice------------------------------//

// Note: The following workarounds are patterned after resolve.hpp. It has not
// yet been confirmed that they are necessary.

# ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //------------------------//
#  ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //------------------------------//

template<typename T>
restriction<T> 
BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
                          BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
{ return restriction<T>(t, off, len); }

template<typename Ch, typename Tr>
restriction< std::basic_streambuf<Ch, Tr> >
BOOST_IOSTREAMS_RESTRICT( std::basic_streambuf<Ch, Tr>& sb, stream_offset off, 
                          stream_offset len = -1 )
{ return restriction< std::basic_streambuf<Ch, Tr> >(sb, off, len); }

template<typename Ch, typename Tr>
restriction< std::basic_istream<Ch, Tr> >
BOOST_IOSTREAMS_RESTRICT
    (std::basic_istream<Ch, Tr>& is, stream_offset off, stream_offset len = -1)
{ return restriction< std::basic_istream<Ch, Tr> >(is, off, len); }

template<typename Ch, typename Tr>
restriction< std::basic_ostream<Ch, Tr> >
BOOST_IOSTREAMS_RESTRICT
    (std::basic_ostream<Ch, Tr>& os, stream_offset off, stream_offset len = -1)
{ return restriction< std::basic_ostream<Ch, Tr> >(os, off, len); }

template<typename Ch, typename Tr>
restriction< std::basic_iostream<Ch, Tr> >
BOOST_IOSTREAMS_RESTRICT
    (std::basic_iostream<Ch, Tr>& io, stream_offset off, stream_offset len = -1)
{ return restriction< std::basic_iostream<Ch, Tr> >(io, off, len); }

#  else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//

template<typename T>
restriction<T> 
BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
                          BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
{ return restriction<T>(t, off, len); }

restriction<std::streambuf> 
BOOST_IOSTREAMS_RESTRICT
    (std::streambuf& sb, stream_offset off, stream_offset len = -1)
{ return restriction<std::streambuf>(sb, off, len); }

restriction<std::istream> 
BOOST_IOSTREAMS_RESTRICT
    (std::istream<Ch, Tr>& is, stream_offset off, stream_offset len = -1)
{ return restriction<std::istream>(is, off, len); }

restriction<std::ostream> 
BOOST_IOSTREAMS_RESTRICT
    (std::ostream<Ch, Tr>& os, stream_offset off, stream_offset len = -1)
{ return restriction<std::ostream>(os, off, len); }

restriction<std::iostream> 
BOOST_IOSTREAMS_RESTRICT
    (std::iostream<Ch, Tr>& io, stream_offset off, stream_offset len = -1)
{ return restriction<std::iostream>(io, off, len); }

#  endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------//
# else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //---------------//

template<typename T>
restriction<T> 
BOOST_IOSTREAMS_RESTRICT
    (const T& t, stream_offset off, stream_offset len, mpl::true_)
{   // Bad overload resolution.
    return restriction<T>(const_cast<T&>(t, off, len));
}

template<typename T>
restriction<T> 
BOOST_IOSTREAMS_RESTRICT
    (const T& t, stream_offset off, stream_offset len, mpl::false_)
{ return restriction<T>(t, off, len); }

template<typename T>
restriction<T> 
BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
                          BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
{ return BOOST_IOSTREAMS_RESTRICT(t, off, len, is_std_io<T>()); }

# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
     !defined(__GNUC__) // ---------------------------------------------------//

template<typename T>
restriction<T>
BOOST_IOSTREAMS_RESTRICT(T& t, stream_offset off, stream_offset len = -1)
{ return restriction<T>(t, off, len); }

#  endif // Borland 5.x or GCC //-------------------------------//
# endif // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //--------------//

} } // End namespaces iostreams, boost.

#endif // #if !defined(BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED) ...
Commit	Line	Data
7c673cae FG	1	/*
	2	* Distributed under the Boost Software License, Version 1.0.(See accompanying
	3	* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
	4	*
	5	* See http://www.boost.org/libs/iostreams for documentation.
	6
	7	* File: boost/iostreams/detail/restrict_impl.hpp
	8	* Date: Sun Jan 06 12:57:30 MST 2008
	9	* Copyright: 2007-2008 CodeRage, LLC
	10	* Author: Jonathan Turkanis
	11	* Contact: turkanis at coderage dot com
	12	*
	13	* If included with the macro BOOST_IOSTREAMS_RESTRICT undefined, defines the
	14	* class template boost::iostreams::restriction. If included with the macro
	15	* BOOST_IOSTREAMS_RESTRICT defined as an identifier, defines the overloaded
	16	* function template boost::iostreams::BOOST_IOSTREAMS_RESTRICT, and object
	17	* generator for boost::iostreams::restriction.
	18	*
	19	* This design allows <boost/iostreams/restrict.hpp> and
	20	* <boost/iostreams/slice.hpp> to share an implementation.
	21	*/
	22
	23	#if !defined(BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED) && \
	24	!defined(BOOST_IOSTREAMS_RESTRICT)
	25	# define BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED
	26
	27	//------------------Implementation of restriction-----------------------------//
	28
	29	# include <algorithm> // min.
	30	# include <utility> // pair.
	31	# include <boost/cstdint.hpp> // intmax_t.
	32	# include <boost/config.hpp> // DEDUCED_TYPENAME.
	33	# include <boost/iostreams/categories.hpp>
	34	# include <boost/iostreams/char_traits.hpp>
	35	# include <boost/iostreams/detail/adapter/device_adapter.hpp>
	36	# include <boost/iostreams/detail/adapter/filter_adapter.hpp>
	37	# include <boost/iostreams/detail/call_traits.hpp>
	38	# include <boost/iostreams/detail/enable_if_stream.hpp>
	39	# include <boost/iostreams/detail/error.hpp>
	40	# include <boost/iostreams/detail/ios.hpp> // failure.
	41	# include <boost/iostreams/detail/select.hpp>
	42	# include <boost/iostreams/operations.hpp>
	43	# include <boost/iostreams/skip.hpp>
	44	# include <boost/iostreams/traits.hpp> // mode_of, is_direct.
	45	# include <boost/mpl/bool.hpp>
	46	# include <boost/static_assert.hpp>
	47	# include <boost/throw_exception.hpp>
	48	# include <boost/type_traits/is_convertible.hpp>
	49
	50	# include <boost/iostreams/detail/config/disable_warnings.hpp>
	51
	52	namespace boost { namespace iostreams {
	53
	54	namespace detail {
	55
	56	//
	57	// Template name: restricted_indirect_device.
	58	// Description: Provides an restricted view of an indirect Device.
	59	// Template parameters:
	60	// Device - An indirect model of Device that models either Source or
	61	// SeekableDevice.
	62	//
	63	template<typename Device>
	64	class restricted_indirect_device : public device_adapter<Device> {
65	private:
66	typedef typename detail::param_type<Device>::type param_type;
67	public:
68	typedef typename char_type_of<Device>::type char_type;
69	typedef typename mode_of<Device>::type mode;
70	BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
71	struct category
72	: mode,
73	device_tag,
74	closable_tag,
75	flushable_tag,
76	localizable_tag,
77	optimally_buffered_tag
78	{ };
79	restricted_indirect_device( param_type dev, stream_offset off,
80	stream_offset len = -1 );
81	std::streamsize read(char_type* s, std::streamsize n);
82	std::streamsize write(const char_type* s, std::streamsize n);
83	std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
84	private:
85	stream_offset beg_, pos_, end_;
86	};
87
88	//
89	// Template name: restricted_direct_device.
90	// Description: Provides an restricted view of a Direct Device.
91	// Template parameters:
92	// Device - A model of Direct and Device.
93	//
94	template<typename Device>
95	class restricted_direct_device : public device_adapter<Device> {
96	public:
97	typedef typename char_type_of<Device>::type char_type;
98	typedef std::pair<char_type, char_type> pair_type;
99	typedef typename mode_of<Device>::type mode;
100	BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
101	struct category
102	: mode_of<Device>::type,
103	device_tag,
104	direct_tag,
105	closable_tag,
106	localizable_tag
107	{ };
108	restricted_direct_device( const Device& dev, stream_offset off,
109	stream_offset len = -1 );
110	pair_type input_sequence();
111	pair_type output_sequence();
112	private:
113	pair_type sequence(mpl::true_);
114	pair_type sequence(mpl::false_);
115	char_type beg_, end_;
116	};
117
118	//
119	// Template name: restricted_filter.
120	// Description: Provides an restricted view of a Filter.
121	// Template parameters:
122	// Filter - An indirect model of Filter.
123	//
124	template<typename Filter>
125	class restricted_filter : public filter_adapter<Filter> {
126	public:
127	typedef typename char_type_of<Filter>::type char_type;
128	typedef typename mode_of<Filter>::type mode;
129	BOOST_STATIC_ASSERT(!(is_convertible<mode, detail::two_sequence>::value));
130	struct category
131	: mode,
132	filter_tag,
133	multichar_tag,
134	closable_tag,
135	localizable_tag,
136	optimally_buffered_tag
137	{ };
138	restricted_filter( const Filter& flt, stream_offset off,
139	stream_offset len = -1 );
140
141	template<typename Source>
142	std::streamsize read(Source& src, char_type* s, std::streamsize n)
143	{
144	using namespace std;
145	if (!open_)
146	open(src, BOOST_IOS::in);
147	std::streamsize amt =
148	end_ != -1 ?
149	(std::min) (n, static_cast<std::streamsize>(end_ - pos_)) :
150	n;
151	std::streamsize result =
152	iostreams::read(this->component(), src, s, amt);
153	if (result != -1)
154	pos_ += result;
155	return result;
156	}
157
158	template<typename Sink>
159	std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
160	{
161	if (!open_)
162	open(snk, BOOST_IOS::out);
163	if (end_ != -1 && pos_ + n >= end_) {
164	if(pos_ < end_)
165	pos_ += iostreams::write(this->component(),
166	snk, s, end_ - pos_);
167	boost::throw_exception(bad_write());
168	}
169	std::streamsize result =
170	iostreams::write(this->component(), snk, s, n);
171	pos_ += result;
172	return result;
173	}
174
175	template<typename Device>
176	std::streampos seek(Device& dev, stream_offset off, BOOST_IOS::seekdir way)
177	{
178	stream_offset next;
179	if (way == BOOST_IOS::beg) {
180	next = beg_ + off;
181	} else if (way == BOOST_IOS::cur) {
182	next = pos_ + off;
183	} else if (end_ != -1) {
184	next = end_ + off;
185	} else {
186	// Restriction is half-open; seek relative to the actual end.
187	pos_ = this->component().seek(dev, off, BOOST_IOS::end);
188	if (pos_ < beg_)
189	boost::throw_exception(bad_seek());
190	return offset_to_position(pos_ - beg_);
191	}
192	if (next < beg_ \|\| (end_ != -1 && next >= end_))
193	boost::throw_exception(bad_seek());
194	pos_ = this->component().seek(dev, next, BOOST_IOS::cur);
195	return offset_to_position(pos_ - beg_);
196	}
197
198	template<typename Device>
199	void close(Device& dev)
200	{
201	open_ = false;
202	detail::close_all(this->component(), dev);
203	}
204
205	template<typename Device>
206	void close(Device& dev, BOOST_IOS::openmode which)
207	{
208	open_ = false;
209	iostreams::close(this->component(), dev, which);
210	}
211	private:
212	template<typename Device>
213	void open(Device& dev, BOOST_IOS::openmode which)
214	{
215	typedef typename is_convertible<mode, dual_use>::type is_dual_use;
216	open_ = true;
217	which = is_dual_use() ? which : (BOOST_IOS::in \| BOOST_IOS::out);
218	iostreams::skip(this->component(), dev, beg_, which);
219	}
220
221	stream_offset beg_, pos_, end_;
222	bool open_;
223	};
224
225	template<typename T>
226	struct restriction_traits
227	: iostreams::select< // Disambiguation for Tru64.
228	is_filter<T>, restricted_filter<T>,
229	is_direct<T>, restricted_direct_device<T>,
230	else_, restricted_indirect_device<T>
231	>
232	{ };
233
234	} // End namespace detail.
235
236	template<typename T>
237	struct restriction : public detail::restriction_traits<T>::type {
238	typedef typename detail::param_type<T>::type param_type;
239	typedef typename detail::restriction_traits<T>::type base_type;
240	restriction(param_type t, stream_offset off, stream_offset len = -1)
241	: base_type(t, off, len)
242	{ }
243	};
244
245	namespace detail {
246
247	//--------------Implementation of restricted_indirect_device------------------//
248
249	template<typename Device>
250	restricted_indirect_device<Device>::restricted_indirect_device
251	(param_type dev, stream_offset off, stream_offset len)
252	: device_adapter<Device>(dev), beg_(off), pos_(off),
253	end_(len != -1 ? off + len : -1)
254	{
255	if (len < -1 \|\| off < 0)
256	boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
257	iostreams::skip(this->component(), off);
258	}
259
260	template<typename Device>
261	inline std::streamsize restricted_indirect_device<Device>::read
262	(char_type* s, std::streamsize n)
263	{
264	using namespace std;
265	std::streamsize amt =
266	end_ != -1 ?
267	(std::min) (n, static_cast<std::streamsize>(end_ - pos_)) :
268	n;
269	std::streamsize result = iostreams::read(this->component(), s, amt);
270	if (result != -1)
271	pos_ += result;
272	return result;
273	}
274
275	template<typename Device>
276	inline std::streamsize restricted_indirect_device<Device>::write
277	(const char_type* s, std::streamsize n)
278	{
279	if (end_ != -1 && pos_ + n >= end_) {
280	if(pos_ < end_)
281	pos_ += iostreams::write(this->component(), s, end_ - pos_);
282	boost::throw_exception(bad_write());
283	}
284	std::streamsize result = iostreams::write(this->component(), s, n);
285	pos_ += result;
286	return result;
287	}
288
289	template<typename Device>
290	std::streampos restricted_indirect_device<Device>::seek
291	(stream_offset off, BOOST_IOS::seekdir way)
292	{
293	stream_offset next;
294	if (way == BOOST_IOS::beg) {
295	next = beg_ + off;
296	} else if (way == BOOST_IOS::cur) {
297	next = pos_ + off;
298	} else if (end_ != -1) {
299	next = end_ + off;
300	} else {
301	// Restriction is half-open; seek relative to the actual end.
302	pos_ = iostreams::seek(this->component(), off, BOOST_IOS::end);
303	if (pos_ < beg_)
304	boost::throw_exception(bad_seek());
305	return offset_to_position(pos_ - beg_);
306	}
307	if (next < beg_ \|\| (end_ != -1 && next > end_))
308	boost::throw_exception(bad_seek());
309	pos_ = iostreams::seek(this->component(), next - pos_, BOOST_IOS::cur);
310	return offset_to_position(pos_ - beg_);
311	}
312
313	//--------------Implementation of restricted_direct_device--------------------//
314
315	template<typename Device>
316	restricted_direct_device<Device>::restricted_direct_device
317	(const Device& dev, stream_offset off, stream_offset len)
318	: device_adapter<Device>(dev), beg_(0), end_(0)
319	{
320	std::pair<char_type, char_type> seq =
321	sequence(is_convertible<category, input>());
322	if ( off < 0 \|\| len < -1 \|\|
323	(len != -1 && off + len > seq.second - seq.first) )
324	{
325	boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
326	}
327	beg_ = seq.first + off;
328	end_ = len != -1 ?
329	seq.first + off + len :
330	seq.second;
331	}
332
333	template<typename Device>
334	typename restricted_direct_device<Device>::pair_type
335	restricted_direct_device<Device>::input_sequence()
336	{
337	BOOST_STATIC_ASSERT((is_convertible<category, input>::value));
338	return std::make_pair(beg_, end_);
339	}
340
341	template<typename Device>
342	typename restricted_direct_device<Device>::pair_type
343	restricted_direct_device<Device>::output_sequence()
344	{
345	BOOST_STATIC_ASSERT((is_convertible<category, output>::value));
346	return std::make_pair(beg_, end_);
347	}
348
349	template<typename Device>
350	typename restricted_direct_device<Device>::pair_type
351	restricted_direct_device<Device>::sequence(mpl::true_)
352	{ return iostreams::input_sequence(this->component()); }
353
354	template<typename Device>
355	typename restricted_direct_device<Device>::pair_type
356	restricted_direct_device<Device>::sequence(mpl::false_)
357	{ return iostreams::output_sequence(this->component()); }
358
359	//--------------Implementation of restricted_filter---------------------------//
360
361	template<typename Filter>
362	restricted_filter<Filter>::restricted_filter
363	(const Filter& flt, stream_offset off, stream_offset len)
364	: filter_adapter<Filter>(flt), beg_(off),
365	pos_(off), end_(len != -1 ? off + len : -1), open_(false)
366	{
367	if (len < -1 \|\| off < 0)
368	boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset"));
369	}
370
371	} // End namespace detail.
372
373	} } // End namespaces iostreams, boost.
374
375	#elif defined(BOOST_IOSTREAMS_RESTRICT)
376
377	namespace boost { namespace iostreams {
378
379	//--------------Implementation of restrict/slice------------------------------//
380
381	// Note: The following workarounds are patterned after resolve.hpp. It has not
382	// yet been confirmed that they are necessary.
383
384	# ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //------------------------//
385	# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //------------------------------//
386
387	template<typename T>
388	restriction<T>
389	BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
390	BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
391	{ return restriction<T>(t, off, len); }
392
393	template<typename Ch, typename Tr>
394	restriction< std::basic_streambuf<Ch, Tr> >
395	BOOST_IOSTREAMS_RESTRICT( std::basic_streambuf<Ch, Tr>& sb, stream_offset off,
396	stream_offset len = -1 )
397	{ return restriction< std::basic_streambuf<Ch, Tr> >(sb, off, len); }
398
399	template<typename Ch, typename Tr>
400	restriction< std::basic_istream<Ch, Tr> >
401	BOOST_IOSTREAMS_RESTRICT
402	(std::basic_istream<Ch, Tr>& is, stream_offset off, stream_offset len = -1)
403	{ return restriction< std::basic_istream<Ch, Tr> >(is, off, len); }
404
405	template<typename Ch, typename Tr>
406	restriction< std::basic_ostream<Ch, Tr> >
407	BOOST_IOSTREAMS_RESTRICT
408	(std::basic_ostream<Ch, Tr>& os, stream_offset off, stream_offset len = -1)
409	{ return restriction< std::basic_ostream<Ch, Tr> >(os, off, len); }
410
411	template<typename Ch, typename Tr>
412	restriction< std::basic_iostream<Ch, Tr> >
413	BOOST_IOSTREAMS_RESTRICT
414	(std::basic_iostream<Ch, Tr>& io, stream_offset off, stream_offset len = -1)
415	{ return restriction< std::basic_iostream<Ch, Tr> >(io, off, len); }
416
417	# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
418
419	template<typename T>
420	restriction<T>
421	BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
422	BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
423	{ return restriction<T>(t, off, len); }
424
425	restriction<std::streambuf>
426	BOOST_IOSTREAMS_RESTRICT
427	(std::streambuf& sb, stream_offset off, stream_offset len = -1)
428	{ return restriction<std::streambuf>(sb, off, len); }
429
430	restriction<std::istream>
431	BOOST_IOSTREAMS_RESTRICT
432	(std::istream<Ch, Tr>& is, stream_offset off, stream_offset len = -1)
433	{ return restriction<std::istream>(is, off, len); }
434
435	restriction<std::ostream>
436	BOOST_IOSTREAMS_RESTRICT
437	(std::ostream<Ch, Tr>& os, stream_offset off, stream_offset len = -1)
438	{ return restriction<std::ostream>(os, off, len); }
439
440	restriction<std::iostream>
441	BOOST_IOSTREAMS_RESTRICT
442	(std::iostream<Ch, Tr>& io, stream_offset off, stream_offset len = -1)
443	{ return restriction<std::iostream>(io, off, len); }
444
445	# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------//
446	# else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //---------------//
447
448	template<typename T>
449	restriction<T>
450	BOOST_IOSTREAMS_RESTRICT
451	(const T& t, stream_offset off, stream_offset len, mpl::true_)
452	{ // Bad overload resolution.
453	return restriction<T>(const_cast<T&>(t, off, len));
454	}
455
456	template<typename T>
457	restriction<T>
458	BOOST_IOSTREAMS_RESTRICT
459	(const T& t, stream_offset off, stream_offset len, mpl::false_)
460	{ return restriction<T>(t, off, len); }
461
462	template<typename T>
463	restriction<T>
464	BOOST_IOSTREAMS_RESTRICT( const T& t, stream_offset off, stream_offset len = -1
465	BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) )
466	{ return BOOST_IOSTREAMS_RESTRICT(t, off, len, is_std_io<T>()); }
467
468	# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
469	!defined(__GNUC__) // ---------------------------------------------------//
470
471	template<typename T>
472	restriction<T>
473	BOOST_IOSTREAMS_RESTRICT(T& t, stream_offset off, stream_offset len = -1)
474	{ return restriction<T>(t, off, len); }
475
476	# endif // Borland 5.x or GCC //-------------------------------//
477	# endif // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //--------------//
478
479	} } // End namespaces iostreams, boost.
480
481	#endif // #if !defined(BOOST_IOSTREAMS_RESTRICT_IMPL_HPP_INCLUDED) ...