void QAppointmentIO::notifyUpdated(const QUniqueId &id)
{
{
QtopiaIpcEnvelope e("QPE/PIM", "updatedAppointment(int,QUuid,QUniqueId)");
e << getpid();
e << contextId();
e << id;
}
foreach(QAppointmentIO *c, activeAppointments) {
if (c != this && c->contextId() == contextId())
c->checkUpdated(id);
}
}
void QAppointmentIO::notifyRemoved(const QList<QUniqueId> &ids)
{
{
QtopiaIpcEnvelope e("QPE/PIM", "removedAppointments(int,QUuid,QList<QUniqueId>)");
e << getpid();
e << contextId();
e << ids;
}
foreach(QAppointmentIO *c, activeAppointments) {
if (c != this && c->contextId() == contextId())
c->checkRemoved(ids);
}
}
// ---------------------------------------------------------------------------
// CMccCryptoContextContainer::CreateContext
// ---------------------------------------------------------------------------
//
TInt CMccCryptoContextContainer::CreateContext( const TMccSrtpMasterKey& aMasterKey,
const TMccSrtpMasterSalt& aSaltKey,
TUint32& aContextId,
const TMccSrtpCryptoParams& aCryptoParams )
{
__INTERFACE( "CMccCryptoContextContainer::CreateContext" )
TUint32 contextId( GenerateContextId() );
TMccCryptoContext cryptoContext( contextId,
aMasterKey,
aSaltKey,
aCryptoParams );
TInt error( cryptoContext.ValidateContext() );
if ( KErrNone == error )
{
error = iContextArray.Append( cryptoContext );
aContextId = contextId;
}
return error;
}
int UserAttr::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_attrs, ptr); ptr += 2;
return ptr-data;
}
int AnnotationDelete::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
return ptr-data;
}
int LayerDelete::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
*(ptr++) = _merge;
return ptr - data;
}
int UserJoin::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
memcpy(ptr, _name.constData(), _name.length());
ptr += _name.length();
return ptr - data;
}
int Undo::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _override;
*(ptr++) = _points;
return ptr-data;
}
int SessionTitle::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
memcpy(ptr, _title.constData(), _title.length());
ptr += _title.length();
return ptr - data;
}
int Marker::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
memcpy(ptr, _text.constData(), _text.length());
ptr += _text.length();
return ptr - data;
}
int PenMove::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
foreach(const PenPoint &p, _points) {
qToBigEndian(p.x, ptr); ptr += 4;
qToBigEndian(p.y, ptr); ptr += 4;
qToBigEndian(p.p, ptr); ptr += 2;
}
int LayerOrder::serializePayload(uchar *data) const
{
Q_ASSERT(_order.length()<256);
uchar *ptr = data;
*(ptr++) = contextId();
foreach(uint8_t l, _order)
*(ptr++) = l;
return ptr - data;
}
int LayerAttributes::serializePayload(uchar *data) const
{
uchar *ptr=data;
*(ptr++) = contextId();
*(ptr++) = _id;
*(ptr++) = _opacity;
*(ptr++) = _blend;
return ptr-data;
}
int Chat::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = flags();
memcpy(ptr, _msg.constData(), _msg.length());
ptr += _msg.length();
return ptr - data;
}
int LayerCreate::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
qToBigEndian(_fill, ptr); ptr += 4;
memcpy(ptr, _title.constData(), _title.length());
ptr += _title.length();
return ptr - data;
}
int CanvasResize::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_top, ptr); ptr += 2;
qToBigEndian(_right, ptr); ptr += 2;
qToBigEndian(_bottom, ptr); ptr += 2;
qToBigEndian(_left, ptr); ptr += 2;
return ptr - data;
}
int LayerACL::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
*(ptr++) = _locked;
foreach(uint8_t e, _exclusive)
*(ptr++) = e;
return ptr-data;
}
int MovePointer::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_x, ptr); ptr += 4;
qToBigEndian(_y, ptr); ptr += 4;
*(ptr++) = _persistence;
return ptr-data;
}
int AnnotationEdit::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
qToBigEndian(_bg, ptr); ptr += 4;
memcpy(ptr, _text.constData(), _text.length());
ptr += _text.length();
return ptr - data;
}
int AnnotationReshape::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
qToBigEndian(_x, ptr); ptr += 4;
qToBigEndian(_y, ptr); ptr += 4;
qToBigEndian(_w, ptr); ptr += 2;
qToBigEndian(_h, ptr); ptr += 2;
return ptr - data;
}
// -----------------------------------------------------------------------------
// CSIPPrflStateBase::HandleError()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSIPPrflStateBase::HandleError(
MSIPProfileContext& aContext,
TInt aError,
CSIPPrflStateBase* aNextState)
{
__ASSERT_DEBUG(aContext.Profile()!=0, User::Invariant());
TUint32 contextId(0);
CSIPConcreteProfile& profile = DoCleanup(aContext,contextId);
aContext.SetNextState(*aNextState);
aContext.AgentObserver().SIPProfileErrorEvent(profile,aError);
}
void QTaskIO::pimMessage(const QString &message, const QByteArray &data)
{
QDataStream ds(data);
if (message == "addedTask(int,QUuid,QUniqueId)") {
int pid;
QUuid u;
ds >> pid;
ds >> u;
if (pid != getpid() && u == contextId()) {
QUniqueId task;
ds >> task;
checkAdded(task);
}
void QAppointmentIO::pimMessage(const QString &message, const QByteArray &data)
{
QDataStream ds(data);
if (message == "addedAppointment(int,QUuid,QUniqueId)") {
int pid;
QUuid u;
ds >> pid;
ds >> u;
if (pid != getpid() && u == contextId()) {
QUniqueId appointment;
ds >> appointment;
checkAdded(appointment);
}
/*!
Creates an OpenCL memory buffer from the OpenGL buffer object
\a bufobj, with the specified \a access mode.
This function will only work if supportsObjectSharing() is true.
*/
QCLBuffer QCLContextGL::createGLBuffer(GLuint bufobj, QCLMemoryObject::Access access)
{
#ifndef QT_NO_CL_OPENGL
cl_int error = CL_INVALID_CONTEXT;
cl_mem_flags flags = cl_mem_flags(access);
cl_mem mem = clCreateFromGLBuffer
(contextId(), flags, bufobj, &error);
reportError("QCLContextGL::createGLBuffer:", error);
if (mem)
return QCLBuffer(this, mem);
else
return QCLBuffer();
#else
Q_UNUSED(bufobj);
Q_UNUSED(access);
reportError("QCLContextGL::createGLBuffer:", CL_INVALID_VALUE);
return QCLBuffer();
#endif
}
/*!
Creates a 3D OpenCL image object from the specified \a mipmapLevel,
OpenGL \a texture object, and \a access mode.
The \a type must be \c{GL_TEXTURE_3D}. The \a texture does not need
to be bound to an OpenGL texture target.
This function will only work if supportsObjectSharing() is true.
\sa createTexture2D()
*/
QCLImage3D QCLContextGL::createTexture3D
(GLenum type, GLuint texture, GLint mipmapLevel, QCLMemoryObject::Access access)
{
#ifndef QT_NO_CL_OPENGL
cl_int error = CL_INVALID_CONTEXT;
cl_mem_flags flags = cl_mem_flags(access);
cl_mem mem = clCreateFromGLTexture3D
(contextId(), flags, type, mipmapLevel, texture, &error);
reportError("QCLContextGL::createGLTexture3D:", error);
if (mem)
return QCLImage3D(this, mem);
else
return QCLImage3D();
#else
Q_UNUSED(type);
Q_UNUSED(texture);
Q_UNUSED(mipmapLevel);
Q_UNUSED(access);
reportError("QCLContextGL::createGLTexture3D:", CL_INVALID_VALUE);
return QCLImage3D();
#endif
}
int UndoPoint::serializePayload(uchar *data) const
{
*data = contextId();
return 1;
}
int UserLeave::serializePayload(uchar *data) const
{
*data = contextId();
return 1;
}
RcppExport SEXP xbrlProcessContexts(SEXP epaDoc) {
xmlDocPtr doc = (xmlDocPtr) R_ExternalPtrAddr(epaDoc);
xmlXPathContextPtr context = xmlXPathNewContext(doc);
xmlXPathObjectPtr context_res = xmlXPathEvalExpression((xmlChar*) "//*[local-name()='context']", context);
xmlNodeSetPtr context_nodeset = context_res->nodesetval;
int context_nodeset_ln = context_nodeset->nodeNr;
xmlXPathFreeContext(context);
CharacterVector contextId(context_nodeset_ln);
CharacterVector scheme(context_nodeset_ln);
CharacterVector identifier(context_nodeset_ln);
CharacterVector startDate(context_nodeset_ln);
CharacterVector endDate(context_nodeset_ln);
CharacterVector dimension1(context_nodeset_ln);
CharacterVector value1(context_nodeset_ln);
CharacterVector dimension2(context_nodeset_ln);
CharacterVector value2(context_nodeset_ln);
CharacterVector dimension3(context_nodeset_ln);
CharacterVector value3(context_nodeset_ln);
CharacterVector dimension4(context_nodeset_ln);
CharacterVector value4(context_nodeset_ln);
for (int i=0; i < context_nodeset_ln; i++) {
xmlNodePtr context_node = context_nodeset->nodeTab[i];
xmlChar *tmp_str;
if ((tmp_str = xmlGetProp(context_node, (xmlChar*) "id"))) {
contextId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
contextId[i] = NA_STRING;
}
scheme[i] = identifier[i] = startDate[i] = endDate[i] =
dimension1[i] = value1[i] = dimension2[i] = value2[i] =
dimension3[i] = value3[i] = dimension4[i] = value4[i] = NA_STRING;
xmlNodePtr child_node = context_node->xmlChildrenNode;
while (child_node) {
if (!xmlStrcmp(child_node->name, (xmlChar*) "entity")) {
xmlNodePtr gchild_node = child_node->xmlChildrenNode;
while (gchild_node) {
if (!xmlStrcmp(gchild_node->name, (xmlChar*) "identifier")) {
if ((tmp_str = xmlGetProp(gchild_node, (xmlChar*) "scheme"))) {
scheme[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
identifier[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "segment")) {
xmlNodePtr ggchild_node = gchild_node->xmlChildrenNode;
int dimn = 1;
while (ggchild_node) {
if (!xmlStrcmp(ggchild_node->name, (xmlChar*) "explicitMember")) {
if ((tmp_str = xmlGetProp(ggchild_node, (xmlChar*) "dimension"))) {
if (dimn == 1)
dimension1[i] = (char *) tmp_str;
else if (dimn == 2)
dimension2[i] = (char *) tmp_str;
else if (dimn == 3)
dimension3[i] = (char *) tmp_str;
else if (dimn == 4)
dimension4[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
if ((tmp_str = xmlNodeListGetString(doc, ggchild_node->xmlChildrenNode, 1))) {
if (dimn == 1)
value1[i] = (char *) tmp_str;
else if (dimn == 2)
value2[i] = (char *) tmp_str;
else if (dimn == 3)
value3[i] = (char *) tmp_str;
else if (dimn == 4)
value4[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
dimn++;
}
ggchild_node = ggchild_node->next;
}
}
gchild_node = gchild_node->next;
}
} else if (!xmlStrcmp(child_node->name, (xmlChar*) "period")) {
xmlNodePtr gchild_node = child_node->xmlChildrenNode;
while (gchild_node) {
if (!xmlStrcmp(gchild_node->name, (xmlChar*) "startDate")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
startDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "endDate")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
endDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "instant")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
endDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
}
gchild_node = gchild_node->next;
}
}
child_node = child_node->next;
}
}
xmlXPathFreeObject(context_res);
return DataFrame::create(Named("contextId")=contextId,
Named("scheme")=scheme,
Named("identifier")=identifier,
Named("startDate")=startDate,
Named("endDate")=endDate,
Named("dimension1")=dimension1,
Named("value1")=value1,
Named("dimension2")=dimension2,
Named("value2")=value2,
Named("dimension3")=dimension3,
Named("value3")=value3,
Named("dimension4")=dimension4,
Named("value4")=value4);
}
RcppExport SEXP xbrlProcessFacts(SEXP epaDoc) {
xmlDocPtr doc = (xmlDocPtr) R_ExternalPtrAddr(epaDoc);
xmlXPathContextPtr context = xmlXPathNewContext(doc);
xmlXPathObjectPtr fact_res = xmlXPathEvalExpression((xmlChar*) "//*[@*[local-name()='contextRef']]", context);
xmlNodeSetPtr fact_nodeset = fact_res->nodesetval;
xmlXPathFreeContext(context);
int fact_nodeset_ln = fact_nodeset->nodeNr;
CharacterVector elementId(fact_nodeset_ln);
CharacterVector contextId(fact_nodeset_ln);
CharacterVector unitId(fact_nodeset_ln);
CharacterVector fact(fact_nodeset_ln);
CharacterVector decimals(fact_nodeset_ln);
CharacterVector sign(fact_nodeset_ln);
CharacterVector scale(fact_nodeset_ln);
CharacterVector tupleRef(fact_nodeset_ln);
CharacterVector order(fact_nodeset_ln);
CharacterVector factId(fact_nodeset_ln);
CharacterVector ns(fact_nodeset_ln);
for (int i=0; i < fact_nodeset_ln; i++) {
xmlNodePtr fact_node = fact_nodeset->nodeTab[i];
if (fact_node->ns->prefix)
elementId[i] = (char *) ((string) (char *) fact_node->ns->prefix + "_" + (string) (char *) fact_node->name).data();
else
elementId[i] = (char *) fact_node->name;
xmlChar *tmp_str;
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "contextRef"))) {
contextId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
contextId[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "unitRef"))) {
unitId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
unitId[i] = NA_STRING;
}
if ((tmp_str = xmlNodeListGetString(doc, fact_node->xmlChildrenNode, 1))) {
fact[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
fact[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "decimals"))) {
decimals[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
decimals[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "scale"))) {
scale[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
scale[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "sign"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "tupleRef"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "order"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "id"))) {
factId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "name"))) {
factId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
factId[i] = NA_STRING;
}
ns[i] = (char *) fact_node->ns->href;
}
xmlXPathFreeObject(fact_res);
return DataFrame::create(Named("elementId")=elementId,
Named("contextId")=contextId,
Named("unitId")=unitId,
Named("fact")=fact,
Named("factId")=factId,
Named("decimals")=decimals,
Named("scale")=scale,
Named("sign")=sign,
Named("tupleRef")=tupleRef,
Named("order")=order,
Named("ns")=ns);
}
