ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::php_takeWhile(const Variant& fn) {
CallCtx ctx;
vm_decode_function(fn, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto map = req::make<TMap>();
if (!m_size) return Object{std::move(map)};
int32_t version UNUSED;
if (std::is_same<c_Map, TMap>::value) {
version = m_version;
}
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto* e = iter_elm(pos);
bool b = invokeAndCastToBool(ctx, 1, &e->data);
if (std::is_same<c_Map, TMap>::value) {
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
}
if (!b) break;
e = iter_elm(pos);
if (e->hasIntKey()) {
map->set(e->ikey, &e->data);
} else {
assert(e->hasStrKey());
map->set(e->skey, &e->data);
}
}
return Object{std::move(map)};
}
Object BaseMap::php_retain(const Variant& callback) {
CallCtx ctx;
vm_decode_function(callback, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto size = m_size;
if (!size) { return Object{this}; }
constexpr int64_t argc = useKey ? 2 : 1;
TypedValue argv[argc];
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto* e = iter_elm(pos);
if (useKey) {
if (e->hasIntKey()) {
argv[0].m_type = KindOfInt64;
argv[0].m_data.num = e->ikey;
} else {
argv[0].m_type = KindOfString;
argv[0].m_data.pstr = e->skey;
}
}
argv[argc-1] = e->data;
int32_t version = m_version;
bool b = invokeAndCastToBool(ctx, argc, argv);
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
if (b) {
continue;
}
mutateAndBump();
version = m_version;
e = iter_elm(pos);
ssize_t pp = (e->hasIntKey()
? findForRemove(e->ikey)
: findForRemove(e->skey, e->skey->hash()));
eraseNoCompact(pp);
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
}
assert(m_size <= size);
compactOrShrinkIfDensityTooLow();
return Object{this};
}
ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::php_filter(const Variant& callback) const {
VMRegGuard _;
CallCtx ctx;
vm_decode_function(callback, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto map = req::make<TMap>();
if (!m_size) return Object(std::move(map));
map->mutate();
int32_t version = m_version;
constexpr int64_t argc = useKey ? 2 : 1;
TypedValue argv[argc];
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto* e = iter_elm(pos);
if (useKey) {
if (e->hasIntKey()) {
argv[0].m_type = KindOfInt64;
argv[0].m_data.num = e->ikey;
} else {
argv[0].m_type = KindOfString;
argv[0].m_data.pstr = e->skey;
}
}
argv[argc-1] = e->data;
bool b = invokeAndCastToBool(ctx, argc, argv);
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
if (!b) continue;
e = iter_elm(pos);
if (e->hasIntKey()) {
map->set(e->ikey, &e->data);
} else {
assert(e->hasStrKey());
map->set(e->skey, &e->data);
}
}
return Object(std::move(map));
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_skipWhile(const Variant& fn) {
CallCtx ctx;
vm_decode_function(fn, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto set = req::make<TSet>();
if (!m_size) return Object(std::move(set));
// we don't reserve(), because we don't know how selective fn will be
set->mutate();
int32_t version UNUSED;
if (std::is_same<c_Set, TSet>::value) {
version = m_version;
}
uint32_t used = posLimit();
uint32_t i = 0;
for (; i < used; ++i) {
if (isTombstone(i)) continue;
Elm& e = data()[i];
bool b = invokeAndCastToBool(ctx, 1, &e.data);
if (std::is_same<c_Set, TSet>::value) {
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
}
if (!b) break;
}
for (; i < used; ++i) {
if (isTombstone(i)) continue;
Elm& e = data()[i];
if (e.hasIntKey()) {
set->addRaw(e.data.m_data.num);
} else {
assert(e.hasStrKey());
set->addRaw(e.data.m_data.pstr);
}
}
return Object(std::move(set));
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_filter(const Variant& callback) const {
VMRegGuard _;
CallCtx ctx;
vm_decode_function(callback, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto set = req::make<TSet>();
if (!m_size) return Object(std::move(set));
// we don't reserve(), because we don't know how selective callback will be
set->mutate();
int32_t version = m_version;
constexpr int64_t argc = useKey ? 2 : 1;
TypedValue argv[argc];
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto e = iter_elm(pos);
if (useKey) {
argv[0] = e->data;
}
argv[argc-1] = e->data;
bool b = invokeAndCastToBool(ctx, argc, argv);
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
if (!b) continue;
e = iter_elm(pos);
if (e->hasIntKey()) {
set->addRaw(e->data.m_data.num);
} else {
assert(e->hasStrKey());
set->addRaw(e->data.m_data.pstr);
}
}
return Object(std::move(set));
}