From 3cdee40928aacb3d35d6b279e4e4b0de0dec0080 Mon Sep 17 00:00:00 2001 From: "Victor A. Wagner Jr." Date: Wed, 13 Apr 2005 23:32:41 +0000 Subject: [PATCH] Changed - \r\r\n to \r\n so that vc8.0 doesn't complain [SVN r28229] --- include/boost/iostreams/compose.hpp | 66 ++++++++-------- include/boost/iostreams/filter/counter.hpp | 6 +- .../boost/iostreams/filter/line_filter.hpp | 8 +- include/boost/iostreams/filter/tee.hpp | 6 +- include/boost/iostreams/offset.hpp | 78 +++++++++---------- 5 files changed, 82 insertions(+), 82 deletions(-) diff --git a/include/boost/iostreams/compose.hpp b/include/boost/iostreams/compose.hpp index 5a562f0..20738db 100755 --- a/include/boost/iostreams/compose.hpp +++ b/include/boost/iostreams/compose.hpp @@ -11,7 +11,7 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once -#endif +#endif #include // min. #include // pair. @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include // io_mode, is_direct. #include #include @@ -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 // Avoid dependency on - void imbue(const Locale& loc) - { + void imbue(const Locale& loc) + { iostreams::imbue(filter_, loc); iostreams::imbue(device_, loc); } @@ -99,21 +99,21 @@ public: template std::streamsize read(Source& src, char_type* s, std::streamsize n) - { + { composite_device cmp(filter2_, src); return iostreams::read(filter1_, cmp, s, n); } template void write(Sink& snk, const char_type* s, std::streamsize n) - { + { composite_device cmp(filter2_, snk); iostreams::write(filter1_, cmp, s, n); } template 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 cmp(filter2_, dev); @@ -121,8 +121,8 @@ public: } template - void close( Device& dev, - BOOST_IOS::openmode which = + void close( Device& dev, + BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out ); template @@ -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 // Avoid dependency on - 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 -struct composite_traits +struct composite_traits : mpl::if_< - detail::is_device, + detail::is_device, composite_device, composite_filter > @@ -165,7 +165,7 @@ template struct composite_view : detail::composite_traits::type { typedef typename detail::param_type::type param_type; composite_view(const Filter& flt, param_type dev) - : detail::composite_traits::type(flt, dev) + : detail::composite_traits::type(flt, dev) { } }; @@ -178,56 +178,56 @@ struct composite_view : detail::composite_traits::type { # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------// template -composite_view +composite_view compose( const Filter& filter, const FilterOrDevice& fod, BOOST_IOSTREAMS_DISABLE_IF_STREAM(FilterOrDevice) ) { return composite_view(filter, fod); } template -composite_view< Filter, std::basic_streambuf > +composite_view< Filter, std::basic_streambuf > compose(const Filter& filter, std::basic_streambuf& sb) { return composite_view< std::basic_streambuf >(filter, sb); } template -composite_view< Filter, std::basic_istream > +composite_view< Filter, std::basic_istream > compose(const Filter& filter, std::basic_istream& is) { return composite_view< std::basic_istream >(filter, is); } template -composite_view< Filter, std::basic_ostream > +composite_view< Filter, std::basic_ostream > compose(const Filter& filter, std::basic_ostream& os) { return composite_view< std::basic_ostream >(filter, os); } template -composite_view< Filter, std::basic_iostream > +composite_view< Filter, std::basic_iostream > compose(const Filter& filter, std::basic_iostream& io) { return composite_view< std::basic_iostream >(filter, io); } # else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------// template -composite_view +composite_view compose( const Filter& filter, const FilterOrDevice& fod, BOOST_IOSTREAMS_DISABLE_IF_STREAM(FilterOrDevice) ) { return composite_view(filter, fod); } template -composite_view +composite_view compose(const Filter& filter, std::streambuf& sb) { return composite_view(filter, sb); } template -composite_view +composite_view compose(const Filter& filter, std::istream& is) { return composite_view(filter, is); } template -composite_view +composite_view compose(const Filter& filter, std::ostream& os) { return composite_view(filter, os); } template -composite_view +composite_view compose(const Filter& filter, std::iostream& io) { return composite_view(filter, io); } @@ -235,14 +235,14 @@ compose(const Filter& filter, std::iostream& io) #else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //----------------// template -composite_view +composite_view compose(const Filter& filter, const Stream& strm, mpl::true_) { // Bad overload resolution. return composite_view(filter, const_cast(strm)); } template -composite_view +composite_view compose(const Filter& filter, const FilterOrDevice& fod, mpl::false_) { return composite_view(filter, fod); } @@ -257,7 +257,7 @@ compose( const Filter& filter, const FilterOrDevice& fod !defined(__GNUC__) // ---------------------------------------------------// template -composite_view +composite_view compose (const Filter& filter, FilterOrDevice& fod) { return composite_view(filter, fod); } @@ -271,7 +271,7 @@ namespace detail { template composite_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::seek template void composite_device::close - (BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out) -{ + (BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out) +{ external_closer close_filter(filter_, device_); external_closer close_device(device_); } @@ -307,7 +307,7 @@ bool composite_device::flush() } template -std::streamsize composite_device::optimal_buffer_size() const +std::streamsize composite_device::optimal_buffer_size() const { return iostreams::optimal_buffer_size(device_); } } // End namespace detail. diff --git a/include/boost/iostreams/filter/counter.hpp b/include/boost/iostreams/filter/counter.hpp index 6454ed9..9c7d908 100755 --- a/include/boost/iostreams/filter/counter.hpp +++ b/include/boost/iostreams/filter/counter.hpp @@ -9,7 +9,7 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once -#endif +#endif #include // count. #include @@ -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_; } diff --git a/include/boost/iostreams/filter/line_filter.hpp b/include/boost/iostreams/filter/line_filter.hpp index 6463eca..1f2023f 100755 --- a/include/boost/iostreams/filter/line_filter.hpp +++ b/include/boost/iostreams/filter/line_filter.hpp @@ -88,14 +88,14 @@ public: } } } - + typedef basic_line_filter self; friend struct detail::closer; template 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::value; } diff --git a/include/boost/iostreams/filter/tee.hpp b/include/boost/iostreams/filter/tee.hpp index 98be296..f6632a5 100755 --- a/include/boost/iostreams/filter/tee.hpp +++ b/include/boost/iostreams/filter/tee.hpp @@ -17,7 +17,7 @@ #include #include #include -#include +#include #include namespace boost { namespace iostreams { @@ -58,8 +58,8 @@ public: } template - 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); } diff --git a/include/boost/iostreams/offset.hpp b/include/boost/iostreams/offset.hpp index 73ba55d..905043b 100755 --- a/include/boost/iostreams/offset.hpp +++ b/include/boost/iostreams/offset.hpp @@ -9,7 +9,7 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once -#endif +#endif #include // min. #include // pair. @@ -23,10 +23,10 @@ #include // failure. #include #include -#include +#include #include // io_mode, is_direct. #include -#include +#include #include #include // VC7.1 C4244. @@ -79,7 +79,7 @@ public: struct io_category : io_mode::type, device_tag, - direct_tag, + direct_tag, closable_tag, localizable_tag { }; @@ -115,25 +115,25 @@ public: template 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(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 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 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 -struct offset_traits +struct offset_traits : select< is_filter, offset_filter, is_direct, offset_direct_device, @@ -179,7 +179,7 @@ template struct offset_view : public detail::offset_traits::type { typedef typename detail::param_type::type param_type; offset_view(param_type t, stream_offset off, stream_offset len) - : detail::offset_traits::type(t, off, len) + : detail::offset_traits::type(t, off, len) { } }; @@ -197,22 +197,22 @@ offset_view offset( const T& t, stream_offset off, stream_offset len { return offset_view(t, off, len); } template -offset_view< std::basic_streambuf > +offset_view< std::basic_streambuf > offset(std::basic_streambuf& sb) { return offset_view< std::basic_streambuf >(sb); } template -offset_view< std::basic_istream > +offset_view< std::basic_istream > offset(std::basic_istream& is) { return offset_view< std::basic_istream >(is); } template -offset_view< std::basic_ostream > +offset_view< std::basic_ostream > offset(std::basic_ostream& os) { return offset_view< std::basic_ostream >(os); } template -offset_view< std::basic_iostream > +offset_view< std::basic_iostream > offset(std::basic_iostream& io) { return offset_view< std::basic_iostream >(io); } @@ -269,22 +269,22 @@ namespace detail { template offset_indirect_device::offset_indirect_device - (param_type dev, stream_offset off, stream_offset len) + (param_type dev, stream_offset off, stream_offset len) : basic_adapter(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 inline std::streamsize offset_indirect_device::read (char_type* s, std::streamsize n) -{ +{ using namespace std; - streamsize amt = + streamsize amt = (std::min) (n, static_cast(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::read template inline void offset_indirect_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::seek template offset_direct_device::offset_direct_device - (const Device& dev, stream_offset off, stream_offset len) + (const Device& dev, stream_offset off, stream_offset len) : basic_adapter(dev), beg_(0), end_(0) -{ +{ std::pair seq = sequence(is_convertible()); if (off < 0 || len < 0 || off + len > seq.second - seq.first) @@ -333,28 +333,28 @@ offset_direct_device::offset_direct_device } template -typename offset_direct_device::pair_type +typename offset_direct_device::pair_type offset_direct_device::input_sequence() -{ +{ BOOST_STATIC_ASSERT((is_convertible::value)); - return std::make_pair(beg_, end_); + return std::make_pair(beg_, end_); } template -typename offset_direct_device::pair_type -offset_direct_device::output_sequence() -{ +typename offset_direct_device::pair_type +offset_direct_device::output_sequence() +{ BOOST_STATIC_ASSERT((is_convertible::value)); - return std::make_pair(beg_, end_); + return std::make_pair(beg_, end_); } template -typename offset_direct_device::pair_type +typename offset_direct_device::pair_type offset_direct_device::sequence(mpl::true_) { return iostreams::input_sequence(this->component()); } template -typename offset_direct_device::pair_type +typename offset_direct_device::pair_type offset_direct_device::sequence(mpl::false_) { return iostreams::output_sequence(this->component()); } @@ -362,10 +362,10 @@ offset_direct_device::sequence(mpl::false_) template offset_filter::offset_filter - (const Filter& flt, stream_offset off, stream_offset len) - : basic_adapter(flt), beg_(off), + (const Filter& flt, stream_offset off, stream_offset len) + : basic_adapter(flt), beg_(off), pos_(off), end_(off + len), open_(false) -{ +{ if (len < 0 || off < 0) throw BOOST_IOSTREAMS_FAILURE("bad offset"); }