Added boost header

test/external/boost/xpressive/traits/null_regex_traits.hpp

@@ -0,0 +1,231 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file null_regex_traits.hpp
+/// Contains the definition of the null_regex_traits\<\> template, which is a
+/// stub regex traits implementation that can be used by static and dynamic
+/// regexes for searching non-character data.
+//
+//  Copyright 2008 Eric Niebler. 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_XPRESSIVE_TRAITS_NULL_REGEX_TRAITS_HPP_EAN_10_04_2005
+#define BOOST_XPRESSIVE_TRAITS_NULL_REGEX_TRAITS_HPP_EAN_10_04_2005
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <vector>
+#include <boost/assert.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/xpressive/detail/detail_fwd.hpp>
+#include <boost/xpressive/detail/utility/never_true.hpp>
+#include <boost/xpressive/detail/utility/ignore_unused.hpp>
+
+namespace boost { namespace xpressive
+{
+
+namespace detail
+{
+    struct not_a_locale {};
+}
+
+struct regex_traits_version_1_tag;
+
+///////////////////////////////////////////////////////////////////////////////
+// null_regex_traits
+//
+/// \brief stub regex_traits for non-char data
+///
+template<typename Elem>
+struct null_regex_traits
+{
+    typedef Elem char_type;
+    typedef std::vector<char_type> string_type;
+    typedef detail::not_a_locale locale_type;
+    typedef int char_class_type;
+    typedef regex_traits_version_1_tag version_tag;
+
+    /// Initialize a null_regex_traits object.
+    ///
+    null_regex_traits(locale_type = locale_type())
+    {
+    }
+
+    /// Checks two null_regex_traits objects for equality
+    ///
+    /// \return true.
+    bool operator ==(null_regex_traits<char_type> const &that) const
+    {
+        detail::ignore_unused(that);
+        return true;
+    }
+
+    /// Checks two null_regex_traits objects for inequality
+    ///
+    /// \return false.
+    bool operator !=(null_regex_traits<char_type> const &that) const
+    {
+        detail::ignore_unused(that);
+        return false;
+    }
+
+    /// Convert a char to a Elem
+    ///
+    /// \param ch The source character.
+    /// \return Elem(ch).
+    char_type widen(char ch) const
+    {
+        return char_type(ch);
+    }
+
+    /// Returns a hash value for a Elem in the range [0, UCHAR_MAX]
+    ///
+    /// \param ch The source character.
+    /// \return a value between 0 and UCHAR_MAX, inclusive.
+    static unsigned char hash(char_type ch)
+    {
+        return static_cast<unsigned char>(ch);
+    }
+
+    /// No-op
+    ///
+    /// \param ch The source character.
+    /// \return ch
+    static char_type translate(char_type ch)
+    {
+        return ch;
+    }
+
+    /// No-op
+    ///
+    /// \param ch The source character.
+    /// \return ch
+    static char_type translate_nocase(char_type ch)
+    {
+        return ch;
+    }
+
+    /// Checks to see if a character is within a character range.
+    ///
+    /// \param first The bottom of the range, inclusive.
+    /// \param last The top of the range, inclusive.
+    /// \param ch The source character.
+    /// \return first <= ch && ch <= last.
+    static bool in_range(char_type first, char_type last, char_type ch)
+    {
+        return first <= ch && ch <= last;
+    }
+
+    /// Checks to see if a character is within a character range.
+    ///
+    /// \param first The bottom of the range, inclusive.
+    /// \param last The top of the range, inclusive.
+    /// \param ch The source character.
+    /// \return first <= ch && ch <= last.
+    /// \attention Since the null_regex_traits does not do case-folding,
+    /// this function is equivalent to in_range().
+    static bool in_range_nocase(char_type first, char_type last, char_type ch)
+    {
+        return first <= ch && ch <= last;
+    }
+
+    /// Returns a sort key for the character sequence designated by the iterator range [F1, F2)
+    /// such that if the character sequence [G1, G2) sorts before the character sequence [H1, H2)
+    /// then v.transform(G1, G2) < v.transform(H1, H2).
+    ///
+    /// \attention Not currently used
+    template<typename FwdIter>
+    static string_type transform(FwdIter begin, FwdIter end)
+    {
+        return string_type(begin, end);
+    }
+
+    /// Returns a sort key for the character sequence designated by the iterator range [F1, F2)
+    /// such that if the character sequence [G1, G2) sorts before the character sequence [H1, H2)
+    /// when character case is not considered then
+    /// v.transform_primary(G1, G2) < v.transform_primary(H1, H2).
+    ///
+    /// \attention Not currently used
+    template<typename FwdIter>
+    static string_type transform_primary(FwdIter begin, FwdIter end)
+    {
+        return string_type(begin, end);
+    }
+
+    /// Returns a sequence of characters that represents the collating element
+    /// consisting of the character sequence designated by the iterator range [F1, F2).
+    /// Returns an empty string if the character sequence is not a valid collating element.
+    ///
+    /// \attention Not currently used
+    template<typename FwdIter>
+    static string_type lookup_collatename(FwdIter begin, FwdIter end)
+    {
+        detail::ignore_unused(begin);
+        detail::ignore_unused(end);
+        return string_type();
+    }
+
+    /// The null_regex_traits does not have character classifications, so lookup_classname()
+    /// is unused.
+    ///
+    /// \param begin not used
+    /// \param end not used
+    /// \param icase not used
+    /// \return static_cast\<char_class_type\>(0)
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        detail::ignore_unused(begin);
+        detail::ignore_unused(end);
+        detail::ignore_unused(icase);
+        return 0;
+    }
+
+    /// The null_regex_traits does not have character classifications, so isctype()
+    /// is unused.
+    ///
+    /// \param ch not used
+    /// \param mask not used
+    /// \return false
+    static bool isctype(char_type ch, char_class_type mask)
+    {
+        detail::ignore_unused(ch);
+        detail::ignore_unused(mask);
+        return false;
+    }
+
+    /// The null_regex_traits recognizes no elements as digits, so value() is unused.
+    ///
+    /// \param ch not used
+    /// \param radix not used
+    /// \return -1
+    static int value(char_type ch, int radix)
+    {
+        detail::ignore_unused(ch);
+        detail::ignore_unused(radix);
+        return -1;
+    }
+
+    /// Not used
+    ///
+    /// \param loc not used
+    /// \return loc
+    static locale_type imbue(locale_type loc)
+    {
+        return loc;
+    }
+
+    /// Returns locale_type().
+    ///
+    /// \return locale_type()
+    static locale_type getloc()
+    {
+        return locale_type();
+    }
+};
+
+}}
+
+#endif