boost_spirit 0.1.0

Boost C++ library boost_spirit packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

// Copyright (c) 2009 Erik Bryan
// Copyright (c) 2007-2010 Hartmut Kaiser
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <string>
#include <vector>

#include <boost/array.hpp>

#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

///////////////////////////////////////////////////////////////////////////////
// create a wrapper holding the boost::array and a current insertion point
namespace client 
{ 
    namespace detail
    {
        template <typename T>
        struct adapt_array;

        template <typename T, std::size_t N>
        struct adapt_array<boost::array<T, N> >
        {
            typedef boost::array<T, N> array_type;

            adapt_array(array_type& arr)
              : arr_(arr), current_(0) {}

            // expose a push_back function compatible with std containers
            bool push_back(typename array_type::value_type const& val)
            {
                // if the array is full, we need to bail out
                // returning false will fail the parse
                if (current_ >= N) 
                    return false;

                arr_[current_++] = val;
                return true;
            }

            array_type& arr_;
            std::size_t current_;
        };
    }

    namespace result_of
    {
        template <typename T>
        struct adapt_array;

        template <typename T, std::size_t N>
        struct adapt_array<boost::array<T, N> >
        {
            typedef detail::adapt_array<boost::array<T, N> > type;
        };
    }

    template <typename T, std::size_t N>
    inline detail::adapt_array<boost::array<T, N> > 
    adapt_array(boost::array<T, N>& arr)
    {
        return detail::adapt_array<boost::array<T, N> >(arr);
    }
}

///////////////////////////////////////////////////////////////////////////////
// specialize Spirit's container specific customization points for our adaptor
namespace boost { namespace spirit { namespace traits
{
    template <typename T, std::size_t N>
     struct is_container<client::detail::adapt_array<boost::array<T, N> > > 
       : boost::mpl::true_
     {};

    template <typename T, std::size_t N>
    struct container_value<client::detail::adapt_array<boost::array<T, N> > >
    {
        typedef T type;     // value type of container
    };

    template <typename T, std::size_t N>
    struct push_back_container<
      client::detail::adapt_array<boost::array<T, N> >, T>
    {
        static bool call(client::detail::adapt_array<boost::array<T, N> >& c
          , T const& val)
        {
            return c.push_back(val);
        }
    };
}}}

int main()
{
    typedef std::string::const_iterator iterator_type;
    typedef boost::array<int, 2> array_type; 
    typedef client::result_of::adapt_array<array_type>::type adapted_type; 

    array_type arr;

    std::string str = "1 2";
    iterator_type iter = str.begin();
    iterator_type end = str.end();

    qi::rule<iterator_type, adapted_type(), ascii::space_type> r = *qi::int_;

    adapted_type attr = client::adapt_array(arr);
    bool result = qi::phrase_parse(iter, end, r, ascii::space, attr);

    if (result) 
        std::cout << "Parsed: " << arr[0] << ", " << arr[1] << std::endl;

    return 0;
}