m_count = 0; return; } ++m_count; ++(this->base_reference()); } CharType dereference() const { if(m_count == N) return '\n'; return * (this->base_reference()); } unsigned int m_count; public: // make composible buy using templated constructor template<class T> insert_linebreaks(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), m_count(0) {} // intel 7.1 doesn't like default copy constructor insert_linebreaks(const insert_linebreaks & rhs) : super_t(rhs.base_reference()), m_count(rhs.m_count) {} }; } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
m_bend = m_bnext = 0; ++(this->base_reference()); m_full = false; } // buffer to handle pending characters int m_bend; int m_bnext; char m_buffer[9]; bool m_full; public: // make composible buy using templated constructor template<class T> mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), m_bend(0), m_bnext(0), m_full(false) {} // intel 7.1 doesn't like default copy constructor mb_from_wchar(const mb_from_wchar & rhs) : super_t(rhs.base_reference()), m_bend(rhs.m_bend), m_bnext(rhs.m_bnext), m_full(rhs.m_full) {} }; } // namespace iterators
reference_type dereference() const { return unescape<xml_unescape<Base>, Base>::dereference(); } public: // workaround msvc 7.1 ICU crash #if defined(BOOST_MSVC) typedef int value_type; #else typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type; #endif void drain_residue(const char *literal); value_type drain(); template<class T> xml_unescape(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))) {} // intel 7.1 doesn't like default copy constructor xml_unescape(const xml_unescape & rhs) : super_t(rhs.base_reference()) {} }; template<class Base> void xml_unescape<Base>::drain_residue(const char * literal){ do{ if(* literal != * ++(this->base_reference())) boost::serialization::throw_exception( dataflow_exception( dataflow_exception::invalid_xml_escape_sequence
> class binary_from_base64 : public transform_iterator< detail::to_6_bit<CharType>, Base > { friend class boost::iterator_core_access; typedef transform_iterator< detail::to_6_bit<CharType>, Base > super_t; public: // make composible buy using templated constructor template<class T> binary_from_base64(BOOST_PFTO_WRAPPER(T) start) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))), detail::to_6_bit<CharType>() ) {} // intel 7.1 doesn't like default copy constructor binary_from_base64(const binary_from_base64 & rhs) : super_t( Base(rhs.base_reference()), detail::to_6_bit<CharType>() ) {} // binary_from_base64(){}; };
template<class Base> class remove_whitespace : public filter_iterator< remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>, Base > { friend class boost::iterator_core_access; typedef filter_iterator< remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>, Base > super_t; public: // remove_whitespace(){} // why is this needed? // make composible buy using templated constructor template<class T> remove_whitespace(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))) {} // intel 7.1 doesn't like default copy constructor remove_whitespace(const remove_whitespace & rhs) : super_t(rhs.base_reference()) {} }; } // namespace iterators } // namespace archive } // namespace boost #endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
m_full = false; } CharType m_current_value; // number of bits left in current input character buffer unsigned int m_displacement; base_value_type m_buffer; // flag to current output character is ready - just used to save time bool m_full; // flag to indicate that m_buffer has data bool m_bufferfull; public: // make composible buy using templated constructor template<class T> transform_width(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), m_displacement(0), m_full(false), m_bufferfull(false) {} // intel 7.1 doesn't like default copy constructor transform_width(const transform_width & rhs) : super_t(rhs.base_reference()), m_current_value(rhs.m_current_value), m_displacement(rhs.m_displacement), m_buffer(rhs.m_buffer), m_full(rhs.m_full), m_bufferfull(rhs.m_bufferfull) {} };
return const_cast<this_t *>(this)->dereference_impl(); } void increment(){ dereference_impl(); m_full = false; ++(this->base_reference()); }; wchar_t m_current_value; bool m_full; public: // make composible buy using templated constructor template<class T> wchar_from_mb(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), m_full(false) {} // intel 7.1 doesn't like default copy constructor wchar_from_mb(const wchar_from_mb & rhs) : super_t(rhs.base_reference()), m_full(rhs.m_full) {} }; template<class Base> wchar_t wchar_from_mb<Base>::drain(){ char buffer[9]; char * bptr = buffer; char val;
> class stateful_base64_from_binary : public transform_iterator< detail::from_6_bit<CharType>, Base > { friend class boost::iterator_core_access; typedef transform_iterator< typename detail::from_6_bit<CharType>, Base > super_t; public: template<class T, class State> stateful_base64_from_binary(BOOST_PFTO_WRAPPER(T) start, BOOST_PFTO_WRAPPER(T) end, State & state) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)), end, state), detail::from_6_bit<CharType>() ) {} template<class T> stateful_base64_from_binary(BOOST_PFTO_WRAPPER(T) start) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start))), detail::from_6_bit<CharType>() ) {} // intel 7.1 doesn't like default copy constructor