PageRenderTime 75ms CodeModel.GetById 66ms app.highlight 6ms RepoModel.GetById 1ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/spirit/home/support/utree/detail/utree_detail1.hpp

http://hadesmem.googlecode.com/
C++ Header | 146 lines | 82 code | 26 blank | 38 comment | 0 complexity | 88e3eac41b2572c495fb8e68ac9d0565 MD5 | raw file
  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