regex.h

 
#ifndef _aspose_system_regex_h_
#define _aspose_system_regex_h_
 
#include <system/text/regularexpressions/match_collection.h>
#include <system/text/regularexpressions/match.h>
#include <system/exceptions.h>
#include <system/multicast_delegate.h>
 
namespace System { namespace Text { namespace RegularExpressions {
 
namespace Detail
{
    class RegexHolder;
}
 
using MatchEvaluator = System::MulticastDelegate<System::String(MatchPtr)>;
 
class Regex;
typedef System::SharedPtr<Regex> RegexPtr;
class Match;
 
class ASPOSECPP_SHARED_CLASS Regex: public Object
{
    friend class Match;
public:
    static TimeSpan ASPOSECPP_SHARED_API InfiniteMatchTimeout;
 
    ASPOSECPP_SHARED_API Regex();
    ASPOSECPP_SHARED_API Regex(const String& pattern);
    ASPOSECPP_SHARED_API Regex(const String& pattern, RegexOptions options);
    ASPOSECPP_SHARED_API Regex(const String& pattern, RegexOptions options, TimeSpan matchTimeout);
 
    TimeSpan get_MatchTimeout() { return m_matchTimeout; }
    RegexOptions get_Options() { return m_options; }
    bool get_RightToLeft() { return (m_options & RegexOptions::RightToLeft) == RegexOptions::RightToLeft; }
 
    ASPOSECPP_SHARED_API bool IsMatch(const String& input, int startat = 0);
 
    ASPOSECPP_SHARED_API MatchPtr Match(const String& input);
    ASPOSECPP_SHARED_API MatchPtr Match(const String& input, int startat, int length = 0);
 
    ASPOSECPP_SHARED_API MatchCollectionPtr Matches(const String& input, int startat = 0);
 
    ASPOSECPP_SHARED_API String Replace(const String& input, const String& replacement);
    ASPOSECPP_SHARED_API String Replace(const String& input, const char_t* replacement);
 
    static ASPOSECPP_SHARED_API String Replace(const String& input, const char_t* pattern, const char_t* replacement);
    static ASPOSECPP_SHARED_API String Replace(const String& input, const String& pattern, const char_t* replacement);
 
    ASPOSECPP_SHARED_API String Replace(const String& input, const MatchEvaluator& evaluator);
    ASPOSECPP_SHARED_API String Replace(const String& input, const MatchEvaluator& evaluator, int count);
    ASPOSECPP_SHARED_API String Replace(const String& input, const MatchEvaluator& evaluator, int count, int startat);
 
    ASPOSECPP_SHARED_API static String Replace(const String& input, const String& pattern, const MatchEvaluator& evaluator, RegexOptions options);
 
 
    static ASPOSECPP_SHARED_API String Replace(const String& input, const String& pattern, const String& replacement, RegexOptions options);
    ASPOSECPP_SHARED_API String Replace(const String& input, const String& replacement, int count);
    ASPOSECPP_SHARED_API String Replace(const String& input, const String& replacement, int count, int startat);
 
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& input);
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& input, int count);
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& input, int count, int startat);
 
    String ToString() const override { return m_pattern; }
 
    // static methods
    static ASPOSECPP_SHARED_API bool IsMatch(const String& input, const String& pattern,
                        RegexOptions options = RegexOptions::None,
                        TimeSpan matchTimeout = InfiniteMatchTimeout,
                        int startat = 0);
    static ASPOSECPP_SHARED_API MatchPtr Match(const String& input, const String& pattern,
                            RegexOptions options = RegexOptions::None,
                            TimeSpan matchTimeout = InfiniteMatchTimeout,
                            int startat = 0, int length = 0);
    static ASPOSECPP_SHARED_API MatchCollectionPtr Matches(const String& input, const String& pattern,
                                        RegexOptions options = RegexOptions::None,
                                        TimeSpan matchTimeout = InfiniteMatchTimeout,
                                        int startat = 0, int length = 0);
 
    static ASPOSECPP_SHARED_API String Replace(const String& input, const String& pattern, const String& replacement);
    static ASPOSECPP_SHARED_API String Replace(const String& input, const String& pattern, const MatchEvaluator& evaluator);
 
    static ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& input, const String& pattern,
                                  RegexOptions options = RegexOptions::None,
                                  TimeSpan matchTimeout = InfiniteMatchTimeout);
    static ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& input, const String& pattern, int count,
                                  RegexOptions options = RegexOptions::None,
                                  TimeSpan matchTimeout = InfiniteMatchTimeout);
 
    static ASPOSECPP_SHARED_API String Escape(const String& str);
    static ASPOSECPP_SHARED_API String Unescape(const String& str);
 
protected:
    ASPOSECPP_SHARED_API ~Regex() override;
 
private:
    MatchPtr Match(const UStringPtr& source, int index);
 
    static bool IsMetachar(char_t ch);
 
    String m_pattern;
    RegexOptions m_options;
    TimeSpan m_matchTimeout;
    std::unique_ptr<Detail::RegexHolder> m_regex_holder;
 
    static const unsigned char s_category[];
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
    {
        Object::DBG_for_each_member(visitor);
        visitor.add_self(this);
    }
 
    const char* DBG_class_name() const override { return "Regex"; }
#endif
};
 
}}} // namespace System::Text::RegularExpressions
 
#endif // _aspose_system_regex_h_