/Src/Dependencies/Boost/boost/spirit/home/support/char_set/basic_chset.hpp

  1/*=============================================================================
  2    Copyright (c) 2001-2011 Joel de Guzman
  3    Copyright (c) 2001-2009 Daniel Nuffer
  4    http://spirit.sourceforge.net/
  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#ifndef BOOST_SPIRIT_BASIC_CHSET_APRIL_17_2008
 10#define BOOST_SPIRIT_BASIC_CHSET_APRIL_17_2008
 11
 12#if defined(_MSC_VER)
 13#pragma once
 14#endif
 15
 16///////////////////////////////////////////////////////////////////////////////
 17#include <bitset>
 18#include <climits> 
 19#include <boost/spirit/home/support/char_set/range_run.hpp>
 20
 21namespace boost { namespace spirit { namespace support { namespace detail
 22{
 23    ///////////////////////////////////////////////////////////////////////////
 24    //
 25    //  basic_chset: basic character set implementation using range_run
 26    //
 27    ///////////////////////////////////////////////////////////////////////////
 28    template <typename Char>
 29    struct basic_chset
 30    {
 31        basic_chset() {}
 32        basic_chset(basic_chset const& arg_)
 33          : rr(arg_.rr) {}
 34
 35        bool
 36        test(Char v) const
 37        {
 38            return rr.test(v);
 39        }
 40
 41        void
 42        set(Char from, Char to)
 43        {
 44            rr.set(range<Char>(from, to));
 45        }
 46
 47        void
 48        set(Char c)
 49        {
 50            rr.set(range<Char>(c, c));
 51        }
 52
 53        void
 54        clear(Char from, Char to)
 55        {
 56            rr.clear(range<Char>(from, to));
 57        }
 58
 59        void
 60        clear(Char c)
 61        {
 62            rr.clear(range<Char>(c, c));
 63        }
 64
 65        void
 66        clear()
 67        {
 68            rr.clear();
 69        }
 70
 71        void
 72        inverse()
 73        {
 74            basic_chset inv;
 75            inv.set(
 76                (std::numeric_limits<Char>::min)(),
 77                (std::numeric_limits<Char>::max)()
 78            );
 79            inv -= *this;
 80            swap(inv);
 81        }
 82
 83        void
 84        swap(basic_chset& x)
 85        {
 86            rr.swap(x.rr);
 87        }
 88
 89
 90        basic_chset&
 91        operator|=(basic_chset const& x)
 92        {
 93            typedef typename range_run<Char>::const_iterator const_iterator;
 94            for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
 95                rr.set(*iter);
 96            return *this;
 97        }
 98
 99        basic_chset&
100        operator&=(basic_chset const& x)
101        {
102            basic_chset inv;
103            inv.set(
104                (std::numeric_limits<Char>::min)(),
105                (std::numeric_limits<Char>::max)()
106            );
107            inv -= x;
108            *this -= inv;
109            return *this;
110        }
111
112        basic_chset&
113        operator-=(basic_chset const& x)
114        {
115            typedef typename range_run<Char>::const_iterator const_iterator;
116            for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
117                rr.clear(*iter);
118            return *this;
119        }
120
121        basic_chset&
122        operator^=(basic_chset const& x)
123        {
124            basic_chset bma = x;
125            bma -= *this;
126            *this -= x;
127            *this |= bma;
128            return *this;
129        }
130
131        private: range_run<Char> rr;
132    };
133
134#if (CHAR_BIT == 8)
135
136    ///////////////////////////////////////////////////////////////////////////
137    //
138    //  basic_chset: specializations for 8 bit chars using std::bitset
139    //
140    ///////////////////////////////////////////////////////////////////////////
141    template <typename Char>
142    struct basic_chset_8bit
143    {
144        basic_chset_8bit() {}
145        basic_chset_8bit(basic_chset_8bit const& arg_)
146          : bset(arg_.bset) {}
147
148        bool
149        test(Char v) const
150        {
151            return bset.test((unsigned char)v);
152        }
153
154        void
155        set(Char from, Char to)
156        {
157            for (int i = from; i <= to; ++i)
158                bset.set((unsigned char)i);
159        }
160
161        void
162        set(Char c)
163        {
164            bset.set((unsigned char)c);
165        }
166
167        void
168        clear(Char from, Char to)
169        {
170            for (int i = from; i <= to; ++i)
171                bset.reset((unsigned char)i);
172        }
173
174        void
175        clear(Char c)
176        {
177            bset.reset((unsigned char)c);
178        }
179
180        void
181        clear()
182        {
183            bset.reset();
184        }
185
186        void
187        inverse()
188        {
189            bset.flip();
190        }
191
192        void
193        swap(basic_chset_8bit& x)
194        {
195            std::swap(bset, x.bset);
196        }
197
198        basic_chset_8bit&
199        operator|=(basic_chset_8bit const& x)
200        {
201            bset |= x.bset;
202            return *this;
203        }
204
205        basic_chset_8bit&
206        operator&=(basic_chset_8bit const& x)
207        {
208            bset &= x.bset;
209            return *this;
210        }
211
212        basic_chset_8bit&
213        operator-=(basic_chset_8bit const& x)
214        {
215            bset &= ~x.bset;
216            return *this;
217        }
218
219        basic_chset_8bit&
220        operator^=(basic_chset_8bit const& x)
221        {
222            bset ^= x.bset;
223            return *this;
224        }
225
226        private: std::bitset<256> bset;
227    };
228
229    /////////////////////////////////
230    template <>
231    struct basic_chset<char>
232      : basic_chset_8bit<char> {};
233
234    /////////////////////////////////
235    template <>
236    struct basic_chset<signed char>
237      : basic_chset_8bit<signed char> {};
238
239    /////////////////////////////////
240    template <>
241    struct basic_chset<unsigned char>
242      : basic_chset_8bit<unsigned char> {};
243
244#endif // #if (CHAR_BIT == 8)
245
246}}}}
247
248#endif
249