1/*=============================================================================
2 Copyright (c) 2001-2011 Joel de Guzman
3 Copyright (c) 2001-2011 Hartmut Kaiser
4 Copyright (c) 2011 Bryce Lelbach
5
6 Distributed under the Boost Software License, Version 1.0. (See accompanying
7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8=============================================================================*/
9#if !defined(BOOST_SPIRIT_UTREE_DETAIL1)
10#define BOOST_SPIRIT_UTREE_DETAIL1
11
12#include <boost/type_traits/alignment_of.hpp>
13
14namespace boost { namespace spirit { namespace detail
15{
16 template <typename UTreeX, typename UTreeY>
17 struct visit_impl;
18
19 struct index_impl;
20
21 ///////////////////////////////////////////////////////////////////////////
22 // Our POD double linked list. Straightforward implementation.
23 // This implementation is very primitive and is not meant to be
24 // used stand-alone. This is the internal data representation
25 // of lists in our utree.
26 ///////////////////////////////////////////////////////////////////////////
27 struct list // keep this a POD!
28 {
29 struct node;
30
31 template <typename Value>
32 class node_iterator;
33
34 void free();
35 void copy(list const& other);
36 void default_construct();
37
38 template <typename T, typename Iterator>
39 void insert(T const& val, Iterator pos);
40
41 template <typename T>
42 void push_front(T const& val);
43
44 template <typename T>
45 void push_back(T const& val);
46
47 void pop_front();
48 void pop_back();
49 node* erase(node* pos);
50
51 node* first;
52 node* last;
53 std::size_t size;
54 };
55
56 ///////////////////////////////////////////////////////////////////////////
57 // A range of utree(s) using an iterator range (begin/end) of node(s)
58 ///////////////////////////////////////////////////////////////////////////
59 struct range
60 {
61 list::node* first;
62 list::node* last;
63 };
64
65 ///////////////////////////////////////////////////////////////////////////
66 // A range of char*s
67 ///////////////////////////////////////////////////////////////////////////
68 struct string_range
69 {
70 char const* first;
71 char const* last;
72 };
73
74 ///////////////////////////////////////////////////////////////////////////
75 // A void* plus type_info
76 ///////////////////////////////////////////////////////////////////////////
77 struct void_ptr
78 {
79 void* p;
80 std::type_info const* i;
81 };
82
83 ///////////////////////////////////////////////////////////////////////////
84 // Our POD fast string. This implementation is very primitive and is not
85 // meant to be used stand-alone. This is the internal data representation
86 // of strings in our utree. This is deliberately a POD to allow it to be
87 // placed in a union. This POD fast string specifically utilizes
88 // (sizeof(list) * alignment_of(list)) - (2 * sizeof(char)). In a 32 bit
89 // system, this is 14 bytes. The two extra bytes are used by utree to store
90 // management info.
91 //
92 // It is a const string (i.e. immutable). It stores the characters directly
93 // if possible and only uses the heap if the string does not fit. Null
94 // characters are allowed, making it suitable to encode raw binary. The
95 // string length is encoded in the first byte if the string is placed in-situ,
96 // else, the length plus a pointer to the string in the heap are stored.
97 ///////////////////////////////////////////////////////////////////////////
98 struct fast_string // Keep this a POD!
99 {
100 static std::size_t const
101 buff_size = (sizeof(list) + boost::alignment_of<list>::value)
102 / sizeof(char);
103
104 static std::size_t const
105 small_string_size = buff_size-sizeof(char);
106
107 static std::size_t const
108 max_string_len = small_string_size - 3;
109
110 struct heap_store
111 {
112 char* str;
113 std::size_t size;
114 };
115
116 union
117 {
118 char buff[buff_size];
119 long lbuff[buff_size / (sizeof(long)/sizeof(char))]; // for initialize
120 heap_store heap;
121 };
122
123 int get_type() const;
124 void set_type(int t);
125 bool is_heap_allocated() const;
126
127 std::size_t size() const;
128 char const* str() const;
129
130 template <typename Iterator>
131 void construct(Iterator f, Iterator l);
132
133 void swap(fast_string& other);
134 void free();
135 void copy(fast_string const& other);
136 void initialize();
137
138 char& info();
139 char info() const;
140
141 short tag() const;
142 void tag(short tag);
143 };
144}}}
145
146#endif
147

source code of boost/libs/spirit/include/boost/spirit/home/support/utree/detail/utree_detail1.hpp