ceph/src/boost/boost/spirit/home/support/info.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2011 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7 #if !defined(BOOST_SPIRIT_INFO_NOVEMBER_22_2008_1132AM)
   8 #define BOOST_SPIRIT_INFO_NOVEMBER_22_2008_1132AM
   9
  10 #if defined(_MSC_VER)
  11 #pragma once
  12 #endif
  13
  14 #include <boost/variant/variant.hpp>
  15 #include <boost/variant/recursive_variant.hpp>
  16 #include <boost/variant/apply_visitor.hpp>
  17 #include <boost/spirit/home/support/utf8.hpp>
  18 #include <list>
  19 #include <iterator>
  20 #include <utility>
  21
  22 namespace boost { namespace spirit
  23 {
  24     // info provides information about a component. Each component
  25     // has a what member function that returns an info object.
  26     // strings in the info object are assumed to be encoded as UTF8
  27     // for uniformity.
  28     struct info
  29     {
  30         struct nil_ {};
  31
  32         typedef
  33             boost::variant<
  34                 nil_
  35               , utf8_string
  36               , recursive_wrapper<info>
  37               , recursive_wrapper<std::pair<info, info> >
  38               , recursive_wrapper<std::list<info> >
  39             >
  40         value_type;
  41
  42         explicit info(utf8_string const& tag_)
  43           : tag(tag_), value(nil_()) {}
  44
  45         template <typename T>
  46         info(utf8_string const& tag_, T const& value_)
  47           : tag(tag_), value(value_) {}
  48
  49         info(utf8_string const& tag_, char value_)
  50           : tag(tag_), value(utf8_string(1, value_)) {}
  51
  52         info(utf8_string const& tag_, wchar_t value_)
  53           : tag(tag_), value(to_utf8(value_)) {}
  54
  55         info(utf8_string const& tag_, ucs4_char value_)
  56           : tag(tag_), value(to_utf8(value_)) {}
  57
  58         template <typename Char>
  59         info(utf8_string const& tag_, Char const* str)
  60           : tag(tag_), value(to_utf8(str)) {}
  61
  62         template <typename Char, typename Traits, typename Allocator>
  63         info(utf8_string const& tag_
  64               , std::basic_string<Char, Traits, Allocator> const& str)
  65           : tag(tag_), value(to_utf8(str)) {}
  66
  67         utf8_string tag;
  68         value_type value;
  69     };
  70
  71     template <typename Callback>
  72     struct basic_info_walker
  73     {
  74         typedef void result_type;
  75         typedef basic_info_walker<Callback> this_type;
  76
  77         basic_info_walker(Callback& callback_, utf8_string const& tag_, int depth_)
  78           : callback(callback_), tag(tag_), depth(depth_) {}
  79
  80         void operator()(info::nil_) const
  81         {
  82             callback.element(tag, "", depth);
  83         }
  84
  85         void operator()(utf8_string const& str) const
  86         {
  87             callback.element(tag, str, depth);
  88         }
  89
  90         void operator()(info const& what) const
  91         {
  92             boost::apply_visitor(
  93                 this_type(callback, what.tag, depth+1), what.value);
  94         }
  95
  96         void operator()(std::pair<info, info> const& pair) const
  97         {
  98             callback.element(tag, "", depth);
  99             boost::apply_visitor(
 100                 this_type(callback, pair.first.tag, depth+1), pair.first.value);
 101             boost::apply_visitor(
 102                 this_type(callback, pair.second.tag, depth+1), pair.second.value);
 103         }
 104
 105         void operator()(std::list<info> const& l) const
 106         {
 107             callback.element(tag, "", depth);
 108             for (std::list<info>::const_iterator it = l.begin(),
 109                                                  end = l.end(); it != end; ++it)
 110             {
 111                 boost::apply_visitor(
 112                     this_type(callback, it->tag, depth+1), it->value);
 113             }
 114         }
 115
 116         Callback& callback;
 117         utf8_string const& tag;
 118         int depth;
 119
 120         // silence MSVC warning C4512: assignment operator could not be generated
 121         BOOST_DELETED_FUNCTION(basic_info_walker& operator= (basic_info_walker const&))
 122     };
 123
 124     // bare-bones print support
 125     template <typename Out>
 126     struct simple_printer
 127     {
 128         typedef utf8_string string;
 129
 130         simple_printer(Out& out_)
 131           : out(out_) {}
 132
 133         void element(string const& tag, string const& value, int /*depth*/) const
 134         {
 135             if (value.empty())
 136                 out << '<' << tag << '>';
 137             else
 138                 out << '"' << value << '"';
 139         }
 140
 141         Out& out;
 142
 143         // silence MSVC warning C4512: assignment operator could not be generated
 144         BOOST_DELETED_FUNCTION(simple_printer& operator= (simple_printer const&))
 145     };
 146
 147     template <typename Out>
 148     Out& operator<<(Out& out, info const& what)
 149     {
 150         simple_printer<Out> pr(out);
 151         basic_info_walker<simple_printer<Out> > walker(pr, what.tag, 0);
 152         boost::apply_visitor(walker, what.value);
 153         return out;
 154     }
 155 }}
 156
 157 #endif