546 lines
18 KiB
C
546 lines
18 KiB
C
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 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 <ext/spl/spl_iterators.h>
|
|
#include <Zend/zend_API.h>
|
|
#include <Zend/zend_interfaces.h>
|
|
|
|
#include "protobuf.h"
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetGet, 0, 0, 1)
|
|
ZEND_ARG_INFO(0, index)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetSet, 0, 0, 2)
|
|
ZEND_ARG_INFO(0, index)
|
|
ZEND_ARG_INFO(0, newval)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
ZEND_BEGIN_ARG_INFO(arginfo_void, 0)
|
|
ZEND_END_ARG_INFO()
|
|
|
|
static zend_function_entry repeated_field_methods[] = {
|
|
PHP_ME(RepeatedField, __construct, NULL, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, append, NULL, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, offsetExists, arginfo_offsetGet, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, offsetGet, arginfo_offsetGet, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, offsetSet, arginfo_offsetSet, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, offsetUnset, arginfo_offsetGet, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, count, arginfo_void, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedField, getIterator, arginfo_void, ZEND_ACC_PUBLIC)
|
|
ZEND_FE_END
|
|
};
|
|
|
|
static zend_function_entry repeated_field_iter_methods[] = {
|
|
PHP_ME(RepeatedFieldIter, rewind, arginfo_void, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedFieldIter, current, arginfo_void, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedFieldIter, key, arginfo_void, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedFieldIter, next, arginfo_void, ZEND_ACC_PUBLIC)
|
|
PHP_ME(RepeatedFieldIter, valid, arginfo_void, ZEND_ACC_PUBLIC)
|
|
ZEND_FE_END
|
|
};
|
|
|
|
// Forward declare static functions.
|
|
|
|
static int repeated_field_array_init(zval *array, upb_fieldtype_t type,
|
|
uint size ZEND_FILE_LINE_DC);
|
|
static void repeated_field_write_dimension(zval *object, zval *offset,
|
|
zval *value TSRMLS_DC);
|
|
static int repeated_field_has_dimension(zval *object, zval *offset TSRMLS_DC);
|
|
static HashTable *repeated_field_get_gc(zval *object, CACHED_VALUE **table,
|
|
int *n TSRMLS_DC);
|
|
#if PHP_MAJOR_VERSION < 7
|
|
static zend_object_value repeated_field_create(zend_class_entry *ce TSRMLS_DC);
|
|
static zend_object_value repeated_field_iter_create(zend_class_entry *ce TSRMLS_DC);
|
|
#else
|
|
static zend_object *repeated_field_create(zend_class_entry *ce TSRMLS_DC);
|
|
static zend_object *repeated_field_iter_create(zend_class_entry *ce TSRMLS_DC);
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// RepeatedField creation/desctruction
|
|
// -----------------------------------------------------------------------------
|
|
|
|
zend_class_entry* repeated_field_type;
|
|
zend_class_entry* repeated_field_iter_type;
|
|
zend_object_handlers* repeated_field_handlers;
|
|
zend_object_handlers* repeated_field_iter_handlers;
|
|
|
|
// Define object free method.
|
|
PHP_PROTO_OBJECT_FREE_START(RepeatedField, repeated_field)
|
|
#if PHP_MAJOR_VERSION < 7
|
|
php_proto_zval_ptr_dtor(intern->array);
|
|
#else
|
|
php_proto_zval_ptr_dtor(&intern->array);
|
|
#endif
|
|
PHP_PROTO_OBJECT_FREE_END
|
|
|
|
PHP_PROTO_OBJECT_DTOR_START(RepeatedField, repeated_field)
|
|
PHP_PROTO_OBJECT_DTOR_END
|
|
|
|
// Define object create method.
|
|
PHP_PROTO_OBJECT_CREATE_START(RepeatedField, repeated_field)
|
|
#if PHP_MAJOR_VERSION < 7
|
|
intern->array = NULL;
|
|
#endif
|
|
intern->type = 0;
|
|
intern->msg_ce = NULL;
|
|
PHP_PROTO_OBJECT_CREATE_END(RepeatedField, repeated_field)
|
|
|
|
// Init class entry.
|
|
PHP_PROTO_INIT_CLASS_START("Google\\Protobuf\\Internal\\RepeatedField",
|
|
RepeatedField, repeated_field)
|
|
zend_class_implements(repeated_field_type TSRMLS_CC, 3, spl_ce_ArrayAccess,
|
|
zend_ce_aggregate, spl_ce_Countable);
|
|
repeated_field_handlers->write_dimension = repeated_field_write_dimension;
|
|
repeated_field_handlers->get_gc = repeated_field_get_gc;
|
|
PHP_PROTO_INIT_CLASS_END
|
|
|
|
// Define array element free function.
|
|
#if PHP_MAJOR_VERSION < 7
|
|
static inline void php_proto_array_string_release(void *value) {
|
|
zval_ptr_dtor(value);
|
|
}
|
|
|
|
static inline void php_proto_array_object_release(void *value) {
|
|
zval_ptr_dtor(value);
|
|
}
|
|
static inline void php_proto_array_default_release(void *value) {
|
|
}
|
|
#else
|
|
static inline void php_proto_array_string_release(zval *value) {
|
|
void* ptr = Z_PTR_P(value);
|
|
zend_string* object = *(zend_string**)ptr;
|
|
zend_string_release(object);
|
|
efree(ptr);
|
|
}
|
|
static inline void php_proto_array_object_release(zval *value) {
|
|
zval_ptr_dtor(value);
|
|
}
|
|
static void php_proto_array_default_release(zval* value) {
|
|
void* ptr = Z_PTR_P(value);
|
|
efree(ptr);
|
|
}
|
|
#endif
|
|
|
|
static int repeated_field_array_init(zval *array, upb_fieldtype_t type,
|
|
uint size ZEND_FILE_LINE_DC) {
|
|
PHP_PROTO_ALLOC_ARRAY(array);
|
|
|
|
switch (type) {
|
|
case UPB_TYPE_STRING:
|
|
case UPB_TYPE_BYTES:
|
|
zend_hash_init(Z_ARRVAL_P(array), size, NULL,
|
|
php_proto_array_string_release, 0);
|
|
break;
|
|
case UPB_TYPE_MESSAGE:
|
|
zend_hash_init(Z_ARRVAL_P(array), size, NULL,
|
|
php_proto_array_object_release, 0);
|
|
break;
|
|
default:
|
|
zend_hash_init(Z_ARRVAL_P(array), size, NULL,
|
|
php_proto_array_default_release, 0);
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// RepeatedField Handlers
|
|
// -----------------------------------------------------------------------------
|
|
|
|
static void repeated_field_write_dimension(zval *object, zval *offset,
|
|
zval *value TSRMLS_DC) {
|
|
uint64_t index;
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, object);
|
|
HashTable *ht = PHP_PROTO_HASH_OF(intern->array);
|
|
int size = native_slot_size(intern->type);
|
|
|
|
unsigned char memory[NATIVE_SLOT_MAX_SIZE];
|
|
memset(memory, 0, NATIVE_SLOT_MAX_SIZE);
|
|
|
|
if (!native_slot_set_by_array(intern->type, intern->msg_ce, memory,
|
|
value TSRMLS_CC)) {
|
|
return;
|
|
}
|
|
|
|
if (!offset || Z_TYPE_P(offset) == IS_NULL) {
|
|
index = zend_hash_num_elements(PHP_PROTO_HASH_OF(intern->array));
|
|
} else {
|
|
if (protobuf_convert_to_uint64(offset, &index)) {
|
|
if (!zend_hash_index_exists(ht, index)) {
|
|
zend_error(E_USER_ERROR, "Element at %llu doesn't exist.\n",
|
|
(long long unsigned int)index);
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (intern->type == UPB_TYPE_MESSAGE) {
|
|
php_proto_zend_hash_index_update_zval(ht, index, *(zval**)memory);
|
|
} else {
|
|
php_proto_zend_hash_index_update_mem(ht, index, memory, size, NULL);
|
|
}
|
|
}
|
|
|
|
#if PHP_MAJOR_VERSION < 7
|
|
static HashTable *repeated_field_get_gc(zval *object, zval ***table,
|
|
int *n TSRMLS_DC) {
|
|
#else
|
|
static HashTable *repeated_field_get_gc(zval *object, zval **table, int *n) {
|
|
#endif
|
|
*table = NULL;
|
|
*n = 0;
|
|
RepeatedField *intern = UNBOX(RepeatedField, object);
|
|
return PHP_PROTO_HASH_OF(intern->array);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// C RepeatedField Utilities
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void *repeated_field_index_native(RepeatedField *intern, int index TSRMLS_DC) {
|
|
HashTable *ht = PHP_PROTO_HASH_OF(intern->array);
|
|
void *value;
|
|
|
|
if (intern->type == UPB_TYPE_MESSAGE) {
|
|
if (php_proto_zend_hash_index_find_zval(ht, index, (void **)&value) ==
|
|
FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %d doesn't exist.\n", index);
|
|
return NULL;
|
|
}
|
|
} else {
|
|
if (php_proto_zend_hash_index_find_mem(ht, index, (void **)&value) ==
|
|
FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %d doesn't exist.\n", index);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
void repeated_field_push_native(RepeatedField *intern, void *value) {
|
|
HashTable *ht = PHP_PROTO_HASH_OF(intern->array);
|
|
int size = native_slot_size(intern->type);
|
|
if (intern->type == UPB_TYPE_MESSAGE) {
|
|
php_proto_zend_hash_next_index_insert_zval(ht, value);
|
|
} else {
|
|
php_proto_zend_hash_next_index_insert_mem(ht, (void **)value, size, NULL);
|
|
}
|
|
}
|
|
|
|
void repeated_field_create_with_field(
|
|
zend_class_entry *ce, const upb_fielddef *field,
|
|
CACHED_VALUE *repeated_field PHP_PROTO_TSRMLS_DC) {
|
|
upb_fieldtype_t type = upb_fielddef_type(field);
|
|
const zend_class_entry *msg_ce = field_type_class(field PHP_PROTO_TSRMLS_CC);
|
|
repeated_field_create_with_type(ce, type, msg_ce,
|
|
repeated_field PHP_PROTO_TSRMLS_CC);
|
|
}
|
|
|
|
void repeated_field_create_with_type(
|
|
zend_class_entry *ce, upb_fieldtype_t type, const zend_class_entry *msg_ce,
|
|
CACHED_VALUE *repeated_field PHP_PROTO_TSRMLS_DC) {
|
|
CREATE_OBJ_ON_ALLOCATED_ZVAL_PTR(CACHED_PTR_TO_ZVAL_PTR(repeated_field),
|
|
repeated_field_type);
|
|
|
|
RepeatedField *intern =
|
|
UNBOX(RepeatedField, CACHED_TO_ZVAL_PTR(*repeated_field));
|
|
intern->type = type;
|
|
intern->msg_ce = msg_ce;
|
|
#if PHP_MAJOR_VERSION < 7
|
|
MAKE_STD_ZVAL(intern->array);
|
|
repeated_field_array_init(intern->array, intern->type, 0 ZEND_FILE_LINE_CC);
|
|
#else
|
|
repeated_field_array_init(&intern->array, intern->type, 0 ZEND_FILE_LINE_CC);
|
|
#endif
|
|
|
|
// TODO(teboring): Link class entry for message and enum
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// PHP RepeatedField Methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Constructs an instance of RepeatedField.
|
|
* @param long Type of the stored element.
|
|
* @param string Message/Enum class name (message/enum fields only).
|
|
*/
|
|
PHP_METHOD(RepeatedField, __construct) {
|
|
long type;
|
|
zend_class_entry* klass = NULL;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|C", &type, &klass) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
intern->type = to_fieldtype(type);
|
|
intern->msg_ce = klass;
|
|
|
|
#if PHP_MAJOR_VERSION < 7
|
|
MAKE_STD_ZVAL(intern->array);
|
|
repeated_field_array_init(intern->array, intern->type, 0 ZEND_FILE_LINE_CC);
|
|
#else
|
|
repeated_field_array_init(&intern->array, intern->type, 0 ZEND_FILE_LINE_CC);
|
|
#endif
|
|
|
|
if (intern->type == UPB_TYPE_MESSAGE && klass == NULL) {
|
|
zend_error(E_USER_ERROR, "Message type must have concrete class.");
|
|
return;
|
|
}
|
|
|
|
// TODO(teboring): Consider enum.
|
|
}
|
|
|
|
/**
|
|
* Append element to the end of the repeated field.
|
|
* @param object The element to be added.
|
|
*/
|
|
PHP_METHOD(RepeatedField, append) {
|
|
zval *value;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
repeated_field_write_dimension(getThis(), NULL, value TSRMLS_CC);
|
|
}
|
|
|
|
/**
|
|
* Check whether the element at given index exists.
|
|
* @param long The index to be checked.
|
|
* @return bool True if the element at the given index exists.
|
|
*/
|
|
PHP_METHOD(RepeatedField, offsetExists) {
|
|
long index;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
|
|
RETURN_BOOL(index >= 0 &&
|
|
index < zend_hash_num_elements(PHP_PROTO_HASH_OF(intern->array)));
|
|
}
|
|
|
|
/**
|
|
* Return the element at the given index.
|
|
* This will also be called for: $ele = $arr[0]
|
|
* @param long The index of the element to be fetched.
|
|
* @return object The stored element at given index.
|
|
* @exception Invalid type for index.
|
|
* @exception Non-existing index.
|
|
*/
|
|
PHP_METHOD(RepeatedField, offsetGet) {
|
|
long index;
|
|
void *memory;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
HashTable *table = PHP_PROTO_HASH_OF(intern->array);
|
|
|
|
if (intern->type == UPB_TYPE_MESSAGE) {
|
|
if (php_proto_zend_hash_index_find_zval(table, index, (void **)&memory) ==
|
|
FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %ld doesn't exist.\n", index);
|
|
return;
|
|
}
|
|
} else {
|
|
if (php_proto_zend_hash_index_find_mem(table, index, (void **)&memory) ==
|
|
FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %ld doesn't exist.\n", index);
|
|
return;
|
|
}
|
|
}
|
|
native_slot_get_by_array(intern->type, memory,
|
|
ZVAL_PTR_TO_CACHED_PTR(return_value) TSRMLS_CC);
|
|
}
|
|
|
|
/**
|
|
* Assign the element at the given index.
|
|
* This will also be called for: $arr []= $ele and $arr[0] = ele
|
|
* @param long The index of the element to be assigned.
|
|
* @param object The element to be assigned.
|
|
* @exception Invalid type for index.
|
|
* @exception Non-existing index.
|
|
* @exception Incorrect type of the element.
|
|
*/
|
|
PHP_METHOD(RepeatedField, offsetSet) {
|
|
zval *index, *value;
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &index, &value) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
repeated_field_write_dimension(getThis(), index, value TSRMLS_CC);
|
|
}
|
|
|
|
/**
|
|
* Remove the element at the given index.
|
|
* This will also be called for: unset($arr)
|
|
* @param long The index of the element to be removed.
|
|
* @exception Invalid type for index.
|
|
* @exception The element to be removed is not at the end of the RepeatedField.
|
|
*/
|
|
PHP_METHOD(RepeatedField, offsetUnset) {
|
|
long index;
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) ==
|
|
FAILURE) {
|
|
return;
|
|
}
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
|
|
// Only the element at the end of the array can be removed.
|
|
if (index == -1 ||
|
|
index != (zend_hash_num_elements(PHP_PROTO_HASH_OF(intern->array)) - 1)) {
|
|
zend_error(E_USER_ERROR, "Cannot remove element at %ld.\n", index);
|
|
return;
|
|
}
|
|
|
|
zend_hash_index_del(PHP_PROTO_HASH_OF(intern->array), index);
|
|
}
|
|
|
|
/**
|
|
* Return the number of stored elements.
|
|
* This will also be called for: count($arr)
|
|
* @return long The number of stored elements.
|
|
*/
|
|
PHP_METHOD(RepeatedField, count) {
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
return;
|
|
}
|
|
|
|
RETURN_LONG(zend_hash_num_elements(PHP_PROTO_HASH_OF(intern->array)));
|
|
}
|
|
|
|
/**
|
|
* Return the beginning iterator.
|
|
* This will also be called for: foreach($arr)
|
|
* @return object Beginning iterator.
|
|
*/
|
|
PHP_METHOD(RepeatedField, getIterator) {
|
|
CREATE_OBJ_ON_ALLOCATED_ZVAL_PTR(return_value,
|
|
repeated_field_iter_type);
|
|
|
|
RepeatedField *intern = UNBOX(RepeatedField, getThis());
|
|
RepeatedFieldIter *iter = UNBOX(RepeatedFieldIter, return_value);
|
|
iter->repeated_field = intern;
|
|
iter->position = 0;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// RepeatedFieldIter creation/desctruction
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Define object free method.
|
|
PHP_PROTO_OBJECT_FREE_START(RepeatedFieldIter, repeated_field_iter)
|
|
PHP_PROTO_OBJECT_FREE_END
|
|
|
|
PHP_PROTO_OBJECT_DTOR_START(RepeatedFieldIter, repeated_field_iter)
|
|
PHP_PROTO_OBJECT_DTOR_END
|
|
|
|
// Define object create method.
|
|
PHP_PROTO_OBJECT_CREATE_START(RepeatedFieldIter, repeated_field_iter)
|
|
intern->repeated_field = NULL;
|
|
intern->position = 0;
|
|
PHP_PROTO_OBJECT_CREATE_END(RepeatedFieldIter, repeated_field_iter)
|
|
|
|
// Init class entry.
|
|
PHP_PROTO_INIT_CLASS_START("Google\\Protobuf\\Internal\\RepeatedFieldIter",
|
|
RepeatedFieldIter, repeated_field_iter)
|
|
zend_class_implements(repeated_field_iter_type TSRMLS_CC, 1, zend_ce_iterator);
|
|
PHP_PROTO_INIT_CLASS_END
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// PHP RepeatedFieldIter Methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
PHP_METHOD(RepeatedFieldIter, rewind) {
|
|
RepeatedFieldIter *intern = UNBOX(RepeatedFieldIter, getThis());
|
|
intern->position = 0;
|
|
}
|
|
|
|
PHP_METHOD(RepeatedFieldIter, current) {
|
|
RepeatedFieldIter *intern = UNBOX(RepeatedFieldIter, getThis());
|
|
RepeatedField *repeated_field = intern->repeated_field;
|
|
|
|
long index;
|
|
void *memory;
|
|
|
|
HashTable *table = PHP_PROTO_HASH_OF(repeated_field->array);
|
|
|
|
if (repeated_field->type == UPB_TYPE_MESSAGE) {
|
|
if (php_proto_zend_hash_index_find_zval(table, intern->position,
|
|
(void **)&memory) == FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %d doesn't exist.\n", index);
|
|
return;
|
|
}
|
|
} else {
|
|
if (php_proto_zend_hash_index_find_mem(table, intern->position,
|
|
(void **)&memory) == FAILURE) {
|
|
zend_error(E_USER_ERROR, "Element at %d doesn't exist.\n", index);
|
|
return;
|
|
}
|
|
}
|
|
native_slot_get_by_array(repeated_field->type, memory,
|
|
ZVAL_PTR_TO_CACHED_PTR(return_value) TSRMLS_CC);
|
|
}
|
|
|
|
PHP_METHOD(RepeatedFieldIter, key) {
|
|
RepeatedFieldIter *intern = UNBOX(RepeatedFieldIter, getThis());
|
|
RETURN_LONG(intern->position);
|
|
}
|
|
|
|
PHP_METHOD(RepeatedFieldIter, next) {
|
|
RepeatedFieldIter *intern = UNBOX(RepeatedFieldIter, getThis());
|
|
++intern->position;
|
|
}
|
|
|
|
PHP_METHOD(RepeatedFieldIter, valid) {
|
|
RepeatedFieldIter *intern = UNBOX(RepeatedFieldIter, getThis());
|
|
RETURN_BOOL(zend_hash_num_elements(PHP_PROTO_HASH_OF(
|
|
intern->repeated_field->array)) > intern->position);
|
|
}
|