diff options
Diffstat (limited to 'third_party/protobuf/ruby/ext/google/protobuf_c/repeated_field.c')
-rw-r--r-- | third_party/protobuf/ruby/ext/google/protobuf_c/repeated_field.c | 654 |
1 files changed, 0 insertions, 654 deletions
diff --git a/third_party/protobuf/ruby/ext/google/protobuf_c/repeated_field.c b/third_party/protobuf/ruby/ext/google/protobuf_c/repeated_field.c deleted file mode 100644 index 1c651c192d..0000000000 --- a/third_party/protobuf/ruby/ext/google/protobuf_c/repeated_field.c +++ /dev/null @@ -1,654 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2014 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include "protobuf.h" - -// ----------------------------------------------------------------------------- -// Repeated field container type. -// ----------------------------------------------------------------------------- - -const rb_data_type_t RepeatedField_type = { - "Google::Protobuf::RepeatedField", - { RepeatedField_mark, RepeatedField_free, NULL }, -}; - -VALUE cRepeatedField; - -RepeatedField* ruby_to_RepeatedField(VALUE _self) { - RepeatedField* self; - TypedData_Get_Struct(_self, RepeatedField, &RepeatedField_type, self); - return self; -} - -void* RepeatedField_memoryat(RepeatedField* self, int index, int element_size) { - return ((uint8_t *)self->elements) + index * element_size; -} - -static int index_position(VALUE _index, RepeatedField* repeated_field) { - int index = NUM2INT(_index); - if (index < 0 && repeated_field->size > 0) { - index = repeated_field->size + index; - } - return index; -} - -VALUE RepeatedField_subarray(VALUE _self, long beg, long len) { - RepeatedField* self = ruby_to_RepeatedField(_self); - int element_size = native_slot_size(self->field_type); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - - size_t off = beg * element_size; - VALUE ary = rb_ary_new2(len); - for (int i = beg; i < beg + len; i++, off += element_size) { - void* mem = ((uint8_t *)self->elements) + off; - VALUE elem = native_slot_get(field_type, field_type_class, mem); - rb_ary_push(ary, elem); - } - return ary; -} - -/* - * call-seq: - * RepeatedField.each(&block) - * - * Invokes the block once for each element of the repeated field. RepeatedField - * also includes Enumerable; combined with this method, the repeated field thus - * acts like an ordinary Ruby sequence. - */ -VALUE RepeatedField_each(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - int element_size = native_slot_size(field_type); - - size_t off = 0; - for (int i = 0; i < self->size; i++, off += element_size) { - void* memory = (void *) (((uint8_t *)self->elements) + off); - VALUE val = native_slot_get(field_type, field_type_class, memory); - rb_yield(val); - } - return _self; -} - - -/* - * call-seq: - * RepeatedField.[](index) => value - * - * Accesses the element at the given index. Returns nil on out-of-bounds - */ -VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - int element_size = native_slot_size(self->field_type); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - - VALUE arg = argv[0]; - long beg, len; - - if (argc == 1){ - if (FIXNUM_P(arg)) { - /* standard case */ - void* memory; - int index = index_position(argv[0], self); - if (index < 0 || index >= self->size) { - return Qnil; - } - memory = RepeatedField_memoryat(self, index, element_size); - return native_slot_get(field_type, field_type_class, memory); - }else{ - /* check if idx is Range */ - switch (rb_range_beg_len(arg, &beg, &len, self->size, 0)) { - case Qfalse: - break; - case Qnil: - return Qnil; - default: - return RepeatedField_subarray(_self, beg, len); - } - } - } - /* assume 2 arguments */ - beg = NUM2LONG(argv[0]); - len = NUM2LONG(argv[1]); - if (beg < 0) { - beg += self->size; - } - if (beg >= self->size) { - return Qnil; - } - return RepeatedField_subarray(_self, beg, len); -} - -/* - * call-seq: - * RepeatedField.[]=(index, value) - * - * Sets the element at the given index. On out-of-bounds assignments, extends - * the array and fills the hole (if any) with default values. - */ -VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - int element_size = native_slot_size(field_type); - void* memory; - - int index = index_position(_index, self); - if (index < 0 || index >= (INT_MAX - 1)) { - return Qnil; - } - if (index >= self->size) { - upb_fieldtype_t field_type = self->field_type; - int element_size = native_slot_size(field_type); - RepeatedField_reserve(self, index + 1); - for (int i = self->size; i <= index; i++) { - void* elem = RepeatedField_memoryat(self, i, element_size); - native_slot_init(field_type, elem); - } - self->size = index + 1; - } - - memory = RepeatedField_memoryat(self, index, element_size); - native_slot_set(field_type, field_type_class, memory, val); - return Qnil; -} - -static int kInitialSize = 8; - -void RepeatedField_reserve(RepeatedField* self, int new_size) { - void* old_elems = self->elements; - int elem_size = native_slot_size(self->field_type); - if (new_size <= self->capacity) { - return; - } - if (self->capacity == 0) { - self->capacity = kInitialSize; - } - while (self->capacity < new_size) { - self->capacity *= 2; - } - self->elements = ALLOC_N(uint8_t, elem_size * self->capacity); - if (old_elems != NULL) { - memcpy(self->elements, old_elems, self->size * elem_size); - xfree(old_elems); - } -} - -/* - * call-seq: - * RepeatedField.push(value) - * - * Adds a new element to the repeated field. - */ -VALUE RepeatedField_push(VALUE _self, VALUE val) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - int element_size = native_slot_size(field_type); - void* memory; - - RepeatedField_reserve(self, self->size + 1); - memory = (void *) (((uint8_t *)self->elements) + self->size * element_size); - native_slot_set(field_type, self->field_type_class, memory, val); - // native_slot_set may raise an error; bump size only after set. - self->size++; - return _self; -} - - -// Used by parsing handlers. -void RepeatedField_push_native(VALUE _self, void* data) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - int element_size = native_slot_size(field_type); - void* memory; - - RepeatedField_reserve(self, self->size + 1); - memory = (void *) (((uint8_t *)self->elements) + self->size * element_size); - memcpy(memory, data, element_size); - self->size++; -} - -void* RepeatedField_index_native(VALUE _self, int index) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - int element_size = native_slot_size(field_type); - return RepeatedField_memoryat(self, index, element_size); -} - -int RepeatedField_size(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - return self->size; -} - -/* - * Private ruby method, used by RepeatedField.pop - */ -VALUE RepeatedField_pop_one(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - int element_size = native_slot_size(field_type); - int index; - void* memory; - VALUE ret; - - if (self->size == 0) { - return Qnil; - } - index = self->size - 1; - memory = RepeatedField_memoryat(self, index, element_size); - ret = native_slot_get(field_type, field_type_class, memory); - self->size--; - return ret; -} - -/* - * call-seq: - * RepeatedField.replace(list) - * - * Replaces the contents of the repeated field with the given list of elements. - */ -VALUE RepeatedField_replace(VALUE _self, VALUE list) { - RepeatedField* self = ruby_to_RepeatedField(_self); - Check_Type(list, T_ARRAY); - self->size = 0; - for (int i = 0; i < RARRAY_LEN(list); i++) { - RepeatedField_push(_self, rb_ary_entry(list, i)); - } - return list; -} - -/* - * call-seq: - * RepeatedField.clear - * - * Clears (removes all elements from) this repeated field. - */ -VALUE RepeatedField_clear(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - self->size = 0; - return _self; -} - -/* - * call-seq: - * RepeatedField.length - * - * Returns the length of this repeated field. - */ -VALUE RepeatedField_length(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - return INT2NUM(self->size); -} - -static VALUE RepeatedField_new_this_type(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - VALUE new_rptfield = Qnil; - VALUE element_type = fieldtype_to_ruby(self->field_type); - if (self->field_type_class != Qnil) { - new_rptfield = rb_funcall(CLASS_OF(_self), rb_intern("new"), 2, - element_type, self->field_type_class); - } else { - new_rptfield = rb_funcall(CLASS_OF(_self), rb_intern("new"), 1, - element_type); - } - return new_rptfield; -} - -/* - * call-seq: - * RepeatedField.dup => repeated_field - * - * Duplicates this repeated field with a shallow copy. References to all - * non-primitive element objects (e.g., submessages) are shared. - */ -VALUE RepeatedField_dup(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - VALUE new_rptfield = RepeatedField_new_this_type(_self); - RepeatedField* new_rptfield_self = ruby_to_RepeatedField(new_rptfield); - upb_fieldtype_t field_type = self->field_type; - size_t elem_size = native_slot_size(field_type); - size_t off = 0; - RepeatedField_reserve(new_rptfield_self, self->size); - for (int i = 0; i < self->size; i++, off += elem_size) { - void* to_mem = (uint8_t *)new_rptfield_self->elements + off; - void* from_mem = (uint8_t *)self->elements + off; - native_slot_dup(field_type, to_mem, from_mem); - new_rptfield_self->size++; - } - - return new_rptfield; -} - -// Internal only: used by Google::Protobuf.deep_copy. -VALUE RepeatedField_deep_copy(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - VALUE new_rptfield = RepeatedField_new_this_type(_self); - RepeatedField* new_rptfield_self = ruby_to_RepeatedField(new_rptfield); - upb_fieldtype_t field_type = self->field_type; - size_t elem_size = native_slot_size(field_type); - size_t off = 0; - RepeatedField_reserve(new_rptfield_self, self->size); - for (int i = 0; i < self->size; i++, off += elem_size) { - void* to_mem = (uint8_t *)new_rptfield_self->elements + off; - void* from_mem = (uint8_t *)self->elements + off; - native_slot_deep_copy(field_type, to_mem, from_mem); - new_rptfield_self->size++; - } - - return new_rptfield; -} - -/* - * call-seq: - * RepeatedField.to_ary => array - * - * Used when converted implicitly into array, e.g. compared to an Array. - * Also called as a fallback of Object#to_a - */ -VALUE RepeatedField_to_ary(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - upb_fieldtype_t field_type = self->field_type; - - size_t elem_size = native_slot_size(field_type); - size_t off = 0; - VALUE ary = rb_ary_new2(self->size); - for (int i = 0; i < self->size; i++, off += elem_size) { - void* mem = ((uint8_t *)self->elements) + off; - VALUE elem = native_slot_get(field_type, self->field_type_class, mem); - rb_ary_push(ary, elem); - } - return ary; -} - -/* - * call-seq: - * RepeatedField.==(other) => boolean - * - * Compares this repeated field to another. Repeated fields are equal if their - * element types are equal, their lengths are equal, and each element is equal. - * Elements are compared as per normal Ruby semantics, by calling their :== - * methods (or performing a more efficient comparison for primitive types). - * - * Repeated fields with dissimilar element types are never equal, even if value - * comparison (for example, between integers and floats) would have otherwise - * indicated that every element has equal value. - */ -VALUE RepeatedField_eq(VALUE _self, VALUE _other) { - RepeatedField* self; - RepeatedField* other; - - if (_self == _other) { - return Qtrue; - } - - if (TYPE(_other) == T_ARRAY) { - VALUE self_ary = RepeatedField_to_ary(_self); - return rb_equal(self_ary, _other); - } - - self = ruby_to_RepeatedField(_self); - other = ruby_to_RepeatedField(_other); - if (self->field_type != other->field_type || - self->field_type_class != other->field_type_class || - self->size != other->size) { - return Qfalse; - } - - { - upb_fieldtype_t field_type = self->field_type; - size_t elem_size = native_slot_size(field_type); - size_t off = 0; - for (int i = 0; i < self->size; i++, off += elem_size) { - void* self_mem = ((uint8_t *)self->elements) + off; - void* other_mem = ((uint8_t *)other->elements) + off; - if (!native_slot_eq(field_type, self_mem, other_mem)) { - return Qfalse; - } - } - return Qtrue; - } -} - -/* - * call-seq: - * RepeatedField.hash => hash_value - * - * Returns a hash value computed from this repeated field's elements. - */ -VALUE RepeatedField_hash(VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - st_index_t h = rb_hash_start(0); - VALUE hash_sym = rb_intern("hash"); - upb_fieldtype_t field_type = self->field_type; - VALUE field_type_class = self->field_type_class; - size_t elem_size = native_slot_size(field_type); - size_t off = 0; - for (int i = 0; i < self->size; i++, off += elem_size) { - void* mem = ((uint8_t *)self->elements) + off; - VALUE elem = native_slot_get(field_type, field_type_class, mem); - h = rb_hash_uint(h, NUM2LONG(rb_funcall(elem, hash_sym, 0))); - } - h = rb_hash_end(h); - - return INT2FIX(h); -} - -/* - * call-seq: - * RepeatedField.+(other) => repeated field - * - * Returns a new repeated field that contains the concatenated list of this - * repeated field's elements and other's elements. The other (second) list may - * be either another repeated field or a Ruby array. - */ -VALUE RepeatedField_plus(VALUE _self, VALUE list) { - VALUE dupped = RepeatedField_dup(_self); - - if (TYPE(list) == T_ARRAY) { - for (int i = 0; i < RARRAY_LEN(list); i++) { - VALUE elem = rb_ary_entry(list, i); - RepeatedField_push(dupped, elem); - } - } else if (RB_TYPE_P(list, T_DATA) && RTYPEDDATA_P(list) && - RTYPEDDATA_TYPE(list) == &RepeatedField_type) { - RepeatedField* self = ruby_to_RepeatedField(_self); - RepeatedField* list_rptfield = ruby_to_RepeatedField(list); - if (self->field_type != list_rptfield->field_type || - self->field_type_class != list_rptfield->field_type_class) { - rb_raise(rb_eArgError, - "Attempt to append RepeatedField with different element type."); - } - for (int i = 0; i < list_rptfield->size; i++) { - void* mem = RepeatedField_index_native(list, i); - RepeatedField_push_native(dupped, mem); - } - } else { - rb_raise(rb_eArgError, "Unknown type appending to RepeatedField"); - } - - return dupped; -} - -/* - * call-seq: - * RepeatedField.concat(other) => self - * - * concats the passed in array to self. Returns a Ruby array. - */ -VALUE RepeatedField_concat(VALUE _self, VALUE list) { - Check_Type(list, T_ARRAY); - for (int i = 0; i < RARRAY_LEN(list); i++) { - RepeatedField_push(_self, rb_ary_entry(list, i)); - } - return _self; -} - - -void validate_type_class(upb_fieldtype_t type, VALUE klass) { - if (rb_ivar_get(klass, descriptor_instancevar_interned) == Qnil) { - rb_raise(rb_eArgError, - "Type class has no descriptor. Please pass a " - "class or enum as returned by the DescriptorPool."); - } - if (type == UPB_TYPE_MESSAGE) { - VALUE desc = rb_ivar_get(klass, descriptor_instancevar_interned); - if (!RB_TYPE_P(desc, T_DATA) || !RTYPEDDATA_P(desc) || - RTYPEDDATA_TYPE(desc) != &_Descriptor_type) { - rb_raise(rb_eArgError, "Descriptor has an incorrect type."); - } - if (rb_get_alloc_func(klass) != &Message_alloc) { - rb_raise(rb_eArgError, - "Message class was not returned by the DescriptorPool."); - } - } else if (type == UPB_TYPE_ENUM) { - VALUE enumdesc = rb_ivar_get(klass, descriptor_instancevar_interned); - if (!RB_TYPE_P(enumdesc, T_DATA) || !RTYPEDDATA_P(enumdesc) || - RTYPEDDATA_TYPE(enumdesc) != &_EnumDescriptor_type) { - rb_raise(rb_eArgError, "Descriptor has an incorrect type."); - } - } -} - -void RepeatedField_init_args(int argc, VALUE* argv, - VALUE _self) { - RepeatedField* self = ruby_to_RepeatedField(_self); - VALUE ary = Qnil; - if (argc < 1) { - rb_raise(rb_eArgError, "Expected at least 1 argument."); - } - self->field_type = ruby_to_fieldtype(argv[0]); - - if (self->field_type == UPB_TYPE_MESSAGE || - self->field_type == UPB_TYPE_ENUM) { - if (argc < 2) { - rb_raise(rb_eArgError, "Expected at least 2 arguments for message/enum."); - } - self->field_type_class = argv[1]; - if (argc > 2) { - ary = argv[2]; - } - validate_type_class(self->field_type, self->field_type_class); - } else { - if (argc > 2) { - rb_raise(rb_eArgError, "Too many arguments: expected 1 or 2."); - } - if (argc > 1) { - ary = argv[1]; - } - } - - if (ary != Qnil) { - if (!RB_TYPE_P(ary, T_ARRAY)) { - rb_raise(rb_eArgError, "Expected array as initialize argument"); - } - for (int i = 0; i < RARRAY_LEN(ary); i++) { - RepeatedField_push(_self, rb_ary_entry(ary, i)); - } - } -} - -// Mark, free, alloc, init and class setup functions. - -void RepeatedField_mark(void* _self) { - RepeatedField* self = (RepeatedField*)_self; - upb_fieldtype_t field_type = self->field_type; - int element_size = native_slot_size(field_type); - rb_gc_mark(self->field_type_class); - for (int i = 0; i < self->size; i++) { - void* memory = (((uint8_t *)self->elements) + i * element_size); - native_slot_mark(self->field_type, memory); - } -} - -void RepeatedField_free(void* _self) { - RepeatedField* self = (RepeatedField*)_self; - xfree(self->elements); - xfree(self); -} - -/* - * call-seq: - * RepeatedField.new(type, type_class = nil, initial_elems = []) - * - * Creates a new repeated field. The provided type must be a Ruby symbol, and - * can take on the same values as those accepted by FieldDescriptor#type=. If - * the type is :message or :enum, type_class must be non-nil, and must be the - * Ruby class or module returned by Descriptor#msgclass or - * EnumDescriptor#enummodule, respectively. An initial list of elements may also - * be provided. - */ -VALUE RepeatedField_alloc(VALUE klass) { - RepeatedField* self = ALLOC(RepeatedField); - self->elements = NULL; - self->size = 0; - self->capacity = 0; - self->field_type = -1; - self->field_type_class = Qnil; - return TypedData_Wrap_Struct(klass, &RepeatedField_type, self); -} - -VALUE RepeatedField_init(int argc, VALUE* argv, VALUE self) { - RepeatedField_init_args(argc, argv, self); - return Qnil; -} - -void RepeatedField_register(VALUE module) { - VALUE klass = rb_define_class_under( - module, "RepeatedField", rb_cObject); - rb_define_alloc_func(klass, RepeatedField_alloc); - cRepeatedField = klass; - rb_gc_register_address(&cRepeatedField); - - rb_define_method(klass, "initialize", - RepeatedField_init, -1); - rb_define_method(klass, "each", RepeatedField_each, 0); - rb_define_method(klass, "[]", RepeatedField_index, -1); - rb_define_method(klass, "at", RepeatedField_index, -1); - rb_define_method(klass, "[]=", RepeatedField_index_set, 2); - rb_define_method(klass, "push", RepeatedField_push, 1); - rb_define_method(klass, "<<", RepeatedField_push, 1); - rb_define_private_method(klass, "pop_one", RepeatedField_pop_one, 0); - rb_define_method(klass, "replace", RepeatedField_replace, 1); - rb_define_method(klass, "clear", RepeatedField_clear, 0); - rb_define_method(klass, "length", RepeatedField_length, 0); - rb_define_method(klass, "size", RepeatedField_length, 0); - rb_define_method(klass, "dup", RepeatedField_dup, 0); - // Also define #clone so that we don't inherit Object#clone. - rb_define_method(klass, "clone", RepeatedField_dup, 0); - rb_define_method(klass, "==", RepeatedField_eq, 1); - rb_define_method(klass, "to_ary", RepeatedField_to_ary, 0); - rb_define_method(klass, "hash", RepeatedField_hash, 0); - rb_define_method(klass, "+", RepeatedField_plus, 1); - rb_define_method(klass, "concat", RepeatedField_concat, 1); - rb_include_module(klass, rb_mEnumerable); -} |