ruby/ext/google/protobuf_c/repeated_field.c

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2014 Google Inc.  All rights reserved.
   3 // https://developers.google.com/protocol-buffers/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 #include "protobuf.h"
  32
  33 // -----------------------------------------------------------------------------
  34 // Repeated field container type.
  35 // -----------------------------------------------------------------------------
  36
  37 const rb_data_type_t RepeatedField_type = {
  38   "Google::Protobuf::RepeatedField",
  39   { RepeatedField_mark, RepeatedField_free, NULL },
  40 };
  41
  42 VALUE cRepeatedField;
  43
  44 RepeatedField* ruby_to_RepeatedField(VALUE _self) {
  45   RepeatedField* self;
  46   TypedData_Get_Struct(_self, RepeatedField, &RepeatedField_type, self);
  47   return self;
  48 }
  49
  50 void* RepeatedField_memoryat(RepeatedField* self, int index, int element_size) {
  51   return ((uint8_t *)self->elements) + index * element_size;
  52 }
  53
  54 static int index_position(VALUE _index, RepeatedField* repeated_field) {
  55   int index = NUM2INT(_index);
  56   if (index < 0 && repeated_field->size > 0) {
  57     index = repeated_field->size + index;
  58   }
  59   return index;
  60 }
  61
  62 VALUE RepeatedField_subarray(VALUE _self, long beg, long len) {
  63   RepeatedField* self = ruby_to_RepeatedField(_self);
  64   int element_size = native_slot_size(self->field_type);
  65   upb_fieldtype_t field_type = self->field_type;
  66   VALUE field_type_class = self->field_type_class;
  67
  68   size_t off = beg * element_size;
  69   VALUE ary = rb_ary_new2(len);
  70   for (int i = beg; i < beg + len; i++, off += element_size) {
  71     void* mem = ((uint8_t *)self->elements) + off;
  72     VALUE elem = native_slot_get(field_type, field_type_class, mem);
  73     rb_ary_push(ary, elem);
  74   }
  75   return ary;
  76 }
  77
  78 /*
  79  * call-seq:
  80  *     RepeatedField.each(&block)
  81  *
  82  * Invokes the block once for each element of the repeated field. RepeatedField
  83  * also includes Enumerable; combined with this method, the repeated field thus
  84  * acts like an ordinary Ruby sequence.
  85  */
  86 VALUE RepeatedField_each(VALUE _self) {
  87   RepeatedField* self = ruby_to_RepeatedField(_self);
  88   upb_fieldtype_t field_type = self->field_type;
  89   VALUE field_type_class = self->field_type_class;
  90   int element_size = native_slot_size(field_type);
  91
  92   size_t off = 0;
  93   for (int i = 0; i < self->size; i++, off += element_size) {
  94     void* memory = (void *) (((uint8_t *)self->elements) + off);
  95     VALUE val = native_slot_get(field_type, field_type_class, memory);
  96     rb_yield(val);
  97   }
  98   return _self;
  99 }
 100
 101
 102 /*
 103  * call-seq:
 104  *     RepeatedField.[](index) => value
 105  *
 106  * Accesses the element at the given index. Returns nil on out-of-bounds
 107  */
 108 VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
 109   RepeatedField* self = ruby_to_RepeatedField(_self);
 110   int element_size = native_slot_size(self->field_type);
 111   upb_fieldtype_t field_type = self->field_type;
 112   VALUE field_type_class = self->field_type_class;
 113
 114   VALUE arg = argv[0];
 115   long beg, len;
 116
 117   if (argc == 1){
 118     if (FIXNUM_P(arg)) {
 119       /* standard case */
 120       void* memory;
 121       int index = index_position(argv[0], self);
 122       if (index < 0 || index >= self->size) {
 123         return Qnil;
 124       }
 125       memory = RepeatedField_memoryat(self, index, element_size);
 126       return native_slot_get(field_type, field_type_class, memory);
 127     }else{
 128       /* check if idx is Range */
 129       switch (rb_range_beg_len(arg, &beg, &len, self->size, 0)) {
 130         case Qfalse:
 131           break;
 132         case Qnil:
 133           return Qnil;
 134         default:
 135           return RepeatedField_subarray(_self, beg, len);
 136       }
 137     }
 138   }
 139   /* assume 2 arguments */
 140   beg = NUM2LONG(argv[0]);
 141   len = NUM2LONG(argv[1]);
 142   if (beg < 0) {
 143     beg += self->size;
 144   }
 145   if (beg >= self->size) {
 146     return Qnil;
 147   }
 148   return RepeatedField_subarray(_self, beg, len);
 149 }
 150
 151 /*
 152  * call-seq:
 153  *     RepeatedField.[]=(index, value)
 154  *
 155  * Sets the element at the given index. On out-of-bounds assignments, extends
 156  * the array and fills the hole (if any) with default values.
 157  */
 158 VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) {
 159   RepeatedField* self = ruby_to_RepeatedField(_self);
 160   upb_fieldtype_t field_type = self->field_type;
 161   VALUE field_type_class = self->field_type_class;
 162   int element_size = native_slot_size(field_type);
 163   void* memory;
 164
 165   int index = index_position(_index, self);
 166   if (index < 0 || index >= (INT_MAX - 1)) {
 167     return Qnil;
 168   }
 169   if (index >= self->size) {
 170     upb_fieldtype_t field_type = self->field_type;
 171     int element_size = native_slot_size(field_type);
 172     RepeatedField_reserve(self, index + 1);
 173     for (int i = self->size; i <= index; i++) {
 174       void* elem = RepeatedField_memoryat(self, i, element_size);
 175       native_slot_init(field_type, elem);
 176     }
 177     self->size = index + 1;
 178   }
 179
 180   memory = RepeatedField_memoryat(self, index, element_size);
 181   native_slot_set("", field_type, field_type_class, memory, val);
 182   return Qnil;
 183 }
 184
 185 static int kInitialSize = 8;
 186
 187 void RepeatedField_reserve(RepeatedField* self, int new_size) {
 188   void* old_elems = self->elements;
 189   int elem_size = native_slot_size(self->field_type);
 190   if (new_size <= self->capacity) {
 191     return;
 192   }
 193   if (self->capacity == 0) {
 194     self->capacity = kInitialSize;
 195   }
 196   while (self->capacity < new_size) {
 197     self->capacity *= 2;
 198   }
 199   self->elements = ALLOC_N(uint8_t, elem_size * self->capacity);
 200   if (old_elems != NULL) {
 201     memcpy(self->elements, old_elems, self->size * elem_size);
 202     xfree(old_elems);
 203   }
 204 }
 205
 206 /*
 207  * call-seq:
 208  *     RepeatedField.push(value)
 209  *
 210  * Adds a new element to the repeated field.
 211  */
 212 VALUE RepeatedField_push(VALUE _self, VALUE val) {
 213   RepeatedField* self = ruby_to_RepeatedField(_self);
 214   upb_fieldtype_t field_type = self->field_type;
 215   int element_size = native_slot_size(field_type);
 216   void* memory;
 217
 218   RepeatedField_reserve(self, self->size + 1);
 219   memory = (void *) (((uint8_t *)self->elements) + self->size * element_size);
 220   native_slot_set("", field_type, self->field_type_class, memory, val);
 221   // native_slot_set may raise an error; bump size only after set.
 222   self->size++;
 223   return _self;
 224 }
 225
 226 VALUE RepeatedField_push_vararg(VALUE _self, VALUE args) {
 227   for (int i = 0; i < RARRAY_LEN(args); i++) {
 228     RepeatedField_push(_self, rb_ary_entry(args, i));
 229   }
 230   return _self;
 231 }
 232
 233 // Used by parsing handlers.
 234 void RepeatedField_push_native(VALUE _self, void* data) {
 235   RepeatedField* self = ruby_to_RepeatedField(_self);
 236   upb_fieldtype_t field_type = self->field_type;
 237   int element_size = native_slot_size(field_type);
 238   void* memory;
 239
 240   RepeatedField_reserve(self, self->size + 1);
 241   memory = (void *) (((uint8_t *)self->elements) + self->size * element_size);
 242   memcpy(memory, data, element_size);
 243   self->size++;
 244 }
 245
 246 void* RepeatedField_index_native(VALUE _self, int index) {
 247   RepeatedField* self = ruby_to_RepeatedField(_self);
 248   upb_fieldtype_t field_type = self->field_type;
 249   int element_size = native_slot_size(field_type);
 250   return RepeatedField_memoryat(self, index, element_size);
 251 }
 252
 253 int RepeatedField_size(VALUE _self) {
 254   RepeatedField* self = ruby_to_RepeatedField(_self);
 255   return self->size;
 256 }
 257
 258 /*
 259  * Private ruby method, used by RepeatedField.pop
 260  */
 261 VALUE RepeatedField_pop_one(VALUE _self) {
 262   RepeatedField* self = ruby_to_RepeatedField(_self);
 263   upb_fieldtype_t field_type = self->field_type;
 264   VALUE field_type_class = self->field_type_class;
 265   int element_size = native_slot_size(field_type);
 266   int index;
 267   void* memory;
 268   VALUE ret;
 269
 270   if (self->size == 0) {
 271     return Qnil;
 272   }
 273   index = self->size - 1;
 274   memory = RepeatedField_memoryat(self, index, element_size);
 275   ret = native_slot_get(field_type, field_type_class, memory);
 276   self->size--;
 277   return ret;
 278 }
 279
 280 /*
 281  * call-seq:
 282  *     RepeatedField.replace(list)
 283  *
 284  * Replaces the contents of the repeated field with the given list of elements.
 285  */
 286 VALUE RepeatedField_replace(VALUE _self, VALUE list) {
 287   RepeatedField* self = ruby_to_RepeatedField(_self);
 288   Check_Type(list, T_ARRAY);
 289   self->size = 0;
 290   for (int i = 0; i < RARRAY_LEN(list); i++) {
 291     RepeatedField_push(_self, rb_ary_entry(list, i));
 292   }
 293   return list;
 294 }
 295
 296 /*
 297  * call-seq:
 298  *     RepeatedField.clear
 299  *
 300  * Clears (removes all elements from) this repeated field.
 301  */
 302 VALUE RepeatedField_clear(VALUE _self) {
 303   RepeatedField* self = ruby_to_RepeatedField(_self);
 304   self->size = 0;
 305   return _self;
 306 }
 307
 308 /*
 309  * call-seq:
 310  *     RepeatedField.length
 311  *
 312  * Returns the length of this repeated field.
 313  */
 314 VALUE RepeatedField_length(VALUE _self) {
 315   RepeatedField* self = ruby_to_RepeatedField(_self);
 316   return INT2NUM(self->size);
 317 }
 318
 319 static VALUE RepeatedField_new_this_type(VALUE _self) {
 320   RepeatedField* self = ruby_to_RepeatedField(_self);
 321   VALUE new_rptfield = Qnil;
 322   VALUE element_type = fieldtype_to_ruby(self->field_type);
 323   if (self->field_type_class != Qnil) {
 324     new_rptfield = rb_funcall(CLASS_OF(_self), rb_intern("new"), 2,
 325                               element_type, self->field_type_class);
 326   } else {
 327     new_rptfield = rb_funcall(CLASS_OF(_self), rb_intern("new"), 1,
 328                               element_type);
 329   }
 330   return new_rptfield;
 331 }
 332
 333 /*
 334  * call-seq:
 335  *     RepeatedField.dup => repeated_field
 336  *
 337  * Duplicates this repeated field with a shallow copy. References to all
 338  * non-primitive element objects (e.g., submessages) are shared.
 339  */
 340 VALUE RepeatedField_dup(VALUE _self) {
 341   RepeatedField* self = ruby_to_RepeatedField(_self);
 342   VALUE new_rptfield = RepeatedField_new_this_type(_self);
 343   RepeatedField* new_rptfield_self = ruby_to_RepeatedField(new_rptfield);
 344   upb_fieldtype_t field_type = self->field_type;
 345   size_t elem_size = native_slot_size(field_type);
 346   size_t off = 0;
 347   RepeatedField_reserve(new_rptfield_self, self->size);
 348   for (int i = 0; i < self->size; i++, off += elem_size) {
 349     void* to_mem = (uint8_t *)new_rptfield_self->elements + off;
 350     void* from_mem = (uint8_t *)self->elements + off;
 351     native_slot_dup(field_type, to_mem, from_mem);
 352     new_rptfield_self->size++;
 353   }
 354
 355   return new_rptfield;
 356 }
 357
 358 // Internal only: used by Google::Protobuf.deep_copy.
 359 VALUE RepeatedField_deep_copy(VALUE _self) {
 360   RepeatedField* self = ruby_to_RepeatedField(_self);
 361   VALUE new_rptfield = RepeatedField_new_this_type(_self);
 362   RepeatedField* new_rptfield_self = ruby_to_RepeatedField(new_rptfield);
 363   upb_fieldtype_t field_type = self->field_type;
 364   size_t elem_size = native_slot_size(field_type);
 365   size_t off = 0;
 366   RepeatedField_reserve(new_rptfield_self, self->size);
 367   for (int i = 0; i < self->size; i++, off += elem_size) {
 368     void* to_mem = (uint8_t *)new_rptfield_self->elements + off;
 369     void* from_mem = (uint8_t *)self->elements + off;
 370     native_slot_deep_copy(field_type, to_mem, from_mem);
 371     new_rptfield_self->size++;
 372   }
 373
 374   return new_rptfield;
 375 }
 376
 377 /*
 378  * call-seq:
 379  *     RepeatedField.to_ary => array
 380  *
 381  * Used when converted implicitly into array, e.g. compared to an Array.
 382  * Also called as a fallback of Object#to_a
 383  */
 384 VALUE RepeatedField_to_ary(VALUE _self) {
 385   RepeatedField* self = ruby_to_RepeatedField(_self);
 386   upb_fieldtype_t field_type = self->field_type;
 387
 388   size_t elem_size = native_slot_size(field_type);
 389   size_t off = 0;
 390   VALUE ary = rb_ary_new2(self->size);
 391   for (int i = 0; i < self->size; i++, off += elem_size) {
 392     void* mem = ((uint8_t *)self->elements) + off;
 393     VALUE elem = native_slot_get(field_type, self->field_type_class, mem);
 394     rb_ary_push(ary, elem);
 395   }
 396   return ary;
 397 }
 398
 399 /*
 400  * call-seq:
 401  *     RepeatedField.==(other) => boolean
 402  *
 403  * Compares this repeated field to another. Repeated fields are equal if their
 404  * element types are equal, their lengths are equal, and each element is equal.
 405  * Elements are compared as per normal Ruby semantics, by calling their :==
 406  * methods (or performing a more efficient comparison for primitive types).
 407  *
 408  * Repeated fields with dissimilar element types are never equal, even if value
 409  * comparison (for example, between integers and floats) would have otherwise
 410  * indicated that every element has equal value.
 411  */
 412 VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
 413   RepeatedField* self;
 414   RepeatedField* other;
 415
 416   if (_self == _other) {
 417     return Qtrue;
 418   }
 419
 420   if (TYPE(_other) == T_ARRAY) {
 421     VALUE self_ary = RepeatedField_to_ary(_self);
 422     return rb_equal(self_ary, _other);
 423   }
 424
 425   self = ruby_to_RepeatedField(_self);
 426   other = ruby_to_RepeatedField(_other);
 427   if (self->field_type != other->field_type ||
 428       self->field_type_class != other->field_type_class ||
 429       self->size != other->size) {
 430     return Qfalse;
 431   }
 432
 433   {
 434     upb_fieldtype_t field_type = self->field_type;
 435     size_t elem_size = native_slot_size(field_type);
 436     size_t off = 0;
 437     for (int i = 0; i < self->size; i++, off += elem_size) {
 438       void* self_mem = ((uint8_t *)self->elements) + off;
 439       void* other_mem = ((uint8_t *)other->elements) + off;
 440       if (!native_slot_eq(field_type, self_mem, other_mem)) {
 441         return Qfalse;
 442       }
 443     }
 444     return Qtrue;
 445   }
 446 }
 447
 448 /*
 449  * call-seq:
 450  *     RepeatedField.hash => hash_value
 451  *
 452  * Returns a hash value computed from this repeated field's elements.
 453  */
 454 VALUE RepeatedField_hash(VALUE _self) {
 455   RepeatedField* self = ruby_to_RepeatedField(_self);
 456   st_index_t h = rb_hash_start(0);
 457   VALUE hash_sym = rb_intern("hash");
 458   upb_fieldtype_t field_type = self->field_type;
 459   VALUE field_type_class = self->field_type_class;
 460   size_t elem_size = native_slot_size(field_type);
 461   size_t off = 0;
 462   for (int i = 0; i < self->size; i++, off += elem_size) {
 463     void* mem = ((uint8_t *)self->elements) + off;
 464     VALUE elem = native_slot_get(field_type, field_type_class, mem);
 465     h = rb_hash_uint(h, NUM2LONG(rb_funcall(elem, hash_sym, 0)));
 466   }
 467   h = rb_hash_end(h);
 468
 469   return INT2FIX(h);
 470 }
 471
 472 /*
 473  * call-seq:
 474  *     RepeatedField.+(other) => repeated field
 475  *
 476  * Returns a new repeated field that contains the concatenated list of this
 477  * repeated field's elements and other's elements. The other (second) list may
 478  * be either another repeated field or a Ruby array.
 479  */
 480 VALUE RepeatedField_plus(VALUE _self, VALUE list) {
 481   VALUE dupped = RepeatedField_dup(_self);
 482
 483   if (TYPE(list) == T_ARRAY) {
 484     for (int i = 0; i < RARRAY_LEN(list); i++) {
 485       VALUE elem = rb_ary_entry(list, i);
 486       RepeatedField_push(dupped, elem);
 487     }
 488   } else if (RB_TYPE_P(list, T_DATA) && RTYPEDDATA_P(list) &&
 489              RTYPEDDATA_TYPE(list) == &RepeatedField_type) {
 490     RepeatedField* self = ruby_to_RepeatedField(_self);
 491     RepeatedField* list_rptfield = ruby_to_RepeatedField(list);
 492     if (self->field_type != list_rptfield->field_type ||
 493         self->field_type_class != list_rptfield->field_type_class) {
 494       rb_raise(rb_eArgError,
 495                "Attempt to append RepeatedField with different element type.");
 496     }
 497     for (int i = 0; i < list_rptfield->size; i++) {
 498       void* mem = RepeatedField_index_native(list, i);
 499       RepeatedField_push_native(dupped, mem);
 500     }
 501   } else {
 502     rb_raise(rb_eArgError, "Unknown type appending to RepeatedField");
 503   }
 504
 505   return dupped;
 506 }
 507
 508 /*
 509  * call-seq:
 510  *     RepeatedField.concat(other) => self
 511  *
 512  * concats the passed in array to self.  Returns a Ruby array.
 513  */
 514 VALUE RepeatedField_concat(VALUE _self, VALUE list) {
 515   Check_Type(list, T_ARRAY);
 516   for (int i = 0; i < RARRAY_LEN(list); i++) {
 517     RepeatedField_push(_self, rb_ary_entry(list, i));
 518   }
 519   return _self;
 520 }
 521
 522
 523 void validate_type_class(upb_fieldtype_t type, VALUE klass) {
 524   if (rb_ivar_get(klass, descriptor_instancevar_interned) == Qnil) {
 525     rb_raise(rb_eArgError,
 526              "Type class has no descriptor. Please pass a "
 527              "class or enum as returned by the DescriptorPool.");
 528   }
 529   if (type == UPB_TYPE_MESSAGE) {
 530     VALUE desc = rb_ivar_get(klass, descriptor_instancevar_interned);
 531     if (!RB_TYPE_P(desc, T_DATA) || !RTYPEDDATA_P(desc) ||
 532         RTYPEDDATA_TYPE(desc) != &_Descriptor_type) {
 533       rb_raise(rb_eArgError, "Descriptor has an incorrect type.");
 534     }
 535     if (rb_get_alloc_func(klass) != &Message_alloc) {
 536       rb_raise(rb_eArgError,
 537                "Message class was not returned by the DescriptorPool.");
 538     }
 539   } else if (type == UPB_TYPE_ENUM) {
 540     VALUE enumdesc = rb_ivar_get(klass, descriptor_instancevar_interned);
 541     if (!RB_TYPE_P(enumdesc, T_DATA) || !RTYPEDDATA_P(enumdesc) ||
 542         RTYPEDDATA_TYPE(enumdesc) != &_EnumDescriptor_type) {
 543       rb_raise(rb_eArgError, "Descriptor has an incorrect type.");
 544     }
 545   }
 546 }
 547
 548 void RepeatedField_init_args(int argc, VALUE* argv,
 549                              VALUE _self) {
 550   RepeatedField* self = ruby_to_RepeatedField(_self);
 551   VALUE ary = Qnil;
 552   if (argc < 1) {
 553     rb_raise(rb_eArgError, "Expected at least 1 argument.");
 554   }
 555   self->field_type = ruby_to_fieldtype(argv[0]);
 556
 557   if (self->field_type == UPB_TYPE_MESSAGE ||
 558       self->field_type == UPB_TYPE_ENUM) {
 559     if (argc < 2) {
 560       rb_raise(rb_eArgError, "Expected at least 2 arguments for message/enum.");
 561     }
 562     self->field_type_class = argv[1];
 563     if (argc > 2) {
 564       ary = argv[2];
 565     }
 566     validate_type_class(self->field_type, self->field_type_class);
 567   } else {
 568     if (argc > 2) {
 569       rb_raise(rb_eArgError, "Too many arguments: expected 1 or 2.");
 570     }
 571     if (argc > 1) {
 572       ary = argv[1];
 573     }
 574   }
 575
 576   if (ary != Qnil) {
 577     if (!RB_TYPE_P(ary, T_ARRAY)) {
 578       rb_raise(rb_eArgError, "Expected array as initialize argument");
 579     }
 580     for (int i = 0; i < RARRAY_LEN(ary); i++) {
 581       RepeatedField_push(_self, rb_ary_entry(ary, i));
 582     }
 583   }
 584 }
 585
 586 // Mark, free, alloc, init and class setup functions.
 587
 588 void RepeatedField_mark(void* _self) {
 589   RepeatedField* self = (RepeatedField*)_self;
 590   upb_fieldtype_t field_type = self->field_type;
 591   int element_size = native_slot_size(field_type);
 592   rb_gc_mark(self->field_type_class);
 593   for (int i = 0; i < self->size; i++) {
 594     void* memory = (((uint8_t *)self->elements) + i * element_size);
 595     native_slot_mark(self->field_type, memory);
 596   }
 597 }
 598
 599 void RepeatedField_free(void* _self) {
 600   RepeatedField* self = (RepeatedField*)_self;
 601   xfree(self->elements);
 602   xfree(self);
 603 }
 604
 605 /*
 606  * call-seq:
 607  *     RepeatedField.new(type, type_class = nil, initial_elems = [])
 608  *
 609  * Creates a new repeated field. The provided type must be a Ruby symbol, and
 610  * can take on the same values as those accepted by FieldDescriptor#type=. If
 611  * the type is :message or :enum, type_class must be non-nil, and must be the
 612  * Ruby class or module returned by Descriptor#msgclass or
 613  * EnumDescriptor#enummodule, respectively. An initial list of elements may also
 614  * be provided.
 615  */
 616 VALUE RepeatedField_alloc(VALUE klass) {
 617   RepeatedField* self = ALLOC(RepeatedField);
 618   self->elements = NULL;
 619   self->size = 0;
 620   self->capacity = 0;
 621   self->field_type = -1;
 622   self->field_type_class = Qnil;
 623   return TypedData_Wrap_Struct(klass, &RepeatedField_type, self);
 624 }
 625
 626 VALUE RepeatedField_init(int argc, VALUE* argv, VALUE self) {
 627   RepeatedField_init_args(argc, argv, self);
 628   return Qnil;
 629 }
 630
 631 void RepeatedField_register(VALUE module) {
 632   VALUE klass = rb_define_class_under(
 633       module, "RepeatedField", rb_cObject);
 634   rb_define_alloc_func(klass, RepeatedField_alloc);
 635   rb_gc_register_address(&cRepeatedField);
 636   cRepeatedField = klass;
 637
 638   rb_define_method(klass, "initialize",
 639                    RepeatedField_init, -1);
 640   rb_define_method(klass, "each", RepeatedField_each, 0);
 641   rb_define_method(klass, "[]", RepeatedField_index, -1);
 642   rb_define_method(klass, "at", RepeatedField_index, -1);
 643   rb_define_method(klass, "[]=", RepeatedField_index_set, 2);
 644   rb_define_method(klass, "push", RepeatedField_push_vararg, -2);
 645   rb_define_method(klass, "<<", RepeatedField_push, 1);
 646   rb_define_private_method(klass, "pop_one", RepeatedField_pop_one, 0);
 647   rb_define_method(klass, "replace", RepeatedField_replace, 1);
 648   rb_define_method(klass, "clear", RepeatedField_clear, 0);
 649   rb_define_method(klass, "length", RepeatedField_length, 0);
 650   rb_define_method(klass, "size", RepeatedField_length, 0);
 651   rb_define_method(klass, "dup", RepeatedField_dup, 0);
 652   // Also define #clone so that we don't inherit Object#clone.
 653   rb_define_method(klass, "clone", RepeatedField_dup, 0);
 654   rb_define_method(klass, "==", RepeatedField_eq, 1);
 655   rb_define_method(klass, "to_ary", RepeatedField_to_ary, 0);
 656   rb_define_method(klass, "hash", RepeatedField_hash, 0);
 657   rb_define_method(klass, "+", RepeatedField_plus, 1);
 658   rb_define_method(klass, "concat", RepeatedField_concat, 1);
 659   rb_include_module(klass, rb_mEnumerable);
 660 }