class RE2::MatchData

Public Instance Methods

[](p1, p2 = v2) click to toggle source

Retrieve zero, one or more matches by index or name.

@return [Array<String, nil>, String, Boolean]

@overload [](index)

Access a particular match by index.

@param [Fixnum] index the index of the match to fetch
@return [String, nil] the specified match
@example
  m = RE2::Regexp.new('(\d+)').match("bob 123")
  m[0]    #=> "123"

@overload [](start, length)

Access a range of matches by starting index and length.

@param [Fixnum] start the index from which to start
@param [Fixnum] length the number of elements to fetch
@return [Array<String, nil>] the specified matches
@example
  m = RE2::Regexp.new('(\d+)').match("bob 123")
  m[0, 1]    #=> ["123"]

@overload [](range)

Access a range of matches by index.

@param [Range] range the range of match indexes to fetch
@return [Array<String, nil>] the specified matches
@example
  m = RE2::Regexp.new('(\d+)').match("bob 123")
  m[0..1]    #=> "[123", "123"]

@overload [](name)

Access a particular match by name.

@param [String, Symbol] name the name of the match to fetch
@return [String, nil] the specific match
@example
  m = RE2::Regexp.new('(?P<number>\d+)').match("bob 123")
  m["number"] #=> "123"
  m[:number]  #=> "123"
static VALUE re2_matchdata_aref(int argc, VALUE *argv, VALUE self) {
  VALUE idx, rest;
  rb_scan_args(argc, argv, "11", &idx, &rest);

  if (TYPE(idx) == T_STRING) {
    return re2_matchdata_named_match(StringValuePtr(idx), self);
  } else if (SYMBOL_P(idx)) {
    return re2_matchdata_named_match(rb_id2name(SYM2ID(idx)), self);
  } else if (!NIL_P(rest) || !FIXNUM_P(idx) || FIX2INT(idx) < 0) {
    return rb_ary_aref(argc, argv, re2_matchdata_to_a(self));
  } else {
    return re2_matchdata_nth_match(FIX2INT(idx), self);
  }
}
begin(p1) click to toggle source

Returns the offset of the start of the nth element of the matchdata.

@param [Fixnum, String, Symbol] n the name or number of the match @return [Fixnum] the offset of the start of the match @example

m = RE2::Regexp.new('ob (\d+)').match("bob 123")
m.begin(0)  #=> 1
m.begin(1)  #=> 4
static VALUE re2_matchdata_begin(VALUE self, VALUE n) {
  re2_matchdata *m;
  re2_pattern *p;
  re2::StringPiece *match;
  long offset;

  Data_Get_Struct(self, re2_matchdata, m);
  Data_Get_Struct(m->regexp, re2_pattern, p);

  match = re2_matchdata_find_match(n, self);
  if (match == NULL) {
    return Qnil;
  } else {
    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text));

    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
           p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
  }
}
end(p1) click to toggle source

Returns the offset of the character following the end of the nth element of the matchdata.

@param [Fixnum, String, Symbol] n the name or number of the match @return [Fixnum] the offset of the character following the end of the match @example

m = RE2::Regexp.new('ob (\d+) b').match("bob 123 bob")
m.end(0)  #=> 9
m.end(1)  #=> 7
static VALUE re2_matchdata_end(VALUE self, VALUE n) {
  re2_matchdata *m;
  re2_pattern *p;
  re2::StringPiece *match;
  long offset;

  Data_Get_Struct(self, re2_matchdata, m);
  Data_Get_Struct(m->regexp, re2_pattern, p);

  match = re2_matchdata_find_match(n, self);

  if (match == NULL) {
    return Qnil;
  } else {
    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text)) + match->size();

    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
           p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
  }
}
inspect() click to toggle source

Returns a printable version of the match.

@return [String] a printable version of the match @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.inspect    #=> "#<RE2::MatchData \"123\" 1:\"123\">"
static VALUE re2_matchdata_inspect(VALUE self) {
  int i;
  re2_matchdata *m;
  re2_pattern *p;
  VALUE match, result;
  ostringstream output;

  Data_Get_Struct(self, re2_matchdata, m);
  Data_Get_Struct(m->regexp, re2_pattern, p);

  output << "#<RE2::MatchData";

  for (i = 0; i < m->number_of_matches; i++) {
    output << " ";

    if (i > 0) {
      output << i << ":";
    }

    match = re2_matchdata_nth_match(i, self);

    if (match == Qnil) {
      output << "nil";
    } else {
      output << "\"" << StringValuePtr(match) << "\"";
    }
  }

  output << ">";

  result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
      p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");

  return result;
}
length() click to toggle source

Returns the number of elements in the match array (including nils).

@return [Fixnum] the number of elements @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.size      #=> 2
m.length    #=> 2
static VALUE re2_matchdata_size(VALUE self) {
  re2_matchdata *m;
  Data_Get_Struct(self, re2_matchdata, m);

  return INT2FIX(m->number_of_matches);
}
regexp() click to toggle source

Returns the {RE2::Regexp} used in the match.

@return [RE2::Regexp] the regexp used in the match @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.regexp    #=> #<RE2::Regexp /(\d+)/>
static VALUE re2_matchdata_regexp(VALUE self) {
  re2_matchdata *m;
  Data_Get_Struct(self, re2_matchdata, m);
  return m->regexp;
}
size() click to toggle source

Returns the number of elements in the match array (including nils).

@return [Fixnum] the number of elements @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.size      #=> 2
m.length    #=> 2
static VALUE re2_matchdata_size(VALUE self) {
  re2_matchdata *m;
  Data_Get_Struct(self, re2_matchdata, m);

  return INT2FIX(m->number_of_matches);
}
string() click to toggle source

Returns a frozen copy of the string passed into match.

@return [String] a frozen copy of the passed string. @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.string  #=> "bob 123"
static VALUE re2_matchdata_string(VALUE self) {
  re2_matchdata *m;
  Data_Get_Struct(self, re2_matchdata, m);

  return m->text;
}
to_a() click to toggle source

Returns the array of matches.

@return [Array<String, nil>] the array of matches @example

m = RE2::Regexp.new('(\d+)').match("bob 123")
m.to_a    #=> ["123", "123"]
static VALUE re2_matchdata_to_a(VALUE self) {
  int i;
  re2_matchdata *m;
  re2_pattern *p;
  re2::StringPiece *match;
  VALUE array;

  Data_Get_Struct(self, re2_matchdata, m);
  Data_Get_Struct(m->regexp, re2_pattern, p);

  array = rb_ary_new2(m->number_of_matches);
  for (i = 0; i < m->number_of_matches; i++) {
    match = &m->matches[i];

    if (match->empty()) {
      rb_ary_push(array, Qnil);
    } else {
      rb_ary_push(array, ENCODED_STR_NEW(match->data(), match->size(),
            p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1"));
    }
  }

  return array;
}
to_s() click to toggle source

Returns the entire matched string.

@return [String] the entire matched string

static VALUE re2_matchdata_to_s(VALUE self) {
  return re2_matchdata_nth_match(0, self);
}