ceph/src/boost/tools/quickbook/src/values_parse.hpp

   1 /*=============================================================================
   2     Copyright (c) 2010-2011 Daniel James
   3
   4     Use, modification and distribution is subject to the Boost Software
   5     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   6     http://www.boost.org/LICENSE_1_0.txt)
   7 =============================================================================*/
   8
   9 #if !defined(BOOST_SPIRIT_QUICKBOOK_VALUES_PARSE_HPP)
  10 #define BOOST_SPIRIT_QUICKBOOK_VALUES_PARSE_HPP
  11
  12 #include "values.hpp"
  13 #include "parsers.hpp"
  14 #include "scoped.hpp"
  15 #include <boost/spirit/include/phoenix1_functions.hpp>
  16
  17 #include <iostream>
  18
  19 namespace quickbook {
  20     namespace ph = phoenix;
  21
  22     struct value_builder_save : scoped_action_base
  23     {
  24         explicit value_builder_save(value_builder& builder_) : builder(builder_) {}
  25
  26         bool start()
  27         {
  28             builder.save();
  29             return true;
  30         }
  31
  32         void cleanup() { builder.restore(); }
  33
  34         value_builder& builder;
  35
  36     private:
  37         value_builder_save& operator=(value_builder_save const&);
  38     };
  39
  40     struct value_builder_list : scoped_action_base
  41     {
  42         explicit value_builder_list(value_builder& builder_) : builder(builder_) {}
  43
  44         bool start(value::tag_type tag = value::default_tag)
  45         {
  46             builder.start_list(tag);
  47             return true;
  48         }
  49
  50         void success(parse_iterator, parse_iterator) { builder.finish_list(); }
  51         void failure() { builder.clear_list(); }
  52
  53         value_builder& builder;
  54
  55     private:
  56         value_builder_list& operator=(value_builder_list const&);
  57     };
  58
  59     struct value_entry
  60     {
  61         template <typename Arg1, typename Arg2 = void, typename Arg3 = void, typename Arg4 = void>
  62         struct result {
  63             typedef void type;
  64         };
  65
  66         explicit value_entry(value_builder& builder_, file_ptr* current_file_)
  67             : builder(builder_), current_file(current_file_) {}
  68
  69         void operator()(parse_iterator begin, parse_iterator end,
  70                 value::tag_type tag = value::default_tag) const
  71         {
  72             builder.insert(qbk_value(*current_file, begin.base(), end.base(), tag));
  73         }
  74
  75         void operator()(int v,
  76             value::tag_type tag = value::default_tag) const
  77         {
  78             builder.insert(int_value(v, tag));
  79         }
  80
  81         value_builder& builder;
  82         file_ptr* current_file;
  83
  84     private:
  85         value_entry& operator=(value_entry const&);
  86     };
  87
  88     struct value_sort
  89     {
  90         typedef void result_type;
  91
  92         explicit value_sort(value_builder& builder_)
  93             : builder(builder_) {}
  94
  95         void operator()() const {
  96             builder.sort_list();
  97         }
  98
  99         value_builder& builder;
 100
 101     private:
 102         value_sort& operator=(value_sort const&);
 103     };
 104
 105     struct value_parser
 106     {
 107         explicit value_parser(file_ptr* current_file)
 108             : builder()
 109             , save(value_builder_save(builder))
 110             , list(value_builder_list(builder))
 111             , entry(value_entry(builder, current_file))
 112             , sort(value_sort(builder))
 113             {}
 114
 115         value release() { return builder.release(); }
 116
 117         value_builder builder;
 118         scoped_parser<value_builder_save> save;
 119         scoped_parser<value_builder_list> list;
 120         ph::function<value_entry> entry;
 121         ph::function<value_sort> sort;
 122     };
 123 }
 124
 125 #endif