| // Copyright (c) 2001-2010 Hartmut Kaiser |
| // |
| // 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) |
| |
| // The main purpose of this example is to show the uniform and easy way of |
| // output formatting for different container types. |
| // |
| // The 'auto_' primitive used below is very similar to the 'stream' primitive |
| // demonstrated in the example 'basic_facilities.cpp' as it allows to generate |
| // output from a multitude of data types. The main difference is that it is |
| // mapped to the correct Karma generator instead of using any available |
| // operator<<() for the contained data type. Additionally this means, that |
| // the format descriptions used below will be usable for any contained type as |
| // long as this type has a defined mapping to a Karma generator. |
| |
| // use a larger value for the alignment field width (default is 10) |
| #define BOOST_KARMA_DEFAULT_FIELD_LENGTH 25 |
| |
| #include <boost/config/warning_disable.hpp> |
| |
| #include <iostream> |
| #include <string> |
| #include <vector> |
| #include <list> |
| #include <map> |
| #include <algorithm> |
| #include <cstdlib> |
| |
| #include <boost/range.hpp> |
| #include <boost/array.hpp> |
| #include <boost/fusion/include/std_pair.hpp> |
| #include <boost/fusion/include/array.hpp> |
| |
| #include <boost/spirit/include/karma.hpp> |
| |
| using namespace boost::spirit; |
| using namespace boost::spirit::ascii; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { namespace traits |
| { |
| // We add a specialization for the create_generator customization point |
| // defining a custom output format for the value type of the std::map used |
| // below (std::pair<int const, std::string>). Generally, any specialization |
| // for create_generator is expected to return the proto expression to be |
| // used to generate output for the type the customization point has been |
| // specialized for. |
| // |
| // We need to utilize proto::deep_copy as the expression contains a literal |
| // (the ':') which normally gets embedded in the proto expression by |
| // reference only. The deep copy converts the proto tree to hold this by |
| // value. The deep copy operation can be left out for simpler proto |
| // expressions (not containing references to temporaries). Alternatively |
| // you could use the proto::make_expr() facility to build the required |
| // proto expression. |
| template <> |
| struct create_generator<std::pair<int const, std::string> > |
| { |
| typedef proto::result_of::deep_copy< |
| BOOST_TYPEOF(int_ << ':' << string) |
| >::type type; |
| |
| static type call() |
| { |
| return proto::deep_copy(int_ << ':' << string); |
| } |
| }; |
| }}} |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Output the given containers in list format |
| // Note: the format description does not depend on the type of the sequence |
| // nor does it depend on the type of the elements contained in the |
| // sequence |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename Container> |
| void output_container(std::ostream& os, Container const& c) |
| { |
| // output the container as a sequence without separators |
| os << |
| karma::format( |
| auto_, // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format( |
| *auto_, // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| // output the container as a space separated sequence |
| os << |
| karma::format_delimited( |
| auto_, // format description |
| space, // delimiter |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format_delimited( |
| *auto_, // format description |
| space, // delimiter |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format_delimited( |
| '[' << *auto_ << ']', // format description |
| space, // delimiter |
| c // data |
| ) << std::endl << std::endl; |
| |
| // output the container as a comma separated list |
| os << |
| karma::format( |
| auto_ % ", ", // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format( |
| '[' << (auto_ % ", ") << ']', // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format( |
| '[' << -(auto_ % ", ") << ']', // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format( |
| '[' << (+auto_ | "empty") << ']', // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| // output the container as a comma separated list of items enclosed in '()' |
| os << |
| karma::format( |
| ('(' << auto_ << ')') % ", ", // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| os << |
| karma::format( |
| '[' << ( |
| ('(' << auto_ << ')') % ", " |
| ) << ']', // format description |
| c // data |
| ) << std::endl << std::endl; |
| |
| // output the container as a HTML list |
| os << |
| karma::format_delimited( |
| "<ol>" << |
| *verbatim["<li>" << auto_ << "</li>"] |
| << "</ol>", // format description |
| '\n', // delimiter |
| c // data |
| ) << std::endl; |
| |
| // output the container as right aligned column |
| os << |
| karma::format_delimited( |
| *verbatim[ |
| "|" << right_align[auto_] << "|" |
| ], // format description |
| '\n', // delimiter |
| c // data |
| ) << std::endl; |
| |
| os << std::endl; |
| } |
| |
| int main() |
| { |
| /////////////////////////////////////////////////////////////////////////// |
| // C-style array |
| int i[4] = { 3, 6, 9, 12 }; |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "int i[]" << std::endl; |
| output_container(std::cout, boost::make_iterator_range(i, i+4)); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // vector |
| std::vector<int> v (5); |
| std::generate(v.begin(), v.end(), std::rand); // randomly fill the vector |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "std::vector<int>" << std::endl; |
| output_container(std::cout, v); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // list |
| std::list<char> l; |
| l.push_back('A'); |
| l.push_back('B'); |
| l.push_back('C'); |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "std::list<char>" << std::endl; |
| output_container(std::cout, l); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // strings |
| std::string str("Hello world!"); |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "std::string" << std::endl; |
| output_container(std::cout, str); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // boost::array |
| boost::array<long, 5> arr; |
| std::generate(arr.begin(), arr.end(), std::rand); // randomly fill the array |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "boost::array<long, 5>" << std::endl; |
| output_container(std::cout, arr); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // map of int --> string mappings |
| std::map<int, std::string> mappings; |
| mappings.insert(std::make_pair(0, "zero")); |
| mappings.insert(std::make_pair(1, "one")); |
| mappings.insert(std::make_pair(2, "two")); |
| |
| std::cout << "-------------------------------------------------------------" |
| << std::endl; |
| std::cout << "std::map<int, std::string>" << std::endl; |
| output_container(std::cout, mappings); |
| |
| return 0; |
| } |
| |
