/*
* Licensed under the GNU Lesser General Public License Version 3
*
* This library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the license, or
* (at your option) any later version.
*
* This software 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library. If not, see .
*/
// generated automatically - do not change
module glib.Regex;
private import gi.glib;
public import gi.glibtypes;
private import glib.ConstructionException;
private import glib.ErrorG;
private import glib.GException;
private import glib.MatchInfo;
private import glib.Str;
/**
* The g_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 #G_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 #G_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 #G_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 #G_REGEX_NEWLINE_CR, #G_REGEX_NEWLINE_LF and #G_REGEX_NEWLINE_CRLF
* compile options, and with #G_REGEX_MATCH_NEWLINE_ANY,
* #G_REGEX_MATCH_NEWLINE_CR, #G_REGEX_MATCH_NEWLINE_LF and
* #G_REGEX_MATCH_NEWLINE_CRLF match options. These settings are also
* relevant when compiling a pattern if #G_REGEX_EXTENDED is set, and an
* unescaped "#" outside a character class is encountered. This indicates
* a comment that lasts until after the next newline.
*
* When setting the %G_REGEX_JAVASCRIPT_COMPAT flag, pattern syntax and pattern
* matching is changed to be compatible with the way that regular expressions
* work in JavaScript. More precisely, a lonely ']' character in the pattern
* is a syntax error; the '\x' escape only allows 0 to 2 hexadecimal digits, and
* you must use the '\u' escape sequence with 4 hex digits to specify a unicode
* codepoint instead of '\x' or 'x{....}'. If '\x' or '\u' are not followed by
* the specified number of hex digits, they match 'x' and 'u' literally; also
* '\U' always matches 'U' instead of being an error in the pattern. Finally,
* pattern matching is modified so that back references to an unset subpattern
* group produces a match with the empty string instead of an error. See
* pcreapi(3) for more information.
*
* Creating and manipulating the same #GRegex structure from different
* threads is not a problem as #GRegex does not modify its internal
* state between creation and destruction, on the other hand #GMatchInfo
* is not threadsafe.
*
* The regular expressions low-level functionalities are obtained through
* the excellent
* [PCRE](http://www.pcre.org/)
* library written by Philip Hazel.
*
* Since: 2.14
*/
public class Regex
{
/** the main Gtk struct */
protected GRegex* gRegex;
protected bool ownedRef;
/** Get the main Gtk struct */
public GRegex* getRegexStruct()
{
return gRegex;
}
/** the main Gtk struct as a void* */
protected void* getStruct()
{
return cast(void*)gRegex;
}
/**
* Sets our main struct and passes it to the parent class.
*/
public this (GRegex* gRegex, bool ownedRef = false)
{
this.gRegex = gRegex;
this.ownedRef = ownedRef;
}
/**
* Compiles the regular expression to an internal form, and does
* the initial setup of the #GRegex structure.
*
* Params:
* pattern = the regular expression
* compileOptions = compile options for the regular expression, or 0
* matchOptions = match options for the regular expression, or 0
*
* Returns: a #GRegex structure. Call g_regex_unref() when you
* are done with it
*
* Since: 2.14
*
* Throws: GException on failure.
* Throws: ConstructionException GTK+ fails to create the object.
*/
public this(string pattern, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions)
{
GError* err = null;
auto p = g_regex_new(Str.toStringz(pattern), compileOptions, matchOptions, &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
throw new ConstructionException("null returned by new");
}
this(cast(GRegex*) p);
}
/**
* Returns the number of capturing subpatterns in the pattern.
*
* Returns: the number of capturing subpatterns
*
* Since: 2.14
*/
public int getCaptureCount()
{
return g_regex_get_capture_count(gRegex);
}
/**
* Returns the compile options that @regex was created with.
*
* Returns: flags from #GRegexCompileFlags
*
* Since: 2.26
*/
public GRegexCompileFlags getCompileFlags()
{
return g_regex_get_compile_flags(gRegex);
}
/**
* Checks whether the pattern contains explicit CR or LF references.
*
* Returns: %TRUE if the pattern contains explicit CR or LF references
*
* Since: 2.34
*/
public bool getHasCrOrLf()
{
return g_regex_get_has_cr_or_lf(gRegex) != 0;
}
/**
* Returns the match options that @regex was created with.
*
* Returns: flags from #GRegexMatchFlags
*
* Since: 2.26
*/
public GRegexMatchFlags getMatchFlags()
{
return g_regex_get_match_flags(gRegex);
}
/**
* Returns the number of the highest back reference
* in the pattern, or 0 if the pattern does not contain
* back references.
*
* Returns: the number of the highest back reference
*
* Since: 2.14
*/
public int getMaxBackref()
{
return g_regex_get_max_backref(gRegex);
}
/**
* Gets the number of characters in the longest lookbehind assertion in the
* pattern. This information is useful when doing multi-segment matching using
* the partial matching facilities.
*
* Returns: the number of characters in the longest lookbehind assertion.
*
* Since: 2.38
*/
public int getMaxLookbehind()
{
return g_regex_get_max_lookbehind(gRegex);
}
/**
* Gets the pattern string associated with @regex, i.e. a copy of
* the string passed to g_regex_new().
*
* Returns: the pattern of @regex
*
* Since: 2.14
*/
public string getPattern()
{
return Str.toString(g_regex_get_pattern(gRegex));
}
/**
* Retrieves the number of the subexpression named @name.
*
* Params:
* name = name of the subexpression
*
* Returns: The number of the subexpression or -1 if @name
* does not exists
*
* Since: 2.14
*/
public int getStringNumber(string name)
{
return g_regex_get_string_number(gRegex, Str.toStringz(name));
}
/**
* Scans for a match in string for the pattern in @regex.
* The @match_options are combined with the match options specified
* when the @regex structure was created, letting you have more
* flexibility in reusing #GRegex structures.
*
* A #GMatchInfo structure, used to get information on the match,
* is stored in @match_info if not %NULL. Note that if @match_info
* is not %NULL then it is created even if the function returns %FALSE,
* i.e. you must free it regardless if regular expression actually matched.
*
* To retrieve all the non-overlapping matches of the pattern in
* string you can use g_match_info_next().
*
* |[
* static void
* print_uppercase_words (const gchar *string)
* {
* // Print all uppercase-only words.
* GRegex *regex;
* GMatchInfo *match_info;
*
* regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
* g_regex_match (regex, string, 0, &match_info);
* while (g_match_info_matches (match_info))
* {
* gchar *word = g_match_info_fetch (match_info, 0);
* g_print ("Found: %s\n", word);
* g_free (word);
* g_match_info_next (match_info, NULL);
* }
* g_match_info_free (match_info);
* g_regex_unref (regex);
* }
* ]|
*
* @string is not copied and is used in #GMatchInfo internally. If
* you use any #GMatchInfo method (except g_match_info_free()) after
* freeing or modifying @string then the behaviour is undefined.
*
* Params:
* str = the string to scan for matches
* matchOptions = match options
* matchInfo = pointer to location where to store
* the #GMatchInfo, or %NULL if you do not need it
*
* Returns: %TRUE is the string matched, %FALSE otherwise
*
* Since: 2.14
*/
public bool match(string str, GRegexMatchFlags matchOptions, out MatchInfo matchInfo)
{
GMatchInfo* outmatchInfo = null;
auto p = g_regex_match(gRegex, Str.toStringz(str), matchOptions, &outmatchInfo) != 0;
matchInfo = new MatchInfo(outmatchInfo);
return p;
}
/**
* Using the standard algorithm for regular expression matching only
* the longest match in the string is retrieved. This function uses
* a different algorithm so it can retrieve all the possible matches.
* For more documentation see g_regex_match_all_full().
*
* A #GMatchInfo structure, used to get information on the match, is
* stored in @match_info if not %NULL. Note that if @match_info is
* not %NULL then it is created even if the function returns %FALSE,
* i.e. you must free it regardless if regular expression actually
* matched.
*
* @string is not copied and is used in #GMatchInfo internally. If
* you use any #GMatchInfo method (except g_match_info_free()) after
* freeing or modifying @string then the behaviour is undefined.
*
* Params:
* str = the string to scan for matches
* matchOptions = match options
* matchInfo = pointer to location where to store
* the #GMatchInfo, or %NULL if you do not need it
*
* Returns: %TRUE is the string matched, %FALSE otherwise
*
* Since: 2.14
*/
public bool matchAll(string str, GRegexMatchFlags matchOptions, out MatchInfo matchInfo)
{
GMatchInfo* outmatchInfo = null;
auto p = g_regex_match_all(gRegex, Str.toStringz(str), matchOptions, &outmatchInfo) != 0;
matchInfo = new MatchInfo(outmatchInfo);
return p;
}
/**
* Using the standard algorithm for regular expression matching only
* the longest match in the string is retrieved, it is not possible
* to obtain all the available matches. For instance matching
* " " against the pattern "<.*>"
* you get " ".
*
* This function uses a different algorithm (called DFA, i.e. deterministic
* finite automaton), so it can retrieve all the possible matches, all
* starting at the same point in the string. For instance matching
* " " against the pattern "<.*>;"
* you would obtain three matches: " ",
* " " and "".
*
* The number of matched strings is retrieved using
* g_match_info_get_match_count(). To obtain the matched strings and
* their position you can use, respectively, g_match_info_fetch() and
* g_match_info_fetch_pos(). Note that the strings are returned in
* reverse order of length; that is, the longest matching string is
* given first.
*
* Note that the DFA algorithm is slower than the standard one and it
* is not able to capture substrings, so backreferences do not work.
*
* Setting @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".
*
* A #GMatchInfo structure, used to get information on the match, is
* stored in @match_info if not %NULL. Note that if @match_info is
* not %NULL then it is created even if the function returns %FALSE,
* i.e. you must free it regardless if regular expression actually
* matched.
*
* @string is not copied and is used in #GMatchInfo internally. If
* you use any #GMatchInfo method (except g_match_info_free()) after
* freeing or modifying @string then the behaviour is undefined.
*
* Params:
* str = the string to scan for matches
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* matchOptions = match options
* matchInfo = pointer to location where to store
* the #GMatchInfo, or %NULL if you do not need it
*
* Returns: %TRUE is the string matched, %FALSE otherwise
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public bool matchAllFull(string str, int startPosition, GRegexMatchFlags matchOptions, out MatchInfo matchInfo)
{
GMatchInfo* outmatchInfo = null;
GError* err = null;
auto p = g_regex_match_all_full(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, matchOptions, &outmatchInfo, &err) != 0;
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
matchInfo = new MatchInfo(outmatchInfo);
return p;
}
/**
* Scans for a match in string for the pattern in @regex.
* The @match_options are combined with the match options specified
* when the @regex structure was created, letting you have more
* flexibility in reusing #GRegex structures.
*
* Setting @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".
*
* A #GMatchInfo structure, used to get information on the match, is
* stored in @match_info if not %NULL. Note that if @match_info is
* not %NULL then it is created even if the function returns %FALSE,
* i.e. you must free it regardless if regular expression actually
* matched.
*
* @string is not copied and is used in #GMatchInfo internally. If
* you use any #GMatchInfo method (except g_match_info_free()) after
* freeing or modifying @string then the behaviour is undefined.
*
* To retrieve all the non-overlapping matches of the pattern in
* string you can use g_match_info_next().
*
* |[
* static void
* print_uppercase_words (const gchar *string)
* {
* // Print all uppercase-only words.
* GRegex *regex;
* GMatchInfo *match_info;
* GError *error = NULL;
*
* regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
* g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
* while (g_match_info_matches (match_info))
* {
* gchar *word = g_match_info_fetch (match_info, 0);
* g_print ("Found: %s\n", word);
* g_free (word);
* g_match_info_next (match_info, &error);
* }
* g_match_info_free (match_info);
* g_regex_unref (regex);
* if (error != NULL)
* {
* g_printerr ("Error while matching: %s\n", error->message);
* g_error_free (error);
* }
* }
* ]|
*
* Params:
* str = the string to scan for matches
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* matchOptions = match options
* matchInfo = pointer to location where to store
* the #GMatchInfo, or %NULL if you do not need it
*
* Returns: %TRUE is the string matched, %FALSE otherwise
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public bool matchFull(string str, int startPosition, GRegexMatchFlags matchOptions, out MatchInfo matchInfo)
{
GMatchInfo* outmatchInfo = null;
GError* err = null;
auto p = g_regex_match_full(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, matchOptions, &outmatchInfo, &err) != 0;
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
matchInfo = new MatchInfo(outmatchInfo);
return p;
}
/**
* Increases reference count of @regex by 1.
*
* Returns: @regex
*
* Since: 2.14
*/
public Regex doref()
{
auto p = g_regex_ref(gRegex);
if(p is null)
{
return null;
}
return new Regex(cast(GRegex*) p, true);
}
/**
* Replaces all occurrences of the pattern in @regex with the
* replacement text. Backreferences of the form '\number' or
* '\g' in the replacement text are interpolated by the
* number-th captured subexpression of the match, '\g' 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:
*
* - \l: Convert to lower case the next character
* - \u: Convert to upper case the next character
* - \L: Convert to lower case till \E
* - \U: Convert to upper case till \E
* - \E: End case modification
*
* If you do not need to use backreferences use g_regex_replace_literal().
*
* The @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 @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".
*
* Params:
* str = the string to perform matches against
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* replacement = text to replace each match with
* matchOptions = options for the match
*
* Returns: a newly allocated string containing the replacements
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public string replace(string str, int startPosition, string replacement, GRegexMatchFlags matchOptions)
{
GError* err = null;
auto retStr = g_regex_replace(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, Str.toStringz(replacement), matchOptions, &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
scope(exit) Str.freeString(retStr);
return Str.toString(retStr);
}
/**
* Replaces occurrences of the pattern in regex with the output of
* @eval for that occurrence.
*
* Setting @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".
*
* The following example uses g_regex_replace_eval() to replace multiple
* strings at once:
* |[
* static gboolean
* eval_cb (const GMatchInfo *info,
* GString *res,
* gpointer data)
* {
* gchar *match;
* gchar *r;
*
* match = g_match_info_fetch (info, 0);
* r = g_hash_table_lookup ((GHashTable *)data, match);
* g_string_append (res, r);
* g_free (match);
*
* return FALSE;
* }
*
* ...
*
* GRegex *reg;
* GHashTable *h;
* gchar *res;
*
* h = g_hash_table_new (g_str_hash, g_str_equal);
*
* g_hash_table_insert (h, "1", "ONE");
* g_hash_table_insert (h, "2", "TWO");
* g_hash_table_insert (h, "3", "THREE");
* g_hash_table_insert (h, "4", "FOUR");
*
* reg = g_regex_new ("1|2|3|4", 0, 0, NULL);
* res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
* g_hash_table_destroy (h);
*
* ...
* ]|
*
* Params:
* str = string to perform matches against
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* matchOptions = options for the match
* eval = a function to call for each match
* userData = user data to pass to the function
*
* Returns: a newly allocated string containing the replacements
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public string replaceEval(string str, int startPosition, GRegexMatchFlags matchOptions, GRegexEvalCallback eval, void* userData)
{
GError* err = null;
auto retStr = g_regex_replace_eval(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, matchOptions, eval, userData, &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
scope(exit) Str.freeString(retStr);
return Str.toString(retStr);
}
/**
* Replaces all occurrences of the pattern in @regex with the
* replacement text. @replacement is replaced literally, to
* include backreferences use g_regex_replace().
*
* Setting @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".
*
* Params:
* str = the string to perform matches against
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* replacement = text to replace each match with
* matchOptions = options for the match
*
* Returns: a newly allocated string containing the replacements
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public string replaceLiteral(string str, int startPosition, string replacement, GRegexMatchFlags matchOptions)
{
GError* err = null;
auto retStr = g_regex_replace_literal(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, Str.toStringz(replacement), matchOptions, &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
scope(exit) Str.freeString(retStr);
return Str.toString(retStr);
}
/**
* 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 @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".
*
* Params:
* str = the string to split with the pattern
* matchOptions = match time option flags
*
* Returns: a %NULL-terminated gchar ** array. Free
* it using g_strfreev()
*
* Since: 2.14
*/
public string[] split(string str, GRegexMatchFlags matchOptions)
{
auto retStr = g_regex_split(gRegex, Str.toStringz(str), matchOptions);
scope(exit) Str.freeStringArray(retStr);
return Str.toStringArray(retStr);
}
/**
* 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 @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 @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".
*
* Params:
* str = the string to split with the pattern
* stringLen = the length of @string, or -1 if @string is nul-terminated
* startPosition = starting index of the string to match
* matchOptions = match time option flags
* maxTokens = the maximum number of tokens to split @string into.
* If this is less than 1, the string is split completely
*
* Returns: a %NULL-terminated gchar ** array. Free
* it using g_strfreev()
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public string[] splitFull(string str, int startPosition, GRegexMatchFlags matchOptions, int maxTokens)
{
GError* err = null;
auto retStr = g_regex_split_full(gRegex, Str.toStringz(str), cast(ptrdiff_t)str.length, startPosition, matchOptions, maxTokens, &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
scope(exit) Str.freeStringArray(retStr);
return Str.toStringArray(retStr);
}
/**
* Decreases reference count of @regex by 1. When reference count drops
* to zero, it frees all the memory associated with the regex structure.
*
* Since: 2.14
*/
public void unref()
{
g_regex_unref(gRegex);
}
/**
* Checks whether @replacement is a valid replacement string
* (see g_regex_replace()), i.e. that all escape sequences in
* it are valid.
*
* If @has_references is not %NULL then @replacement is checked
* for pattern references. For instance, replacement text 'foo\n'
* does not contain references and may be evaluated without information
* about actual match, but '\0\1' (whole match followed by first
* subpattern) requires valid #GMatchInfo object.
*
* Params:
* replacement = the replacement string
* hasReferences = location to store information about
* references in @replacement or %NULL
*
* Returns: whether @replacement is a valid replacement string
*
* Since: 2.14
*
* Throws: GException on failure.
*/
public static bool checkReplacement(string replacement, out bool hasReferences)
{
int outhasReferences;
GError* err = null;
auto p = g_regex_check_replacement(Str.toStringz(replacement), &outhasReferences, &err) != 0;
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
hasReferences = (outhasReferences == 1);
return p;
}
/** */
public static GQuark errorQuark()
{
return g_regex_error_quark();
}
/**
* Escapes the nul characters in @string to "\x00". It can be used
* to compile a regex with embedded nul characters.
*
* For completeness, @length can be -1 for a nul-terminated string.
* In this case the output string will be of course equal to @string.
*
* Params:
* str = the string to escape
* length = the length of @string
*
* Returns: a newly-allocated escaped string
*
* Since: 2.30
*/
public static string escapeNul(string str, int length)
{
auto retStr = g_regex_escape_nul(Str.toStringz(str), length);
scope(exit) Str.freeString(retStr);
return Str.toString(retStr);
}
/**
* Escapes the special characters used for regular expressions
* in @string, for instance "a.b*c" becomes "a\.b\*c". This
* function is useful to dynamically generate regular expressions.
*
* @string can contain nul characters that are replaced with "\0",
* in this case remember to specify the correct length of @string
* in @length.
*
* Params:
* str = the string to escape
* length = the length of @string, or -1 if @string is nul-terminated
*
* Returns: a newly-allocated escaped string
*
* Since: 2.14
*/
public static string escapeString(string str)
{
auto retStr = g_regex_escape_string(Str.toStringz(str), cast(int)str.length);
scope(exit) Str.freeString(retStr);
return Str.toString(retStr);
}
/**
* Scans for a match in @string for @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 @pattern more than
* once, it's more efficient to compile the pattern once with
* g_regex_new() and then use g_regex_match().
*
* Params:
* pattern = the regular expression
* str = the string to scan for matches
* compileOptions = compile options for the regular expression, or 0
* matchOptions = match options, or 0
*
* Returns: %TRUE if the string matched, %FALSE otherwise
*
* Since: 2.14
*/
public static bool matchSimple(string pattern, string str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions)
{
return g_regex_match_simple(Str.toStringz(pattern), Str.toStringz(str), compileOptions, matchOptions) != 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.
*
* 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 @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 @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".
*
* Params:
* pattern = the regular expression
* str = the string to scan for matches
* compileOptions = compile options for the regular expression, or 0
* matchOptions = match options, or 0
*
* Returns: a %NULL-terminated array of strings. Free
* it using g_strfreev()
*
* Since: 2.14
*/
public static string[] splitSimple(string pattern, string str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions)
{
auto retStr = g_regex_split_simple(Str.toStringz(pattern), Str.toStringz(str), compileOptions, matchOptions);
scope(exit) Str.freeStringArray(retStr);
return Str.toStringArray(retStr);
}
}