<code> Listing B #include <iostream> #include <string> #include <list> #include <vector> template< class Function> class basic_range_writer {public: basic_range_writer( Function f) : m_f( f) {} template< class CharType, class CharTraits> void write_prefix( std::basic_ostream< CharType, CharTraits> & streamOut) { // default - don't write any prefix } template< class CharType, class CharTraits> void write_after_element( std::basic_ostream< CharType, CharTraits> & streamOut) { // default - write ", " static std::basic_string< CharType> strDefault = std::basic_string< CharType>() + ( CharType)',' + ( CharType)' '; streamOut << strDefault; } template< class CharType, class CharTraits> void write_suffix( std::basic_ostream< CharType, CharTraits> & streamOut) { // default - write " " static std::basic_string< CharType> strDefault = std::basic_string< CharType>() + ( CharType)' '; streamOut << strDefault; } Function m_f; }; template< class Function, class CharType> class range_writer {public: range_writer( Function f, const CharType * strPrefix, const CharType * strAfterElement, const CharType * strSuffix) : m_f( f), m_strPrefix( strPrefix), m_strAfterElement( strAfterElement), m_strSuffix( strSuffix) {} // ... no suffix, no prefix range_writer( Function f, const CharType * strAfterElement) : m_f( f), m_strAfterElement( strAfterElement) {} template< class CharTraits> void write_prefix( std::basic_ostream< CharType, CharTraits> & streamOut) { streamOut << m_strPrefix; } template< class CharTraits> void write_after_element( std::basic_ostream< CharType, CharTraits> & streamOut) { streamOut << m_strAfterElement; } template< class CharTraits> void write_suffix( std::basic_ostream< CharType, CharTraits> & streamOut) { streamOut << m_strSuffix; } Function m_f; std::basic_string< CharType> m_strPrefix, m_strAfterElement, m_strSuffix; }; template< class Iterator, class FormatterClass> class range_with_formatter {public: range_with_formatter( Iterator itFirst, Iterator itLast, FormatterClass formatter) : m_itFirst( itFirst), m_itLast( itLast), m_formatter( formatter) {} template< class Container> range_with_formatter( Container & cont, FormatterClass formatter) : m_itFirst( cont.begin()), m_itLast( cont.end()), m_formatter( formatter) {} Iterator m_itFirst, m_itLast; FormatterClass m_formatter; }; // allow writing range_with_formatter to streams template< class CharType, class CharTraits, class Iterator, class FormatterClass> std::basic_ostream< CharType, CharTraits> & operator<< ( std::basic_ostream< CharType, CharTraits> & streamOut, range_with_formatter< Iterator, FormatterClass> & range) { Iterator itFirst = range.m_itFirst, itLast = range.m_itLast; range.m_formatter.write_prefix( streamOut); while ( itFirst != itLast) { // write the element, formatted!!! range.m_formatter.m_f( streamOut, *itFirst); ++itFirst; if ( itFirst != itLast) { range.m_formatter.write_after_element( streamOut); } else { // last element } } range.m_formatter.write_suffix( streamOut); return streamOut; } // (Helper - used below, for range( Iterator, Iterator) function) // default formatter for elements - just writes them to the stream class default_transformation {public: template< class StreamType, class Type> void operator() ( StreamType & streamOut, const Type & value) { streamOut << value; } }; // // allow returning formatters // // ... provide only the transformer function - for each element // (default prefix, after element, suffix) template< class Function> basic_range_writer< Function> formatter( Function f) { return basic_range_writer< Function>( f); } // ... provide the transformer function - for each element // AND prefix, after element, suffix template< class Function, class CharType> range_writer< Function, CharType> formatter( Function f, const CharType * strPrefix, const CharType * strAfterElement, const CharType * strSuffix) { return range_writer< Function, CharType>( f, strPrefix, strAfterElement, strSuffix); } // ... provide the transformer function - for each element // AND the after element (no suffix, no prefix - they are empty) template< class Function, class CharType> range_writer< Function, CharType> formatter( Function f, const CharType * strAfterElement) { return range_writer< Function, CharType>( f, strAfterElement); } // ... provide the prefix, after element, suffix // (default transformer) template< class CharType> range_writer< default_transformation, CharType> formatter( const CharType * strPrefix, const CharType * strAfterElement, const CharType * strSuffix) { return range_writer< default_transformation, CharType>( default_transformation(), strPrefix, strAfterElement, strSuffix); } // // allow printing ranges // // Range with formatter // (you provide the beginning & end of the range AND the formatter) template< class Iterator, class FormatterClass > range_with_formatter< Iterator, FormatterClass> range( Iterator itFirst, Iterator itLast, FormatterClass formatter) { return range_with_formatter< Iterator, FormatterClass>( itFirst, itLast, formatter); } // Range with default formatter // (you provide the beginning & end of the range; you're provided a default formatter, // which just writes the elements) template< class Iterator> range_with_formatter< Iterator, basic_range_writer< default_transformation> > range( Iterator itFirst, Iterator itLast) { default_transformation default_format; basic_range_writer< default_transformation> formatter( default_format); return range_with_formatter< Iterator, basic_range_writer< default_transformation> >( itFirst, itLast, formatter); } // // allow printing containers // // Continer with formatter // (you provide the Container AND the formatter) template< class Container, class FormatterClass > range_with_formatter< typename Container::const_iterator, FormatterClass> container( const Container & cont, FormatterClass formatter) { return range_with_formatter< typename Container::const_iterator, FormatterClass>( cont.begin(), cont.end(), formatter); } // Container with default formatter // (you provide the container; you're provided a default formatter, // which just writes the elements) template< class Container> range_with_formatter< typename Container::const_iterator, basic_range_writer< default_transformation> > container( const Container & cont) { default_transformation default_format; basic_range_writer< default_transformation> formatter( default_format); return range_with_formatter< typename Container::const_iterator, basic_range_writer< default_transformation> >( cont.begin(), cont.end(), formatter); } ////////////////////////////////////////////// // EXAMPLES // prefix each element by its index class PrefixByIndex {public: PrefixByIndex() : m_idxCurrent( 0) {} template< class StreamType, class Type> void operator()( StreamType & streamOut, const Type & value) { streamOut << "[" << m_idxCurrent << "] " << value; ++ m_idxCurrent; } private: int m_idxCurrent; }; int _tmain(int argc, _TCHAR* argv[]) { /////////////////////////////////////////////////////////// // printing ranges // printing C-like array of numbers int aMonths [] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; int nMonthsCount = ( sizeof( aMonths) / sizeof( aMonths[ 0])); std::cout << range( aMonths, aMonths + nMonthsCount ) << std::endl ; typedef std::list< std::string> StringsArray; StringsArray aNames; aNames.push_back( "John"); aNames.push_back( "James"); aNames.push_back( "Corina"); // printing as range std::cout << range( aNames.begin(), aNames.end() ) << std::endl ; /////////////////////////////////////////////////////////// // printing containers std::cout << container( aNames) << std::endl ; std::cout << container( aNames, formatter( "{", "}, {", "}") ) << std::endl ; std::cout << container( aNames, formatter( PrefixByIndex(), "{", "}, {","}") ) << std::endl ; std::cout << container( aNames, formatter( PrefixByIndex(), ", ") ) << std::endl ; std::cout << container( aNames, formatter( "[", "]\n[", "]") ) << std::endl ; std::cout << container( aNames, formatter( PrefixByIndex(), "'", "'\n'", "'") ) << std::endl ; std::cout << container( aNames, formatter( PrefixByIndex(), "\n") ) << std::endl ; return 0; } </code> | 