void AsioSession::setOnResumableSuccessCallback(const Variant& callback) {
m_onResumableSuccessCallback = checkCallback(
callback,
"ResumableWaitHandle::onSuccess"
);
updateEventHookState();
}
void AsioSession::setOnExternalThreadEventFailCallback(
const Variant& callback
) {
m_onExternalThreadEventFailCallback = checkCallback(
callback,
"ExternalThreadEventWaitHandle::onFail"
);
}
void AsioSession::setOnExternalThreadEventSuccess(
const Variant& callback
) {
m_onExtThreadEventSuccess = checkCallback(
callback,
"ExternalThreadEventWaitHandle::onSuccess"
);
}
void AsioSession::setOnExternalThreadEventCreate(
const Variant& callback
) {
m_onExtThreadEventCreate = checkCallback(
callback,
"ExternalThreadEventWaitHandle::onCreate"
);
}
/**
* @brief Callback called when the EXIP library has found the start of an element
* @param qname The qualified name of the element
* @param app_data Pointer to the struct appData passed to initParser()
* @return EXIP_HANDLER_OK if success, or EXIP_HANDLER_STOP if need to stop the parser
*/
static errorCode sample_startElement(QName qname, void* app_data) {
struct appData* appD = (struct appData*) app_data;
char error = 0;
unsigned char prefixIndex = 0;
unsigned char prxHit = 1;
int t = 0;
PRINT ("SE ");
writeQName(qname);
PRINT ("\n");
// Check if we where in another element. If yes, calls cb_startElement
checkCallback (appD, 0);
if(!isStringEmpty(qname.uri)) {
char uri[200];
char pfx[30];
error = lookupPrefix(appD, *qname.uri, &prxHit, &prefixIndex);
if (error) {
fprintf (stderr, "Prefix not found\n");
return EXIP_HANDLER_STOP;
}
copyString(*qname.uri, uri);
strcpy (pfx, getPrefixByNamespace(uri));
strcpy (appD->nameBuf, pfx);
strcat (appD->nameBuf, ":");
t = strlen(appD->nameBuf);
if(prxHit == 0) {
// Create xmlns: attribute
t_ctxt *ctxt = &appD->ctxt;
char tmp[30];
strcpy (tmp, "xmlns:");
strcat (tmp, pfx);
ctxt->atname[ctxt->atcount] = strdup(tmp);
ctxt->atvalue[ctxt->atcount] = StringStrdup(qname.uri);
ctxt->atcount++;
}
}
memcpy(appD->nameBuf + t, qname.localName->str, qname.localName->length);
appD->nameBuf[t + qname.localName->length] = '\0';
push(&(appD->stack), createElement(appD->nameBuf));
appD->unclosedElement = 1;
return ERR_OK;
}
/**
* @brief Callback called when the EXIP library has found the end of an element
* @param app_data Pointer to the struct appData passed to initParser()
* @return EXIP_HANDLER_OK if success, or EXIP_HANDLER_STOP if need to stop the parser
*/
static errorCode sample_endElement(void* app_data) {
struct appData* appD = (struct appData*) app_data;
struct element* el;
PRINT ("EE\n");
int save = appD->unclosedElement;
checkCallback (appD, 1);
// libxml2 compatibility : don't call cb_endElement when it is empty
if (!save)
cb_endElement (appD);
appD->depth --;
el = pop(&(appD->stack));
destroyElement(el);
_XoFreeAttributesWith (&appD->ctxt,free);
return ERR_OK;
}
static void putValue(struct appData* appD, char *avalue) {
t_ctxt *ctxt = &appD->ctxt;
//printf ("putValue %s\n", avalue);
// This is the attribute value
if(appD->expectAttributeData) {
char *aqname = appD->attribute;
//printf ("AT(#%d) %s=%s\n", ctxt->atcount, aqname, avalue);
ctxt->atname[ctxt->atcount] = aqname;
ctxt->atvalue[ctxt->atcount] = strdup(avalue);
ctxt->atcount++;
appD->expectAttributeData = 0;
appD->attribute = NULL;
}
else {
//printf ("CH %s\n", avalue);
checkCallback (appD, 0);
cb_text (appD, avalue);
}
}
void AsioSession::setOnSleepSuccessCallback(const Variant& callback) {
m_onSleepSuccessCallback = checkCallback(
callback,
"SleepWaitHandle::onSuccess"
);
}
void AsioSession::setOnSleepCreateCallback(const Variant& callback) {
m_onSleepCreateCallback = checkCallback(
callback,
"SleepWaitHandle::onCreate"
);
}
void AsioSession::setOnConditionCreateCallback(const Variant& callback) {
m_onConditionCreateCallback = checkCallback(
callback,
"ConditionWaitHandle::onCreate"
);
}
void AsioSession::setOnGenVectorCreateCallback(const Variant& callback) {
m_onGenVectorCreateCallback = checkCallback(
callback,
"GenVectorWaitHandle::onCreate"
);
}
void AsioSession::setOnAwaitAllCreateCallback(const Variant& callback) {
m_onAwaitAllCreateCallback = checkCallback(
callback,
"AwaitAllWaitHandle::onCreate"
);
}
void AsioSession::setOnJoinCallback(const Variant& callback) {
m_onJoinCallback = checkCallback(callback, "WaitHandle::onJoin");
}
void AsioSession::setOnIOWaitExitCallback(const Variant& callback) {
m_onIOWaitExitCallback = checkCallback(
callback,
"WaitHandle::onIOWaitExit"
);
}
static Bool checkCBSCallback(CBS cbs, Range range,
void *closureP, Size closureS)
{
UNUSED(cbs);
return checkCallback(range, closureP, closureS);
}
static Bool checkFLCallback(Bool *deleteReturn, Range range,
void *closureP, Size closureS)
{
*deleteReturn = FALSE;
return checkCallback(range, closureP, closureS);
}
void AsioSession::setOnResumableFailCallback(const Variant& callback) {
m_onResumableFailCallback = checkCallback(
callback,
"ResumableWaitHandle::onFail"
);
}
