Object c_GenMapWaitHandle::ti_create(const Variant& dependencies) {
if (UNLIKELY(!dependencies.isObject() ||
dependencies.getObjectData()->getCollectionType() !=
Collection::MapType)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Map"));
throw e;
}
assert(dependencies.getObjectData()->instanceof(c_Map::classof()));
auto deps = p_Map::attach(c_Map::Clone(dependencies.getObjectData()));
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
if (UNLIKELY(!c_WaitHandle::fromCell(current))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be a map of WaitHandle instances"));
throw e;
}
}
Object exception;
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto k = deps->iter_key(iter_pos);
deps->set(k.asCell(), &child->getResult());
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
p_GenMapWaitHandle my_wh = NEWOBJ(c_GenMapWaitHandle)();
my_wh->initialize(exception, deps.get(), iter_pos, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenMapCreateCallback())) {
session->onGenMapCreate(my_wh.get(), dependencies);
}
return my_wh;
}
}
if (exception.isNull()) {
return Object::attach(c_StaticWaitHandle::CreateSucceeded(
make_tv<KindOfObject>(deps.detach())));
} else {
return Object::attach(c_StaticWaitHandle::CreateFailed(exception.detach()));
}
}
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_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));
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_map(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)};
assert(posLimit() != 0);
assert(hashSize() > 0);
assert(set->arrayData() == staticEmptyMixedArray());
auto oldCap = set->cap();
set->reserve(posLimit()); // presume minimum collisions ...
assert(set->canMutateBuffer());
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);
TypedValue tvCbRet;
int32_t pVer = m_version;
if (useKey) {
argv[0] = e->data;
}
argv[argc-1] = e->data;
g_context->invokeFuncFew(&tvCbRet, ctx, argc, argv);
// Now that tvCbRet is live, make sure to decref even if we throw.
SCOPE_EXIT { tvRefcountedDecRef(&tvCbRet); };
if (UNLIKELY(m_version != pVer)) throw_collection_modified();
set->addRaw(&tvCbRet);
}
// ... and shrink back if that was incorrect
set->shrinkIfCapacityTooHigh(oldCap);
return Object{std::move(set)};
}
Object c_GenMapWaitHandle::ti_create(const Variant& dependencies) {
ObjectData* obj;
if (UNLIKELY(!dependencies.isObject() ||
!(obj = dependencies.getObjectData())->isCollection() ||
obj->collectionType() != CollectionType::Map)) {
SystemLib::throwInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Map");
}
assertx(obj->collectionType() == CollectionType::Map);
auto deps = req::ptr<c_Map>::attach(c_Map::Clone(obj));
auto ctx_idx = std::numeric_limits<context_idx_t>::max();
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
auto const child = c_WaitHandle::fromCell(current);
if (UNLIKELY(!child)) {
SystemLib::throwInvalidArgumentExceptionObject(
"Expected dependencies to be a map of WaitHandle instances");
}
if (!child->isFinished()) {
ctx_idx = std::min(
ctx_idx,
static_cast<c_WaitableWaitHandle*>(child)->getContextIdx()
);
}
}
Object exception;
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto k = deps->iter_key(iter_pos);
auto result = child->getResult();
deps->set(k.asCell(), &result);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
auto my_wh = req::make<c_GenMapWaitHandle>();
my_wh->initialize(exception, deps.get(), iter_pos, ctx_idx, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenMapCreate())) {
session->onGenMapCreate(my_wh.get(), dependencies);
}
return Object(std::move(my_wh));
}
}
if (exception.isNull()) {
return Object::attach(c_StaticWaitHandle::CreateSucceeded(
make_tv<KindOfObject>(deps.detach())));
} else {
return Object::attach(c_StaticWaitHandle::CreateFailed(exception.detach()));
}
}
