169 lines
5.2 KiB
C++
169 lines
5.2 KiB
C++
// (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_AGGREGATE_FILTER_HPP_INCLUDED
|
|
#define BOOST_IOSTREAMS_AGGREGATE_FILTER_HPP_INCLUDED
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
|
# pragma once
|
|
#endif
|
|
|
|
#include <algorithm> // copy, min.
|
|
#include <boost/assert.hpp>
|
|
#include <iterator> // back_inserter
|
|
#include <vector>
|
|
#include <boost/iostreams/constants.hpp> // default_device_buffer_size
|
|
#include <boost/iostreams/categories.hpp>
|
|
#include <boost/iostreams/detail/char_traits.hpp>
|
|
#include <boost/iostreams/detail/ios.hpp> // openmode, streamsize.
|
|
#include <boost/iostreams/pipeline.hpp>
|
|
#include <boost/iostreams/read.hpp> // check_eof
|
|
#include <boost/iostreams/write.hpp>
|
|
#include <boost/mpl/bool.hpp>
|
|
#include <boost/type_traits/is_convertible.hpp>
|
|
|
|
// Must come last.
|
|
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
|
|
|
|
namespace boost { namespace iostreams {
|
|
|
|
//
|
|
// Template name: aggregate_filter.
|
|
// Template parameters:
|
|
// Ch - The character type.
|
|
// Alloc - The allocator type.
|
|
// Description: Utility for defining DualUseFilters which filter an
|
|
// entire stream at once. To use, override the protected virtual
|
|
// member do_filter.
|
|
// Note: This filter should not be copied while it is in use.
|
|
//
|
|
template<typename Ch, typename Alloc = std::allocator<Ch> >
|
|
class aggregate_filter {
|
|
public:
|
|
typedef Ch char_type;
|
|
struct category
|
|
: dual_use,
|
|
filter_tag,
|
|
multichar_tag,
|
|
closable_tag
|
|
{ };
|
|
aggregate_filter() : ptr_(0), state_(0) { }
|
|
virtual ~aggregate_filter() { }
|
|
|
|
template<typename Source>
|
|
std::streamsize read(Source& src, char_type* s, std::streamsize n)
|
|
{
|
|
using namespace std;
|
|
BOOST_ASSERT(!(state_ & f_write));
|
|
state_ |= f_read;
|
|
if (!(state_ & f_eof))
|
|
do_read(src);
|
|
std::streamsize amt =
|
|
(std::min)(n, static_cast<std::streamsize>(data_.size() - ptr_));
|
|
if (amt) {
|
|
BOOST_IOSTREAMS_CHAR_TRAITS(char_type)::copy(s, &data_[ptr_], amt);
|
|
ptr_ += amt;
|
|
}
|
|
return detail::check_eof(amt);
|
|
}
|
|
|
|
template<typename Sink>
|
|
std::streamsize write(Sink&, const char_type* s, std::streamsize n)
|
|
{
|
|
BOOST_ASSERT(!(state_ & f_read));
|
|
state_ |= f_write;
|
|
data_.insert(data_.end(), s, s + n);
|
|
return n;
|
|
}
|
|
|
|
template<typename Sink>
|
|
void close(Sink& sink, BOOST_IOS::openmode which)
|
|
{
|
|
if ((state_ & f_read) != 0 && which == BOOST_IOS::in)
|
|
close_impl();
|
|
if ((state_ & f_write) != 0 && which == BOOST_IOS::out) {
|
|
try {
|
|
vector_type filtered;
|
|
do_filter(data_, filtered);
|
|
do_write(
|
|
sink, &filtered[0],
|
|
static_cast<std::streamsize>(filtered.size())
|
|
);
|
|
} catch (...) {
|
|
close_impl();
|
|
throw;
|
|
}
|
|
close_impl();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
typedef std::vector<Ch, Alloc> vector_type;
|
|
typedef typename vector_type::size_type size_type;
|
|
private:
|
|
virtual void do_filter(const vector_type& src, vector_type& dest) = 0;
|
|
virtual void do_close() { }
|
|
|
|
template<typename Source>
|
|
void do_read(Source& src)
|
|
{
|
|
using std::streamsize;
|
|
vector_type data;
|
|
while (true) {
|
|
const std::streamsize size = default_device_buffer_size;
|
|
Ch buf[size];
|
|
std::streamsize amt;
|
|
if ((amt = boost::iostreams::read(src, buf, size)) == -1)
|
|
break;
|
|
data.insert(data.end(), buf, buf + amt);
|
|
}
|
|
do_filter(data, data_);
|
|
state_ |= f_eof;
|
|
}
|
|
|
|
template<typename Sink>
|
|
void do_write(Sink& sink, const char_type* s, std::streamsize n)
|
|
{
|
|
typedef typename iostreams::category_of<Sink>::type category;
|
|
typedef is_convertible<category, output> can_write;
|
|
do_write(sink, s, n, can_write());
|
|
}
|
|
|
|
template<typename Sink>
|
|
void do_write(Sink& sink, const char_type* s, std::streamsize n, mpl::true_)
|
|
{ iostreams::write(sink, s, n); }
|
|
|
|
template<typename Sink>
|
|
void do_write(Sink&, const char_type*, std::streamsize, mpl::false_) { }
|
|
|
|
void close_impl()
|
|
{
|
|
data_.clear();
|
|
ptr_ = 0;
|
|
state_ = 0;
|
|
do_close();
|
|
}
|
|
|
|
enum flag_type {
|
|
f_read = 1,
|
|
f_write = f_read << 1,
|
|
f_eof = f_write << 1
|
|
};
|
|
|
|
// Note: typically will not be copied while vector contains data.
|
|
vector_type data_;
|
|
size_type ptr_;
|
|
int state_;
|
|
};
|
|
BOOST_IOSTREAMS_PIPABLE(aggregate_filter, 1)
|
|
|
|
} } // End namespaces iostreams, boost.
|
|
|
|
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
|
|
|
|
#endif // #ifndef BOOST_IOSTREAMS_AGGREGATE_FILTER_HPP_INCLUDED
|