1 /////////////////////////////////////////////////////////////////////////////// 2 /// \file null_regex_traits.hpp 3 /// Contains the definition of the null_regex_traits\<\> template, which is a 4 /// stub regex traits implementation that can be used by static and dynamic 5 /// regexes for searching non-character data. 6 // 7 // Copyright 2008 Eric Niebler. Distributed under the Boost 8 // Software License, Version 1.0. (See accompanying file 9 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 10 11 #ifndef BOOST_XPRESSIVE_TRAITS_NULL_REGEX_TRAITS_HPP_EAN_10_04_2005 12 #define BOOST_XPRESSIVE_TRAITS_NULL_REGEX_TRAITS_HPP_EAN_10_04_2005 13 14 // MS compatible compilers support #pragma once 15 #if defined(_MSC_VER) 16 # pragma once 17 #endif 18 19 #include <vector> 20 #include <boost/assert.hpp> 21 #include <boost/mpl/assert.hpp> 22 #include <boost/xpressive/detail/detail_fwd.hpp> 23 #include <boost/xpressive/detail/utility/never_true.hpp> 24 #include <boost/xpressive/detail/utility/ignore_unused.hpp> 25 26 namespace boost { namespace xpressive 27 { 28 29 namespace detail 30 { 31 struct not_a_locale {}; 32 } 33 34 struct regex_traits_version_1_tag; 35 36 /////////////////////////////////////////////////////////////////////////////// 37 // null_regex_traits 38 // 39 /// \brief stub regex_traits for non-char data 40 /// 41 template<typename Elem> 42 struct null_regex_traits 43 { 44 typedef Elem char_type; 45 typedef std::vector<char_type> string_type; 46 typedef detail::not_a_locale locale_type; 47 typedef int char_class_type; 48 typedef regex_traits_version_1_tag version_tag; 49 50 /// Initialize a null_regex_traits object. 51 /// null_regex_traitsboost::xpressive::null_regex_traits52 null_regex_traits(locale_type = locale_type()) 53 { 54 } 55 56 /// Checks two null_regex_traits objects for equality 57 /// 58 /// \return true. operator ==boost::xpressive::null_regex_traits59 bool operator ==(null_regex_traits<char_type> const &that) const 60 { 61 detail::ignore_unused(that); 62 return true; 63 } 64 65 /// Checks two null_regex_traits objects for inequality 66 /// 67 /// \return false. operator !=boost::xpressive::null_regex_traits68 bool operator !=(null_regex_traits<char_type> const &that) const 69 { 70 detail::ignore_unused(that); 71 return false; 72 } 73 74 /// Convert a char to a Elem 75 /// 76 /// \param ch The source character. 77 /// \return Elem(ch). widenboost::xpressive::null_regex_traits78 char_type widen(char ch) const 79 { 80 return char_type(ch); 81 } 82 83 /// Returns a hash value for a Elem in the range [0, UCHAR_MAX] 84 /// 85 /// \param ch The source character. 86 /// \return a value between 0 and UCHAR_MAX, inclusive. hashboost::xpressive::null_regex_traits87 static unsigned char hash(char_type ch) 88 { 89 return static_cast<unsigned char>(ch); 90 } 91 92 /// No-op 93 /// 94 /// \param ch The source character. 95 /// \return ch translateboost::xpressive::null_regex_traits96 static char_type translate(char_type ch) 97 { 98 return ch; 99 } 100 101 /// No-op 102 /// 103 /// \param ch The source character. 104 /// \return ch translate_nocaseboost::xpressive::null_regex_traits105 static char_type translate_nocase(char_type ch) 106 { 107 return ch; 108 } 109 110 /// Checks to see if a character is within a character range. 111 /// 112 /// \param first The bottom of the range, inclusive. 113 /// \param last The top of the range, inclusive. 114 /// \param ch The source character. 115 /// \return first <= ch && ch <= last. in_rangeboost::xpressive::null_regex_traits116 static bool in_range(char_type first, char_type last, char_type ch) 117 { 118 return first <= ch && ch <= last; 119 } 120 121 /// Checks to see if a character is within a character range. 122 /// 123 /// \param first The bottom of the range, inclusive. 124 /// \param last The top of the range, inclusive. 125 /// \param ch The source character. 126 /// \return first <= ch && ch <= last. 127 /// \attention Since the null_regex_traits does not do case-folding, 128 /// this function is equivalent to in_range(). in_range_nocaseboost::xpressive::null_regex_traits129 static bool in_range_nocase(char_type first, char_type last, char_type ch) 130 { 131 return first <= ch && ch <= last; 132 } 133 134 /// Returns a sort key for the character sequence designated by the iterator range [F1, F2) 135 /// such that if the character sequence [G1, G2) sorts before the character sequence [H1, H2) 136 /// then v.transform(G1, G2) < v.transform(H1, H2). 137 /// 138 /// \attention Not currently used 139 template<typename FwdIter> transformboost::xpressive::null_regex_traits140 static string_type transform(FwdIter begin, FwdIter end) 141 { 142 return string_type(begin, end); 143 } 144 145 /// Returns a sort key for the character sequence designated by the iterator range [F1, F2) 146 /// such that if the character sequence [G1, G2) sorts before the character sequence [H1, H2) 147 /// when character case is not considered then 148 /// v.transform_primary(G1, G2) < v.transform_primary(H1, H2). 149 /// 150 /// \attention Not currently used 151 template<typename FwdIter> transform_primaryboost::xpressive::null_regex_traits152 static string_type transform_primary(FwdIter begin, FwdIter end) 153 { 154 return string_type(begin, end); 155 } 156 157 /// Returns a sequence of characters that represents the collating element 158 /// consisting of the character sequence designated by the iterator range [F1, F2). 159 /// Returns an empty string if the character sequence is not a valid collating element. 160 /// 161 /// \attention Not currently used 162 template<typename FwdIter> lookup_collatenameboost::xpressive::null_regex_traits163 static string_type lookup_collatename(FwdIter begin, FwdIter end) 164 { 165 detail::ignore_unused(begin); 166 detail::ignore_unused(end); 167 return string_type(); 168 } 169 170 /// The null_regex_traits does not have character classifications, so lookup_classname() 171 /// is unused. 172 /// 173 /// \param begin not used 174 /// \param end not used 175 /// \param icase not used 176 /// \return static_cast\<char_class_type\>(0) 177 template<typename FwdIter> lookup_classnameboost::xpressive::null_regex_traits178 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase) 179 { 180 detail::ignore_unused(begin); 181 detail::ignore_unused(end); 182 detail::ignore_unused(icase); 183 return 0; 184 } 185 186 /// The null_regex_traits does not have character classifications, so isctype() 187 /// is unused. 188 /// 189 /// \param ch not used 190 /// \param mask not used 191 /// \return false isctypeboost::xpressive::null_regex_traits192 static bool isctype(char_type ch, char_class_type mask) 193 { 194 detail::ignore_unused(ch); 195 detail::ignore_unused(mask); 196 return false; 197 } 198 199 /// The null_regex_traits recognizes no elements as digits, so value() is unused. 200 /// 201 /// \param ch not used 202 /// \param radix not used 203 /// \return -1 valueboost::xpressive::null_regex_traits204 static int value(char_type ch, int radix) 205 { 206 detail::ignore_unused(ch); 207 detail::ignore_unused(radix); 208 return -1; 209 } 210 211 /// Not used 212 /// 213 /// \param loc not used 214 /// \return loc imbueboost::xpressive::null_regex_traits215 static locale_type imbue(locale_type loc) 216 { 217 return loc; 218 } 219 220 /// Returns locale_type(). 221 /// 222 /// \return locale_type() getlocboost::xpressive::null_regex_traits223 static locale_type getloc() 224 { 225 return locale_type(); 226 } 227 }; 228 229 }} 230 231 #endif 232