void c_SetResultToRefWaitHandle::ti_setoncreatecallback(CVarRef callback) {
if (!callback.isNull() && !callback.instanceof(c_Closure::classof())) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Unable to set SetResultToRefWaitHandle::onCreate: on_create_cb not a closure"));
throw e;
}
AsioSession::Get()->setOnSetResultToRefCreateCallback(callback.getObjectDataOrNull());
}
void f_asio_set_on_failed_callback(CVarRef on_failed_cb) {
if (!on_failed_cb.isNull() && !on_failed_cb.instanceof(c_Closure::s_cls)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Unable to set asio on failed callback: on_failed_cb not a closure"));
throw e;
}
AsioSession::Get()->setOnFailedCallback(on_failed_cb.getObjectDataOrNull());
}
void c_ContinuationWaitHandle::ti_setonfailcallback(CVarRef callback) {
if (!callback.isNull() && !callback.instanceof(c_Closure::s_cls)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Unable to set ContinuationWaitHandle::onFail: on_fail_cb not a closure"));
throw e;
}
AsioSession::Get()->setOnContinuationFailCallback(callback.getObjectDataOrNull());
}
void c_AsyncFunctionWaitHandle::ti_setonsuccesscallback(CVarRef callback) {
if (!callback.isNull() && !callback.instanceof(c_Closure::classof())) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Unable to set AsyncFunctionWaitHandle::onSuccess: on_success_cb not a closure"));
throw e;
}
AsioSession::Get()->setOnAsyncFunctionSuccessCallback(callback.getObjectDataOrNull());
}
void c_WaitHandle::ti_setonjoincallback(CVarRef callback) {
if (!callback.isNull() && !callback.instanceof(c_Closure::classof())) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Unable to set WaitHandle::onJoin: on_join_cb not a closure"));
throw e;
}
AsioSession::Get()->setOnJoinCallback(callback.getObjectDataOrNull());
}
Object c_GenMapWaitHandle::ti_create(CVarRef dependencies) {
if (UNLIKELY(!dependencies.instanceof(c_Map::classof()))) {
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)) {
Cell* 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)) {
Cell* 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()) {
cellSet(child->getResult(), *current);
} 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 c_StaticResultWaitHandle::Create(make_tv<KindOfObject>(deps.get()));
} else {
return c_StaticExceptionWaitHandle::Create(exception.get());
}
}
Variant f_iterator_count(CVarRef obj) {
if (!obj.instanceof("Traversable")) {
return false;
}
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
int64 count = 0;
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
++count;
pobj->o_invoke("next", null_array, -1);
}
return count;
}
Object c_GenVectorWaitHandle::ti_create(CVarRef dependencies) {
if (UNLIKELY(!dependencies.instanceof(c_Vector::s_cls))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Vector"));
throw e;
}
assert(dynamic_cast<c_Vector*>(dependencies.getObjectData()));
p_Vector deps = static_cast<c_Vector*>(dependencies.getObjectData())->clone();
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
Cell* current = deps->at(iter_pos);
if (UNLIKELY(!c_WaitHandle::fromCell(current))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be a vector of WaitHandle instances"));
throw e;
}
}
Object exception;
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
Cell* current = tvAssertCell(deps->at(iter_pos));
assert(current->m_type == KindOfObject);
assert(dynamic_cast<c_WaitHandle*>(current->m_data.pobj));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
cellSet(child->getResult(), *current);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(dynamic_cast<c_WaitableWaitHandle*>(child));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
p_GenVectorWaitHandle my_wh = NEWOBJ(c_GenVectorWaitHandle)();
my_wh->initialize(exception, deps.get(), iter_pos, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenVectorCreateCallback())) {
session->onGenVectorCreate(my_wh.get(), dependencies);
}
return my_wh;
}
}
if (exception.isNull()) {
return c_StaticResultWaitHandle::Create(make_tv<KindOfObject>(deps.get()));
} else {
return c_StaticExceptionWaitHandle::Create(exception.get());
}
}
Object get_traversable_object_iterator(CVarRef obj) {
if (!obj.instanceof(SystemLib::s_TraversableClass)) {
raise_error("Argument must implement interface Traversable");
}
bool isIteratorAggregate;
Object itObj = obj.getObjectData()
->iterableObject(isIteratorAggregate, true);
if (!isIteratorAggregate) {
if (obj.instanceof(SystemLib::s_IteratorAggregateClass)) {
raise_error("Objects returned by getIterator() must be traversable or "
"implement interface Iterator");
} else {
raise_error(
"Class %s must implement interface Traversable as part of either "
"Iterator or IteratorAggregate",
obj.toObject()->o_getClassName()->data()
);
}
}
return itObj;
}
Variant f_iterator_apply(CVarRef obj, CVarRef func,
CArrRef params /* = null_array */) {
if (!obj.instanceof("Traversable")) {
return false;
}
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
int64 count = 0;
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
if (!same(f_call_user_func_array(func, params), true)) {
break;
}
++count;
pobj->o_invoke("next", null_array, -1);
}
return count;
}
Variant f_iterator_to_array(CVarRef obj, bool use_keys /* = true */) {
if (!obj.instanceof("Traversable")) {
return false;
}
Array ret(Array::Create());
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
Variant val = pobj->o_invoke("current", null_array, -1);
if (use_keys) {
Variant key = pobj->o_invoke("key", null_array, -1);
ret.set(key, val);
} else {
ret.append(val);
}
pobj->o_invoke("next", null_array, -1);
}
return ret;
}