13
0
livetrax/libs/glibmm2/glib/glibmm/regex.h
Paul Davis 449aab3c46 rollback to 3428, before the mysterious removal of libs/* at 3431/3432
git-svn-id: svn://localhost/ardour2/branches/3.0@3435 d708f5d6-7413-0410-9779-e7cbd77b26cf
2008-06-02 21:41:35 +00:00

677 lines
30 KiB
C++

// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _GLIBMM_REGEX_H
#define _GLIBMM_REGEX_H
/* Copyright (C) 2007 The glibmm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <glibmm/refptr.h>
#include <glibmm/ustring.h>
#include <glibmm/error.h>
#include <glibmm/arrayhandle.h>
#include <glib/gregex.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GRegex GRegex;
#endif
namespace Glib
{
/** @addtogroup glibmmEnums Enums and Flags */
/**
* @ingroup glibmmEnums
* @par Bitwise operators:
* <tt>%RegexCompileFlags operator|(RegexCompileFlags, RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags operator&(RegexCompileFlags, RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags operator^(RegexCompileFlags, RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags operator~(RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags& operator|=(RegexCompileFlags&, RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags& operator&=(RegexCompileFlags&, RegexCompileFlags)</tt><br>
* <tt>%RegexCompileFlags& operator^=(RegexCompileFlags&, RegexCompileFlags)</tt><br>
*/
enum RegexCompileFlags
{
REGEX_CASELESS = 1 << 0,
REGEX_MULTILINE = 1 << 1,
REGEX_DOTALL = 1 << 2,
REGEX_EXTENDED = 1 << 3,
REGEX_ANCHORED = 1 << 4,
REGEX_DOLLAR_ENDONLY = 1 << 5,
REGEX_UNGREEDY = 1 << 9,
REGEX_RAW = 1 << 11,
REGEX_NO_AUTO_CAPTURE = 1 << 12,
REGEX_OPTIMIZE = 1 << 13,
REGEX_DUPNAMES = 1 << 19,
REGEX_NEWLINE_CR = 1 << 20,
REGEX_NEWLINE_LF = 1 << 21,
REGEX_NEWLINE_CRLF = 0x100000
};
/** @ingroup glibmmEnums */
inline RegexCompileFlags operator|(RegexCompileFlags lhs, RegexCompileFlags rhs)
{ return static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags operator&(RegexCompileFlags lhs, RegexCompileFlags rhs)
{ return static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags operator^(RegexCompileFlags lhs, RegexCompileFlags rhs)
{ return static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags operator~(RegexCompileFlags flags)
{ return static_cast<RegexCompileFlags>(~static_cast<unsigned>(flags)); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags& operator|=(RegexCompileFlags& lhs, RegexCompileFlags rhs)
{ return (lhs = static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags& operator&=(RegexCompileFlags& lhs, RegexCompileFlags rhs)
{ return (lhs = static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
/** @ingroup glibmmEnums */
inline RegexCompileFlags& operator^=(RegexCompileFlags& lhs, RegexCompileFlags rhs)
{ return (lhs = static_cast<RegexCompileFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
/**
* @ingroup glibmmEnums
* @par Bitwise operators:
* <tt>%RegexMatchFlags operator|(RegexMatchFlags, RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags operator&(RegexMatchFlags, RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags operator^(RegexMatchFlags, RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags operator~(RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags& operator|=(RegexMatchFlags&, RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags& operator&=(RegexMatchFlags&, RegexMatchFlags)</tt><br>
* <tt>%RegexMatchFlags& operator^=(RegexMatchFlags&, RegexMatchFlags)</tt><br>
*/
enum RegexMatchFlags
{
REGEX_MATCH_ANCHORED = 1 << 4,
REGEX_MATCH_NOTBOL = 1 << 7,
REGEX_MATCH_NOTEOL = 1 << 8,
REGEX_MATCH_NOTEMPTY = 1 << 10,
REGEX_MATCH_PARTIAL = 1 << 15,
REGEX_MATCH_NEWLINE_CR = 1 << 20,
REGEX_MATCH_NEWLINE_LF = 1 << 21,
REGEX_MATCH_NEWLINE_CRLF = 0x100000,
REGEX_MATCH_NEWLINE_ANY = 1 << 22
};
/** @ingroup glibmmEnums */
inline RegexMatchFlags operator|(RegexMatchFlags lhs, RegexMatchFlags rhs)
{ return static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags operator&(RegexMatchFlags lhs, RegexMatchFlags rhs)
{ return static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags operator^(RegexMatchFlags lhs, RegexMatchFlags rhs)
{ return static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags operator~(RegexMatchFlags flags)
{ return static_cast<RegexMatchFlags>(~static_cast<unsigned>(flags)); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags& operator|=(RegexMatchFlags& lhs, RegexMatchFlags rhs)
{ return (lhs = static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags& operator&=(RegexMatchFlags& lhs, RegexMatchFlags rhs)
{ return (lhs = static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
/** @ingroup glibmmEnums */
inline RegexMatchFlags& operator^=(RegexMatchFlags& lhs, RegexMatchFlags rhs)
{ return (lhs = static_cast<RegexMatchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
/** Exception class for Regex
*/
class RegexError : public Glib::Error
{
public:
enum Code
{
COMPILE,
OPTIMIZE,
REPLACE,
MATCH
};
RegexError(Code error_code, const Glib::ustring& error_message);
explicit RegexError(GError* gobject);
Code code() const;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
#ifdef GLIBMM_EXCEPTIONS_ENABLED
static void throw_func(GError* gobject);
#else
//When not using exceptions, we just pass the Exception object around without throwing it:
static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
#endif //GLIBMM_EXCEPTIONS_ENABLED
friend void wrap_init(); // uses throw_func()
#endif
};
/** Perl-compatible regular expressions - matches strings against regular expressions.
*
* The Glib::Regex functions implement regular expression pattern matching using
* syntax and semantics similar to Perl regular expression.
*
* Some functions accept a start_position argument, setting it differs from just
* passing over a shortened string and setting REGEX_MATCH_NOTBOL in the case
* of a pattern that begins with any kind of lookbehind assertion. For example,
* consider the pattern "\Biss\B" which finds occurrences of "iss" in the middle
* of words. ("\B" matches only if the current position in the subject is not a
* word boundary.) When applied to the string "Mississipi" from the fourth byte,
* namely "issipi", it does not match, because "\B" is always false at the
* start of the subject, which is deemed to be a word boundary. However, if
* the entire string is passed , but with start_position set to 4, it finds the
* second occurrence of "iss" because it is able to look behind the starting point
* to discover that it is preceded by a letter.
*
* Note that, unless you set the REGEX_RAW flag, all the strings passed to these
* functions must be encoded in UTF-8. The lengths and the positions inside the
* strings are in bytes and not in characters, so, for instance,
* "\xc3\xa0" (i.e. "à") is two bytes long but it is treated as a single
* character. If you set REGEX_RAW the strings can be non-valid UTF-8 strings
* and a byte is treated as a character, so "\xc3\xa0" is two bytes and
* two characters long.
*
* When matching a pattern, "\n" matches only against a "\n" character in the
* string, and "\r" matches only a "\r" character. To match any newline sequence
* use "\R". This particular group matches either the two-character sequence
* CR + LF ("\r\n"), or one of the single characters LF (linefeed, U+000A, "\n"),
* VT (vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"), CR (carriage
* return, U+000D, "\r"), NEL (next line, U+0085), LS (line separator, U+2028),
* or PS (paragraph separator, U+2029).
*
* The behaviour of the dot, circumflex, and dollar metacharacters are affected
* by newline characters, the default is to recognize any newline character (the
* same characters recognized by "\R"). This can be changed with REGEX_NEWLINE_CR,
* REGEX_NEWLINE_LF and REGEX_NEWLINE_CRLF compile options, and with
* REGEX_MATCH_NEWLINE_ANY, REGEX_MATCH_NEWLINE_CR, REGEX_MATCH_NEWLINE_LF
* and REGEX_MATCH_NEWLINE_CRLF match options. These settings are also
* relevant when compiling a pattern if REGEX_EXTENDED is set, and an unescaped
* "#" outside a character class is encountered. This indicates a comment that
* lasts until after the next newline.
*
* Creating and manipulating the same Glib::Regex class from different threads is
* not a problem as Glib::Regex does not modify its internal state between creation and
* destruction, on the other hand Glib::MatchInfo is not threadsafe.
*
* The regular expressions low level functionalities are obtained through the
* excellent PCRE library written by Philip Hazel.
*
* @newin2p14
*/
class Regex
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef Regex CppObjectType;
typedef GRegex BaseObjectType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
// For use with Glib::RefPtr<> only.
void reference() const;
void unreference() const;
///Provides access to the underlying C instance.
GRegex* gobj();
///Provides access to the underlying C instance.
const GRegex* gobj() const;
///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
GRegex* gobj_copy() const;
protected:
// Do not derive this. Glib::Regex can neither be constructed nor deleted.
Regex();
void operator delete(void*, size_t);
private:
// noncopyable
Regex(const Regex&);
Regex& operator=(const Regex&);
public:
#ifdef GLIBMM_EXCEPTIONS_ENABLED
static Glib::RefPtr<Glib::Regex> create(const Glib::ustring& pattern, RegexCompileFlags compile_options = static_cast<RegexCompileFlags>(0), RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
#else
static Glib::RefPtr<Glib::Regex> create(const Glib::ustring& pattern, RegexCompileFlags compile_options = static_cast<RegexCompileFlags>(0), RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0), std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
/** Gets the pattern string associated with @a regex , i.e.\ a copy of
* the string passed to g_regex_new().
* @return The pattern of @a regex
*
* @newin2p14.
*/
Glib::ustring get_pattern() const;
/** Returns: the number of the highest back reference
* @return The number of the highest back reference
*
* @newin2p14.
*/
int get_max_backref() const;
/** Returns: the number of capturing subpatterns
* @return The number of capturing subpatterns
*
* @newin2p14.
*/
int get_capture_count() const;
/** Retrieves the number of the subexpression named @a name .
* @param name Name of the subexpression.
* @return The number of the subexpression or -1 if @a name
* does not exists
*
* @newin2p14.
*/
int get_string_number(const Glib::ustring& name) const;
static Glib::ustring escape_string(const Glib::ustring& string);
/** Scans for a match in @a string for @a pattern .
*
* This function is equivalent to g_regex_match() but it does not
* require to compile the pattern with g_regex_new(), avoiding some
* lines of code when you need just to do a match without extracting
* substrings, capture counts, and so on.
*
* If this function is to be called on the same @a pattern more than
* once, it's more efficient to compile the pattern once with
* g_regex_new() and then use g_regex_match().
* @param pattern The regular expression.
* @param string The string to scan for matches.
* @param compile_options Compile options for the regular expression.
* @param match_options Match options.
* @return <tt>true</tt> is the string matched, <tt>false</tt> otherwise
*
* @newin2p14.
*/
static bool match_simple(const Glib::ustring& pattern, const Glib::ustring& string, RegexCompileFlags compile_options = static_cast<RegexCompileFlags>(0), RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
//TODO: _WRAP_METHOD(bool match(const Glib::ustring& string, RegexMatchFlags match_options = (RegexMatchFlags)0, GMatchInfo **match_info = 0), g_regex_match)
bool match(const Glib::ustring& string, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
//TODO: Wrap GMatchInfo as an iterator:
//_WRAP_METHOD(bool match_full(const gchar* string, gssize string_len, int start_position, RegexMatchFlags match_options = (RegexMatchFlags)0, GMatchInfo** match_info = 0), g_regex_match_full, errthrow)
#ifdef GLIBMM_EXCEPTIONS_ENABLED
bool match(const Glib::ustring& string, int start_position, RegexMatchFlags match_options);
#else
bool match(const Glib::ustring& string, int start_position, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
#ifdef GLIBMM_EXCEPTIONS_ENABLED
bool match(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options);
#else
bool match(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
//TODO: _WRAP_METHOD(bool match_all(const Glib::ustring& string, RegexMatchFlags match_options = (RegexMatchFlags)0, GMatchInfo ** match_info = 0), g_regex_match_all)
bool match_all(const Glib::ustring& string, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
//TODO: _WRAP_METHOD(bool match_all_full(const gchar* string, gssize string_len, int start_position, RegexMatchFlags match_options = (RegexMatchFlags)0, GMatchInfo** match_info = 0), g_regex_match_all_full, errthrow)
#ifdef GLIBMM_EXCEPTIONS_ENABLED
bool match_all(const Glib::ustring& string, int start_position, RegexMatchFlags match_options);
#else
bool match_all(const Glib::ustring& string, int start_position, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
#ifdef GLIBMM_EXCEPTIONS_ENABLED
bool match_all(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options);
#else
bool match_all(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
/** Breaks the string on the pattern, and returns an array of
* the tokens. If the pattern contains capturing parentheses,
* then the text for each of the substrings will also be returned.
* If the pattern does not match anywhere in the string, then the
* whole string is returned as the first token.
*
* This function is equivalent to g_regex_split() but it does
* not require to compile the pattern with g_regex_new(), avoiding
* some lines of code when you need just to do a split without
* extracting substrings, capture counts, and so on.
*
* If this function is to be called on the same @a pattern more than
* once, it's more efficient to compile the pattern once with
* g_regex_new() and then use g_regex_split().
*
* As a special case, the result of splitting the empty string ""
* is an empty vector, not a vector containing a single string.
* The reason for this special case is that being able to represent
* a empty vector is typically more useful than consistent handling
* of empty elements. If you do need to represent empty elements,
* you'll need to check for the empty string before calling this
* function.
*
* A pattern that can match empty strings splits @a string into
* separate characters wherever it matches the empty string between
* characters. For example splitting "ab c" using as a separator
* "\s*", you will get "a", "b" and "c".
* @param pattern The regular expression.
* @param string The string to scan for matches.
* @param compile_options Compile options for the regular expression.
* @param match_options Match options.
* @return A <tt>0</tt>-terminated gchar ** array. Free it using g_strfreev()
*
* @newin2p14.
*/
static Glib::StringArrayHandle split_simple(const Glib::ustring& pattern, const Glib::ustring& string, RegexCompileFlags compile_options = static_cast<RegexCompileFlags>(0), RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
/** Breaks the string on the pattern, and returns an array of the tokens.
* If the pattern contains capturing parentheses, then the text for each
* of the substrings will also be returned. If the pattern does not match
* anywhere in the string, then the whole string is returned as the first
* token.
*
* As a special case, the result of splitting the empty string "" is an
* empty vector, not a vector containing a single string. The reason for
* this special case is that being able to represent a empty vector is
* typically more useful than consistent handling of empty elements. If
* you do need to represent empty elements, you'll need to check for the
* empty string before calling this function.
*
* A pattern that can match empty strings splits @a string into separate
* characters wherever it matches the empty string between characters.
* For example splitting "ab c" using as a separator "\s*", you will get
* "a", "b" and "c".
* @param string The string to split with the pattern.
* @param match_options Match time option flags.
* @return A <tt>0</tt>-terminated gchar ** array. Free it using g_strfreev()
*
* @newin2p14.
*/
Glib::StringArrayHandle split(const Glib::ustring& string, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
/** Breaks the string on the pattern, and returns an array of the tokens.
* If the pattern contains capturing parentheses, then the text for each
* of the substrings will also be returned. If the pattern does not match
* anywhere in the string, then the whole string is returned as the first
* token.
*
* As a special case, the result of splitting the empty string "" is an
* empty vector, not a vector containing a single string. The reason for
* this special case is that being able to represent a empty vector is
* typically more useful than consistent handling of empty elements. If
* you do need to represent empty elements, you'll need to check for the
* empty string before calling this function.
*
* A pattern that can match empty strings splits @a string into separate
* characters wherever it matches the empty string between characters.
* For example splitting "ab c" using as a separator "\s*", you will get
* "a", "b" and "c".
*
* Setting @a start_position differs from just passing over a shortened
* string and setting G::REGEX_MATCH_NOTBOL in the case of a pattern
* that begins with any kind of lookbehind assertion, such as "\b".
* @param string The string to split with the pattern.
* @param string_len The length of @a string , or -1 if @a string is nul-terminated.
* @param start_position Starting index of the string to match.
* @param match_options Match time option flags.
* @param max_tokens The maximum number of tokens to split @a string into.
* If this is less than 1, the string is split completely.
* @param error Return location for a G::Error.
* @return A <tt>0</tt>-terminated gchar ** array. Free it using g_strfreev()
*
* @newin2p14.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::StringArrayHandle split(const gchar* string, gssize string_len, int start_position, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0), int max_tokens = 0) const;
#else
Glib::StringArrayHandle split(const gchar* string, gssize string_len, int start_position, RegexMatchFlags match_options, int max_tokens, std::auto_ptr<Glib::Error>& error) const;
#endif //GLIBMM_EXCEPTIONS_ENABLED
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::StringArrayHandle split(const Glib::ustring& string, int start_position, RegexMatchFlags match_options, int max_tokens) const;
#else
Glib::StringArrayHandle split(const Glib::ustring& string, int start_position, RegexMatchFlags match_options, int max_tokens, std::auto_ptr<Glib::Error>& error) const;
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
/** Replaces all occurances of the pattern in @a regex with the
* replacement text. Backreferences of the form '\number' or
* '\g&lt;number&gt;' in the replacement text are interpolated by the
* number-th captured subexpression of the match, '\g&lt;name&gt;' refers
* to the captured subexpression with the given name. '\0' refers to the
* complete match, but '\0' followed by a number is the octal representation
* of a character. To include a literal '\' in the replacement, write '\\'.
* There are also escapes that changes the case of the following text:
*
* &lt;variablelist&gt;
* &lt;varlistentry&gt;&lt;term&gt;\l&lt;/term&gt;
* &lt;listitem&gt;
* Convert to lower case the next character
* &lt;/listitem&gt;
* &lt;/varlistentry&gt;
* &lt;varlistentry&gt;&lt;term&gt;\u&lt;/term&gt;
* &lt;listitem&gt;
* Convert to upper case the next character
* &lt;/listitem&gt;
* &lt;/varlistentry&gt;
* &lt;varlistentry&gt;&lt;term&gt;\L&lt;/term&gt;
* &lt;listitem&gt;
* Convert to lower case till \E
* &lt;/listitem&gt;
* &lt;/varlistentry&gt;
* &lt;varlistentry&gt;&lt;term&gt;\U&lt;/term&gt;
* &lt;listitem&gt;
* Convert to upper case till \E
* &lt;/listitem&gt;
* &lt;/varlistentry&gt;
* &lt;varlistentry&gt;&lt;term&gt;\E&lt;/term&gt;
* &lt;listitem&gt;
* End case modification
* &lt;/listitem&gt;
* &lt;/varlistentry&gt;
* &lt;/variablelist&gt;
*
* If you do not need to use backreferences use g_regex_replace_literal().
*
* The @a replacement string must be UTF-8 encoded even if G::REGEX_RAW was
* passed to g_regex_new(). If you want to use not UTF-8 encoded stings
* you can use g_regex_replace_literal().
*
* Setting @a start_position differs from just passing over a shortened
* string and setting G::REGEX_MATCH_NOTBOL in the case of a pattern that
* begins with any kind of lookbehind assertion, such as "\b".
* @param string The string to perform matches against.
* @param string_len The length of @a string , or -1 if @a string is nul-terminated.
* @param start_position Starting index of the string to match.
* @param replacement Text to replace each match with.
* @param match_options Options for the match.
* @param error Location to store the error occuring, or <tt>0</tt> to ignore errors.
* @return A newly allocated string containing the replacements
*
* @newin2p14.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::ustring replace(const gchar* string, gssize string_len, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
#else
Glib::ustring replace(const gchar* string, gssize string_len, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif //GLIBMM_EXCEPTIONS_ENABLED
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::ustring replace(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options);
#else
Glib::ustring replace(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
/** Replaces all occurances of the pattern in @a regex with the
* replacement text. @a replacement is replaced literally, to
* include backreferences use g_regex_replace().
*
* Setting @a start_position differs from just passing over a
* shortened string and setting G::REGEX_MATCH_NOTBOL in the
* case of a pattern that begins with any kind of lookbehind
* assertion, such as "\b".
* @param string The string to perform matches against.
* @param string_len The length of @a string , or -1 if @a string is nul-terminated.
* @param start_position Starting index of the string to match.
* @param replacement Text to replace each match with.
* @param match_options Options for the match.
* @param error Location to store the error occuring, or <tt>0</tt> to ignore errors.
* @return A newly allocated string containing the replacements
*
* @newin2p14.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::ustring replace_literal(const gchar *string, gssize string_len, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
#else
Glib::ustring replace_literal(const gchar * string, gssize string_len, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif //GLIBMM_EXCEPTIONS_ENABLED
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::ustring replace_literal(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options);
#else
Glib::ustring replace_literal(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options, std::auto_ptr<Glib::Error>& error);
#endif /* !GLIBMM_EXCEPTIONS_ENABLED */
/** Replaces occurances of the pattern in regex with the output of
* @a eval for that occurance.
*
* Setting @a start_position differs from just passing over a shortened
* string and setting G::REGEX_MATCH_NOTBOL in the case of a pattern
* that begins with any kind of lookbehind assertion, such as "\b".
* @param string String to perform matches against.
* @param string_len The length of @a string , or -1 if @a string is nul-terminated.
* @param start_position Starting index of the string to match.
* @param match_options Options for the match.
* @param eval A function to call for each match.
* @param user_data User data to pass to the function.
* @param error Location to store the error occuring, or <tt>0</tt> to ignore errors.
* @return A newly allocated string containing the replacements
*
* @newin2p14.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
Glib::ustring replace_eval(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options, GRegexEvalCallback eval, gpointer user_data);
#else
Glib::ustring replace_eval(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options, GRegexEvalCallback eval, gpointer user_data, std::auto_ptr<Glib::Error>& error);
#endif //GLIBMM_EXCEPTIONS_ENABLED
/** Checks whether @a replacement is a valid replacement string
* (see g_regex_replace()), i.e.\ that all escape sequences in
* it are valid.
*
* If @a has_references is not <tt>0</tt> then @a replacement is checked
* for pattern references. For instance, replacement text 'foo<tt>\\n</tt>'
* does not contain references and may be evaluated without information
* about actual match, but '\0\1' (whole match followed by first
* subpattern) requires valid G::MatchInfo object.
* @param replacement The replacement string.
* @param has_references Location to store information about
* references in @a replacement or <tt>0</tt>.
* @param error Location to store error.
* @return Whether @a replacement is a valid replacement string
*
* @newin2p14.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
static bool check_replacement(const Glib::ustring& replacement, gboolean* has_references);
#else
static bool check_replacement(const Glib::ustring& replacement, gboolean* has_references, std::auto_ptr<Glib::Error>& error);
#endif //GLIBMM_EXCEPTIONS_ENABLED
/* Match info */
/*
GRegex *g_match_info_get_regex (const GMatchInfo *match_info);
const gchar *g_match_info_get_string (const GMatchInfo *match_info);
void g_match_info_free (GMatchInfo *match_info);
_WRAP_METHOD(bool g_match_info_next (GMatchInfo *match_info,
GError **error);
_WRAP_METHOD(bool g_match_info_matches (const GMatchInfo *match_info);
_WRAP_METHOD(int g_match_info_get_match_count (const GMatchInfo *match_info);
_WRAP_METHOD(bool g_match_info_is_partial_match (const GMatchInfo *match_info);
Glib::ustring g_match_info_expand_references(const GMatchInfo *match_info,
Glib::ustring& string_to_expand,
GError **error);
Glib::ustring g_match_info_fetch (const GMatchInfo *match_info,
int match_num);
_WRAP_METHOD(bool g_match_info_fetch_pos (const GMatchInfo *match_info,
int match_num,
int *start_pos,
int *end_pos);
Glib::ustring g_match_info_fetch_named (const GMatchInfo *match_info,
Glib::ustring& name);
_WRAP_METHOD(bool g_match_info_fetch_named_pos (const GMatchInfo *match_info,
Glib::ustring& name,
int *start_pos,
int *end_pos);
gchar **g_match_info_fetch_all (const GMatchInfo *match_info);
*/
};
} // namespace Glib
namespace Glib
{
/** A Glib::wrap() method for this object.
*
* @param object The C instance.
* @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
* @result A C++ instance that wraps this C instance.
*
* @relates Glib::Regex
*/
Glib::RefPtr<Glib::Regex> wrap(GRegex* object, bool take_copy = false);
} // namespace Glib
#endif /* _GLIBMM_REGEX_H */