regex.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_REGEX_HPP
#define SIG_UTIL_REGEX_HPP

#include "../helper/type_convert.hpp"
#include "../helper/maybe.hpp"
#include <regex>

#if SIG_MSVC_ENV
#define NOMINMAX
#include <windows.h>
#pragma warning ( disable : 4996 )
#endif

#if !SIG_MSVC_ENV && SIG_ENABLE_BOOST
#include <boost/regex.hpp>
#endif

#if (__GLIBCXX__ || __GLIBCPP__)
#define SIG_USE_GLIBCPP 1
#endif

// 正規表現ライブラリの指定 (gcc標準はバグが多いため避ける)
#if (!SIG_GCC_ENV)
    using SIG_Regex = std::regex;
    using SIG_WRegex = std::wregex;
    using SIG_SMatch = std::smatch;
    using SIG_WSMatch = std::wsmatch;
    #define SIG_RegexSearch std::regex_search
    #define SIG_RegexReplace std::regex_replace
#elif SIG_ENABLE_BOOST
    using SIG_Regex = typename boost::regex;
    using SIG_WRegex = typename boost::wregex;
    using SIG_SMatch = typename boost::smatch;
    using SIG_WSMatch = typename boost::wsmatch;
    #define SIG_RegexSearch boost::regex_search
    #define SIG_RegexReplace boost::regex_replace
#else
    #define SIG_REGEX_UNABLE 1
#endif



#if !SIG_REGEX_UNABLE
namespace sig
{

namespace impl
{
// string type to associated in regex type
template <class T>
struct Str2RegexSelector{};
template <>
struct Str2RegexSelector<std::string>{
    typedef SIG_Regex regex;
    typedef SIG_SMatch smatch;
};
template <>
struct Str2RegexSelector<std::wstring>{
    typedef SIG_WRegex regex;
    typedef SIG_WSMatch smatch;
};
}

#if SIG_MSVC_ENV


inline auto escape_regex(std::string const& expression) ->std::string
{
    static const SIG_Regex escape_reg(R"(([(){}\[\]|^?$.+*\\]))");

    return SIG_RegexReplace(expression, escape_reg, std::string(R"(\$1)"));
}

inline auto escape_regex(std::wstring const& expression) ->std::wstring
{
    static const SIG_WRegex escape_reg(LR"(([(){}\[\]|^?$.+*\\]))");

    return SIG_RegexReplace(expression, escape_reg, std::wstring(LR"(\$1)"));
}

#elif (SIG_USE_GLIBCPP && SIG_ENABLE_BOOST)


inline auto escape_regex(std::string const& expression) ->std::string
{
    static const SIG_Regex escape_reg(R"(([(){}\[\]|^?$.+*\\]))");

    return SIG_RegexReplace(expression, escape_reg, std::string(R"(\\$1)"));
}

inline auto escape_regex(std::wstring const& expression) ->std::wstring
{
    static const SIG_WRegex escape_reg(LR"(([(){}\[\]|^?$.+*\\]))");

    return SIG_RegexReplace(expression, escape_reg, std::wstring(LR"(\\$1)"));
}
#endif


#if SIG_MSVC_ENV || (SIG_USE_GLIBCPP && SIG_ENABLE_BOOST)


template <class S>
auto make_regex(S const& expression) ->typename impl::Str2RegexSelector<impl::string_t<S>>::regex
{
    return typename impl::Str2RegexSelector<impl::string_t<S>>::regex(escape_regex(expression));
}



template <class S, class TS = impl::string_t<S>>
auto regex_search(
    S&& src,
    typename impl::Str2RegexSelector<TS>::regex const& expression)
->Maybe<std::vector<std::vector<TS>>>
{
    using R = std::vector<std::vector<TS>>;

    typename impl::Str2RegexSelector<TS>::smatch match;
    auto tmp = static_cast<TS>(src);
    R d;

    while (SIG_RegexSearch(tmp, match, expression)){
        d.push_back(std::vector<TS>());
        for (auto const& m : match) d.back().push_back(m);
        tmp = match.suffix().str();
    }

    return d.empty() ? Nothing(std::move(d)) : Just(std::move(d));
}
#endif

}
#endif
#endif