Variant f_array_replace(int _argc, CVarRef array1,
CArrRef _argv /* = null_array */) {
getCheckedArray(array1);
Array ret = Array::Create();
php_array_replace(ret, arr_array1);
for (ArrayIter iter(_argv); iter; ++iter) {
CVarRef v = iter.secondRef();
getCheckedArray(v);
php_array_replace(ret, arr_v);
}
return ret;
}
Variant f_array_replace_recursive(int _argc, CVarRef array1,
CArrRef _argv /* = null_array */) {
getCheckedArray(array1);
Array ret = Array::Create();
PointerSet seen;
php_array_replace_recursive(seen, false, ret, arr_array1);
assert(seen.empty());
for (ArrayIter iter(_argv); iter; ++iter) {
CVarRef v = iter.secondRef();
getCheckedArray(v);
php_array_replace_recursive(seen, false, ret, arr_v);
assert(seen.empty());
}
return ret;
}
Variant f_array_pad(CVarRef input, int pad_size, CVarRef pad_value) {
getCheckedArray(input);
if (pad_size > 0) {
return ArrayUtil::Pad(arr_input, pad_value, pad_size, true);
}
return ArrayUtil::Pad(arr_input, pad_value, -pad_size, false);
}
Variant f_array_slice(CVarRef array, int offset,
CVarRef length /* = null_variant */,
bool preserve_keys /* = false */) {
getCheckedArray(array);
int64_t len = length.isNull() ? 0x7FFFFFFF : length.toInt64();
return ArrayUtil::Slice(arr_array, offset, len, preserve_keys);
}
Variant f_array_splice(VRefParam input, int offset,
CVarRef length /* = null_variant */,
CVarRef replacement /* = null_variant */) {
getCheckedArray(input);
Array ret(Array::Create());
int64_t len = length.isNull() ? 0x7FFFFFFF : length.toInt64();
input = ArrayUtil::Splice(arr_input, offset, len, replacement, &ret);
return ret;
}
Variant f_array_sum(CVarRef array) {
getCheckedArray(array);
int64_t i;
double d;
if (ArrayUtil::Sum(arr_array, &i, &d) == KindOfInt64) {
return i;
} else {
return d;
}
}
Variant f_array_reduce(CVarRef input, CVarRef callback,
CVarRef initial /* = null_variant */) {
getCheckedArray(input);
CallCtx ctx;
CallerFrame cf;
vm_decode_function(callback, cf(), false, ctx);
if (ctx.func == NULL) {
return uninit_null();
}
return ArrayUtil::Reduce(arr_input, reduce_func, &ctx, initial);
}
Variant f_array_product(CVarRef array) {
getCheckedArray(array);
if (arr_array.empty()) {
return 0; // to be consistent with PHP
}
int64_t i;
double d;
if (ArrayUtil::Product(arr_array, &i, &d) == KindOfInt64) {
return i;
} else {
return d;
}
}
Variant f_array_filter(CVarRef input, CVarRef callback /* = null_variant */) {
getCheckedArray(input);
if (callback.isNull()) {
return ArrayUtil::Filter(arr_input);
}
CallCtx ctx;
EagerCallerFrame cf;
vm_decode_function(callback, cf(), false, ctx);
if (ctx.func == NULL) {
return uninit_null();
}
return ArrayUtil::Filter(arr_input, filter_func, &ctx);
}
Variant f_array_merge(int _argc, CVarRef array1,
CArrRef _argv /* = null_array */) {
getCheckedArray(array1);
Array ret = Array::Create();
php_array_merge(ret, arr_array1);
for (ArrayIter iter(_argv); iter; ++iter) {
Variant v = iter.second();
if (!v.isArray()) {
throw_bad_array_exception();
return uninit_null();
}
CArrRef arr_v = v.asCArrRef();
php_array_merge(ret, arr_v);
}
return ret;
}
Variant f_array_merge_recursive(int _argc, CVarRef array1,
CArrRef _argv /* = null_array */) {
getCheckedArray(array1);
Array ret = Array::Create();
PointerSet seen;
php_array_merge_recursive(seen, false, ret, arr_array1);
assert(seen.empty());
for (ArrayIter iter(_argv); iter; ++iter) {
Variant v = iter.second();
if (!v.isArray()) {
throw_bad_array_exception();
return uninit_null();
}
CArrRef arr_v = v.asCArrRef();
php_array_merge_recursive(seen, false, ret, arr_v);
assert(seen.empty());
}
return ret;
}
Variant f_array_combine(CVarRef keys, CVarRef values) {
getCheckedArray(keys);
getCheckedArray(values);
return ArrayUtil::Combine(arr_keys, arr_values);
}
Variant f_array_chunk(CVarRef input, int size,
bool preserve_keys /* = false */) {
getCheckedArray(input);
return ArrayUtil::Chunk(arr_input, size, preserve_keys);
}
Variant f_array_values(CVarRef input) {
getCheckedArray(input);
return arr_input.values();
}
Variant f_array_keys(CVarRef input, CVarRef search_value /* = null_variant */,
bool strict /* = false */) {
getCheckedArray(input);
return arr_input.keys(search_value, strict);
}
Variant f_array_reverse(CVarRef array, bool preserve_keys /* = false */) {
getCheckedArray(array);
return ArrayUtil::Reverse(arr_array, preserve_keys);
}
Variant f_array_count_values(CVarRef input) {
getCheckedArray(input);
return ArrayUtil::CountValues(arr_input);
}
Variant f_array_fill_keys(CVarRef keys, CVarRef value) {
getCheckedArray(keys);
return ArrayUtil::CreateArray(arr_keys, value);
}
Variant f_array_rand(CVarRef input, int num_req /* = 1 */) {
getCheckedArray(input);
return ArrayUtil::RandomKeys(arr_input, num_req);
}
