/*============================================================================= | |
Copyright (c) 2001-2011 Joel de Guzman | |
Copyright (c) 2001-2009 Daniel Nuffer | |
http://spirit.sourceforge.net/ | |
Distributed under the Boost Software License, Version 1.0. (See accompanying | |
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
=============================================================================*/ | |
#ifndef BOOST_SPIRIT_BASIC_CHSET_APRIL_17_2008 | |
#define BOOST_SPIRIT_BASIC_CHSET_APRIL_17_2008 | |
#if defined(_MSC_VER) | |
#pragma once | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
#include <bitset> | |
#include <climits> | |
#include <boost/spirit/home/support/char_set/range_run.hpp> | |
namespace boost { namespace spirit { namespace support { namespace detail | |
{ | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// basic_chset: basic character set implementation using range_run | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename Char> | |
struct basic_chset | |
{ | |
basic_chset() {} | |
basic_chset(basic_chset const& arg_) | |
: rr(arg_.rr) {} | |
bool | |
test(Char v) const | |
{ | |
return rr.test(v); | |
} | |
void | |
set(Char from, Char to) | |
{ | |
rr.set(range<Char>(from, to)); | |
} | |
void | |
set(Char c) | |
{ | |
rr.set(range<Char>(c, c)); | |
} | |
void | |
clear(Char from, Char to) | |
{ | |
rr.clear(range<Char>(from, to)); | |
} | |
void | |
clear(Char c) | |
{ | |
rr.clear(range<Char>(c, c)); | |
} | |
void | |
clear() | |
{ | |
rr.clear(); | |
} | |
void | |
inverse() | |
{ | |
basic_chset inv; | |
inv.set( | |
(std::numeric_limits<Char>::min)(), | |
(std::numeric_limits<Char>::max)() | |
); | |
inv -= *this; | |
swap(inv); | |
} | |
void | |
swap(basic_chset& x) | |
{ | |
rr.swap(x.rr); | |
} | |
basic_chset& | |
operator|=(basic_chset const& x) | |
{ | |
typedef typename range_run<Char>::const_iterator const_iterator; | |
for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter) | |
rr.set(*iter); | |
return *this; | |
} | |
basic_chset& | |
operator&=(basic_chset const& x) | |
{ | |
basic_chset inv; | |
inv.set( | |
(std::numeric_limits<Char>::min)(), | |
(std::numeric_limits<Char>::max)() | |
); | |
inv -= x; | |
*this -= inv; | |
return *this; | |
} | |
basic_chset& | |
operator-=(basic_chset const& x) | |
{ | |
typedef typename range_run<Char>::const_iterator const_iterator; | |
for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter) | |
rr.clear(*iter); | |
return *this; | |
} | |
basic_chset& | |
operator^=(basic_chset const& x) | |
{ | |
basic_chset bma = x; | |
bma -= *this; | |
*this -= x; | |
*this |= bma; | |
return *this; | |
} | |
private: range_run<Char> rr; | |
}; | |
#if (CHAR_BIT == 8) | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// basic_chset: specializations for 8 bit chars using std::bitset | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename Char> | |
struct basic_chset_8bit | |
{ | |
basic_chset_8bit() {} | |
basic_chset_8bit(basic_chset_8bit const& arg_) | |
: bset(arg_.bset) {} | |
bool | |
test(Char v) const | |
{ | |
return bset.test((unsigned char)v); | |
} | |
void | |
set(Char from, Char to) | |
{ | |
for (int i = from; i <= to; ++i) | |
bset.set((unsigned char)i); | |
} | |
void | |
set(Char c) | |
{ | |
bset.set((unsigned char)c); | |
} | |
void | |
clear(Char from, Char to) | |
{ | |
for (int i = from; i <= to; ++i) | |
bset.reset((unsigned char)i); | |
} | |
void | |
clear(Char c) | |
{ | |
bset.reset((unsigned char)c); | |
} | |
void | |
clear() | |
{ | |
bset.reset(); | |
} | |
void | |
inverse() | |
{ | |
bset.flip(); | |
} | |
void | |
swap(basic_chset_8bit& x) | |
{ | |
std::swap(bset, x.bset); | |
} | |
basic_chset_8bit& | |
operator|=(basic_chset_8bit const& x) | |
{ | |
bset |= x.bset; | |
return *this; | |
} | |
basic_chset_8bit& | |
operator&=(basic_chset_8bit const& x) | |
{ | |
bset &= x.bset; | |
return *this; | |
} | |
basic_chset_8bit& | |
operator-=(basic_chset_8bit const& x) | |
{ | |
bset &= ~x.bset; | |
return *this; | |
} | |
basic_chset_8bit& | |
operator^=(basic_chset_8bit const& x) | |
{ | |
bset ^= x.bset; | |
return *this; | |
} | |
private: std::bitset<256> bset; | |
}; | |
///////////////////////////////// | |
template <> | |
struct basic_chset<char> | |
: basic_chset_8bit<char> {}; | |
///////////////////////////////// | |
template <> | |
struct basic_chset<signed char> | |
: basic_chset_8bit<signed char> {}; | |
///////////////////////////////// | |
template <> | |
struct basic_chset<unsigned char> | |
: basic_chset_8bit<unsigned char> {}; | |
#endif // #if (CHAR_BIT == 8) | |
}}}} | |
#endif | |