boost/iostreams
2
0
Fork 0
mirror of https://github.com/boostorg/iostreams.git synced 2026-02-27 17:12:17 +00:00
Code Issues Projects Releases Wiki Activity

Changed - \r\r\n to \r\n so that vc8.0 doesn't complain

Browse Source 
[SVN r28229]
This commit is contained in:
Victor A. Wagner Jr.
2005-04-13 23:32:41 +00:00
parent 1379d5f21c
commit 3cdee40928
5 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
include/boost/iostreams/compose.hpp
View File

@@ -11,7 +11,7 @@
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#endif
#include <algorithm> // min.
#include <utility> // pair.
@@ -20,7 +20,7 @@
#include <boost/iostreams/detail/call_traits.hpp>
#include <boost/iostreams/detail/closer.hpp>
#include <boost/iostreams/detail/enable_if_streams.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/traits.hpp> // io_mode, is_direct.
#include <boost/mpl/if.hpp>
#include <boost/static_assert.hpp>
@@ -56,7 +56,7 @@ public:
std::streamsize read(char_type* s, std::streamsize n);
void write(const char_type* s, std::streamsize n);
stream_offset seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out );
void close(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out);
@@ -64,8 +64,8 @@ public:
std::streamsize optimal_buffer_size() const;
template<typename Locale> // Avoid dependency on <locale>
void imbue(const Locale& loc)
{
void imbue(const Locale& loc)
{
iostreams::imbue(filter_, loc);
iostreams::imbue(device_, loc);
}
@@ -99,21 +99,21 @@ public:
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{
{
composite_device<Filter2, Source> cmp(filter2_, src);
return iostreams::read(filter1_, cmp, s, n);
}
template<typename Sink>
void write(Sink& snk, const char_type* s, std::streamsize n)
{
{
composite_device<Filter2, Sink> cmp(filter2_, snk);
iostreams::write(filter1_, cmp, s, n);
}
template<typename Device>
stream_offset seek( Device& dev, stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out )
{
composite_device<Filter2, Device> cmp(filter2_, dev);
@@ -121,8 +121,8 @@ public:
}
template<typename Device>
void close( Device& dev,
BOOST_IOS::openmode which =
void close( Device& dev,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out );
template<typename Device>
@@ -132,15 +132,15 @@ public:
return iostreams::flush(filter1_, cmp);
}
std::streamsize optimal_buffer_size() const
{
std::streamsize optimal_buffer_size() const
{
std::streamsize first = iostreams::optimal_buffer_size(filter1_);
std::streamsize second = iostreams::optimal_buffer_size(filter2_);
return first < second ? second : first;
}
template<typename Locale> // Avoid dependency on <locale>
void imbue(const Locale& loc)
void imbue(const Locale& loc)
{ // To do: consider using RAII.
iostreams::imbue(filter_, loc);
iostreams::imbue(device_, loc);
@@ -151,9 +151,9 @@ private:
};
template<typename Filter, typename FilterOrDevice>
struct composite_traits
struct composite_traits
: mpl::if_<
detail::is_device<FilterOrDevice>,
detail::is_device<FilterOrDevice>,
composite_device<Filter, FilterOrDevice>,
composite_filter<Filter, FilterOrDevice>
>
@@ -165,7 +165,7 @@ template<typename Filter, typename FilterOrDevice>
struct composite_view : detail::composite_traits<Filter, FilterOrDevice>::type {
typedef typename detail::param_type<FilterOrDevice>::type param_type;
composite_view(const Filter& flt, param_type dev)
: detail::composite_traits<T>::type(flt, dev)
: detail::composite_traits<T>::type(flt, dev)
{ }
};
@@ -178,56 +178,56 @@ struct composite_view : detail::composite_traits<Filter, FilterOrDevice>::type {
# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
template<typename Filter, typename FilterOrDevice>
composite_view<Filter, FilterOrDevice>
composite_view<Filter, FilterOrDevice>
compose( const Filter& filter, const FilterOrDevice& fod,
BOOST_IOSTREAMS_DISABLE_IF_STREAM(FilterOrDevice) )
{ return composite_view<Filter, FilterOrDevice>(filter, fod); }
template<typename Filter, typename Ch, typename Tr>
composite_view< Filter, std::basic_streambuf<Ch, Tr> >
composite_view< Filter, std::basic_streambuf<Ch, Tr> >
compose(const Filter& filter, std::basic_streambuf<Ch, Tr>& sb)
{ return composite_view< std::basic_streambuf<Ch, Tr> >(filter, sb); }
template<typename Filter, typename Ch, typename Tr>
composite_view< Filter, std::basic_istream<Ch, Tr> >
composite_view< Filter, std::basic_istream<Ch, Tr> >
compose(const Filter& filter, std::basic_istream<Ch, Tr>& is)
{ return composite_view< std::basic_istream<Ch, Tr> >(filter, is); }
template<typename Filter, typename Ch, typename Tr>
composite_view< Filter, std::basic_ostream<Ch, Tr> >
composite_view< Filter, std::basic_ostream<Ch, Tr> >
compose(const Filter& filter, std::basic_ostream<Ch, Tr>& os)
{ return composite_view< std::basic_ostream<Ch, Tr> >(filter, os); }
template<typename Filter, typename Ch, typename Tr>
composite_view< Filter, std::basic_iostream<Ch, Tr> >
composite_view< Filter, std::basic_iostream<Ch, Tr> >
compose(const Filter& filter, std::basic_iostream<Ch, Tr>& io)
{ return composite_view< std::basic_iostream<Ch, Tr> >(filter, io); }
# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
template<typename Filter, typename FilterOrDevice>
composite_view<Filter, FilterOrDevice>
composite_view<Filter, FilterOrDevice>
compose( const Filter& filter, const FilterOrDevice& fod,
BOOST_IOSTREAMS_DISABLE_IF_STREAM(FilterOrDevice) )
{ return composite_view<Filter, FilterOrDevice>(filter, fod); }
template<typename Filter>
composite_view<Filter, std::streambuf>
composite_view<Filter, std::streambuf>
compose(const Filter& filter, std::streambuf& sb)
{ return composite_view<std::streambuf>(filter, sb); }
template<typename Filter>
composite_view<Filter, std::istream>
composite_view<Filter, std::istream>
compose(const Filter& filter, std::istream& is)
{ return composite_view<std::istream>(filter, is); }
template<typename Filter>
composite_view<Filter, std::ostream>
composite_view<Filter, std::ostream>
compose(const Filter& filter, std::ostream& os)
{ return composite_view<std::ostream>(filter, os); }
template<typename Filter>
composite_view<Filter, std::iostream>
composite_view<Filter, std::iostream>
compose(const Filter& filter, std::iostream& io)
{ return composite_view<std::iostream>(filter, io); }
@@ -235,14 +235,14 @@ compose(const Filter& filter, std::iostream& io)
#else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //----------------//
template<typename Filter, typename Stream>
composite_view<Filter, Stream>
composite_view<Filter, Stream>
compose(const Filter& filter, const Stream& strm, mpl::true_)
{ // Bad overload resolution.
return composite_view<Filter, Stream>(filter, const_cast<Stream&>(strm));
}
template<typename Filter, typename FilterOrDevice>
composite_view<Filter, FilterOrDevice>
composite_view<Filter, FilterOrDevice>
compose(const Filter& filter, const FilterOrDevice& fod, mpl::false_)
{ return composite_view<Filter, FilterOrDevice>(filter, fod); }
@@ -257,7 +257,7 @@ compose( const Filter& filter, const FilterOrDevice& fod
!defined(__GNUC__) // ---------------------------------------------------//
template<typename Filter, typename FilterOrDevice>
composite_view<Filter, FilterOrDevice>
composite_view<Filter, FilterOrDevice>
compose (const Filter& filter, FilterOrDevice& fod)
{ return composite_view<Filter, FilterOrDevice>(filter, fod); }
@@ -271,7 +271,7 @@ namespace detail {
template<typename Filter, typename Device>
composite_device<Filter, Device>::composite_device
(const Filter& flt, param_type dev)
(const Filter& flt, param_type dev)
: filter_(flt), device_(dev)
{ }
@@ -292,8 +292,8 @@ stream_offset composite_device<Filter, Device>::seek
template<typename Filter, typename Device>
void composite_device<Filter, Device>::close
(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out)
{
(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out)
{
external_closer<Filter, Device> close_filter(filter_, device_);
external_closer<Device> close_device(device_);
}
@@ -307,7 +307,7 @@ bool composite_device<Filter, Device>::flush()
}
template<typename Filter, typename Device>
std::streamsize composite_device<Filter, Device>::optimal_buffer_size() const
std::streamsize composite_device<Filter, Device>::optimal_buffer_size() const
{ return iostreams::optimal_buffer_size(device_); }
} // End namespace detail.

6
include/boost/iostreams/filter/counter.hpp
View File

@@ -9,7 +9,7 @@
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#endif
#include <algorithm> // count.
#include <boost/iostreams/categories.hpp>
@@ -36,8 +36,8 @@ public:
multichar_tag,
optimally_buffered_tag
{ };
basic_counter(int first_line = 0, int first_char = 0)
: lines_(first_line), chars_(first_char)
basic_counter(int first_line = 0, int first_char = 0)
: lines_(first_line), chars_(first_char)
{ }
int lines() const { return lines_; }
int characters() const { return chars_; }

8
include/boost/iostreams/filter/line_filter.hpp
View File

@@ -88,14 +88,14 @@ public:
}
}
}
typedef basic_line_filter<Ch, Alloc> self;
friend struct detail::closer<self>;
template<typename Sink>
void close(Sink& snk, BOOST_IOS::openmode which)
{
if ((state_ & f_read) && (which & BOOST_IOS::in))
if ((state_ & f_read) && (which & BOOST_IOS::in))
close();
if ((state_ & f_write) && (which & BOOST_IOS::out)) {
@@ -140,8 +140,8 @@ private:
}
bool is_eof(typename traits_type::int_type c)
{
return traits_type::eq_int_type(c, traits_type::eof());
{
return traits_type::eq_int_type(c, traits_type::eof());
}
Ch newline() const { return detail::newline<Ch>::value; }

6
include/boost/iostreams/filter/tee.hpp
View File

@@ -17,7 +17,7 @@
#include <boost/iostreams/detail/call_traits.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace iostreams {
@@ -58,8 +58,8 @@ public:
}
template<typename Next>
void close( Next&,
BOOST_IOS::openmode which =
void close( Next&,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out )
{ iostreams::close(this->component(), which); }

78
include/boost/iostreams/offset.hpp
View File

@@ -9,7 +9,7 @@
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#endif
#include <algorithm> // min.
#include <utility> // pair.
@@ -23,10 +23,10 @@
#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/skip.hpp>
#include <boost/iostreams/traits.hpp> // io_mode, is_direct.
#include <boost/mpl/bool.hpp>
#include <boost/static_assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/iostreams/detail/config/disable_warnings.hpp> // VC7.1 C4244.
@@ -79,7 +79,7 @@ public:
struct io_category
: io_mode<Device>::type,
device_tag,
direct_tag,
direct_tag,
closable_tag,
localizable_tag
{ };
@@ -115,25 +115,25 @@ public:
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{
{
using namespace std;
if (!open_)
open(src);
streamsize amt =
streamsize amt =
(std::min) (n, static_cast<streamsize>(end_ - pos_));
streamsize result = iostreams::read(this->component(), src, s, amt);
streamsize result = iostreams::read(this->component(), src, s, amt);
pos_ += result;
return result;
}
template<typename Sink>
void write(Sink& snk, const char_type* s, std::streamsize n)
{
{
if (!open_)
open(snk);
if (pos_ + n >= end_)
bad_write();
iostreams::write(this->component(), snk, s, n);
iostreams::write(this->component(), snk, s, n);
pos_ += n;
}
@@ -156,16 +156,16 @@ public:
private:
template<typename Device>
void open(Device& dev)
{
{
open_ = true;
pos_ = iostreams::skip(this->component(), dev, beg_);
pos_ = iostreams::skip(this->component(), dev, beg_);
}
stream_offset beg_, pos_, end_;
bool open_;
};
template<typename T>
struct offset_traits
struct offset_traits
: select<
is_filter<T>, offset_filter<T>,
is_direct<T>, offset_direct_device<T>,
@@ -179,7 +179,7 @@ template<typename T>
struct offset_view : public detail::offset_traits<T>::type {
typedef typename detail::param_type<T>::type param_type;
offset_view(param_type t, stream_offset off, stream_offset len)
: detail::offset_traits<T>::type(t, off, len)
: detail::offset_traits<T>::type(t, off, len)
{ }
};
@@ -197,22 +197,22 @@ offset_view<T> offset( const T& t, stream_offset off, stream_offset len
{ return offset_view<T>(t, off, len); }
template<typename Ch, typename Tr>
offset_view< std::basic_streambuf<Ch, Tr> >
offset_view< std::basic_streambuf<Ch, Tr> >
offset(std::basic_streambuf<Ch, Tr>& sb)
{ return offset_view< std::basic_streambuf<Ch, Tr> >(sb); }
template<typename Ch, typename Tr>
offset_view< std::basic_istream<Ch, Tr> >
offset_view< std::basic_istream<Ch, Tr> >
offset(std::basic_istream<Ch, Tr>& is)
{ return offset_view< std::basic_istream<Ch, Tr> >(is); }
template<typename Ch, typename Tr>
offset_view< std::basic_ostream<Ch, Tr> >
offset_view< std::basic_ostream<Ch, Tr> >
offset(std::basic_ostream<Ch, Tr>& os)
{ return offset_view< std::basic_ostream<Ch, Tr> >(os); }
template<typename Ch, typename Tr>
offset_view< std::basic_iostream<Ch, Tr> >
offset_view< std::basic_iostream<Ch, Tr> >
offset(std::basic_iostream<Ch, Tr>& io)
{ return offset_view< std::basic_iostream<Ch, Tr> >(io); }
@@ -269,22 +269,22 @@ namespace detail {
template<typename Device>
offset_indirect_device<Device>::offset_indirect_device
(param_type dev, stream_offset off, stream_offset len)
(param_type dev, stream_offset off, stream_offset len)
: basic_adapter<Device>(dev), beg_(off), pos_(off), end_(off + len)
{
{
if (len < 0 || off < 0)
throw BOOST_IOSTREAMS_FAILURE("bad offset");
pos_ = iostreams::skip(this->component(), off);
pos_ = iostreams::skip(this->component(), off);
}
template<typename Device>
inline std::streamsize offset_indirect_device<Device>::read
(char_type* s, std::streamsize n)
{
{
using namespace std;
streamsize amt =
streamsize amt =
(std::min) (n, static_cast<streamsize>(end_ - pos_));
streamsize result = iostreams::read(this->component(), s, amt);
streamsize result = iostreams::read(this->component(), s, amt);
pos_ += result;
return result;
}
@@ -292,10 +292,10 @@ inline std::streamsize offset_indirect_device<Device>::read
template<typename Device>
inline void offset_indirect_device<Device>::write
(const char_type* s, std::streamsize n)
{
{
if (pos_ + n >= end_)
bad_write();
iostreams::write(this->component(), s, n);
iostreams::write(this->component(), s, n);
pos_ += n;
}
@@ -321,9 +321,9 @@ stream_offset offset_indirect_device<Device>::seek
template<typename Device>
offset_direct_device<Device>::offset_direct_device
(const Device& dev, stream_offset off, stream_offset len)
(const Device& dev, stream_offset off, stream_offset len)
: basic_adapter<Device>(dev), beg_(0), end_(0)
{
{
std::pair<char_type*, char_type*> seq =
sequence(is_convertible<io_category, input>());
if (off < 0 || len < 0 || off + len > seq.second - seq.first)
@@ -333,28 +333,28 @@ offset_direct_device<Device>::offset_direct_device
}
template<typename Device>
typename offset_direct_device<Device>::pair_type
typename offset_direct_device<Device>::pair_type
offset_direct_device<Device>::input_sequence()
{
{
BOOST_STATIC_ASSERT((is_convertible<io_category, input>::value));
return std::make_pair(beg_, end_);
return std::make_pair(beg_, end_);
}
template<typename Device>
typename offset_direct_device<Device>::pair_type
offset_direct_device<Device>::output_sequence()
{
typename offset_direct_device<Device>::pair_type
offset_direct_device<Device>::output_sequence()
{
BOOST_STATIC_ASSERT((is_convertible<io_category, output>::value));
return std::make_pair(beg_, end_);
return std::make_pair(beg_, end_);
}
template<typename Device>
typename offset_direct_device<Device>::pair_type
typename offset_direct_device<Device>::pair_type
offset_direct_device<Device>::sequence(mpl::true_)
{ return iostreams::input_sequence(this->component()); }
template<typename Device>
typename offset_direct_device<Device>::pair_type
typename offset_direct_device<Device>::pair_type
offset_direct_device<Device>::sequence(mpl::false_)
{ return iostreams::output_sequence(this->component()); }
@@ -362,10 +362,10 @@ offset_direct_device<Device>::sequence(mpl::false_)
template<typename Filter>
offset_filter<Filter>::offset_filter
(const Filter& flt, stream_offset off, stream_offset len)
: basic_adapter<Filter>(flt), beg_(off),
(const Filter& flt, stream_offset off, stream_offset len)
: basic_adapter<Filter>(flt), beg_(off),
pos_(off), end_(off + len), open_(false)
{
{
if (len < 0 || off < 0)
throw BOOST_IOSTREAMS_FAILURE("bad offset");
}