void cmx_writerSnapshotNewAction( v_entity e, c_voidp args) { v_writer writer; struct cmx_writerSnapshotArg* arg; arg = (struct cmx_writerSnapshotArg*)args; switch(v_object(e)->kind){ case K_WRITER: arg->success = TRUE; arg->snapshot = cmx_writerSnapshot(os_malloc(C_SIZEOF(cmx_writerSnapshot))); arg->snapshot->samples = NULL; writer = v_writer(e); v_writerRead(writer, cmx_writerHistoryCopy, args); if(arg->serializer != NULL){ sd_serializerFree(arg->serializer); } break; default: break; } }
void cmx_writerDataTypeAction( v_entity entity, c_voidp args) { sd_serializer ser; sd_serializedData data; c_type type; struct cmx_writerTypeArg *arg; arg = (struct cmx_writerTypeArg *)args; type = NULL; switch(v_object(entity)->kind){ case K_WRITER: type = v_topicDataType(v_writer(entity)->topic); break; default: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Trying to resolve dataType of writer that is not a writer.\n"); assert(FALSE); break; } if(type != NULL){ ser = sd_serializerXMLMetadataNew(c_getBase(type)); data = sd_serializerSerialize(ser, type); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); } }
v_actionResult cmx_readerReadCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; v_dataReaderSample sample, newer; struct cmx_readerArg *arg; v_actionResult result; result = 0; if(o != NULL){ sample = v_dataReaderSample(o); if(v_stateTest(v_readerSampleState(sample), L_READ)){ v_actionResultSet(result, V_PROCEED); } else { sample = v_dataReaderSample(o); newer = sample->newer; sample->newer = NULL; arg = (struct cmx_readerArg *)args; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->newer = newer; } } return result; }
const c_char* cmx_participantRegisterType( const c_char* participant, const c_char* type) { sd_serializer serializer; sd_serializedData meta_data; cmx_entityKernelArg kernelArg; c_type topicType; cmx_entity ce; const c_char* result; const c_char* msg; ce = cmx_entityClaim(participant); if(ce != NULL){ kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg))); if (u_observableAction(u_observable(ce->uentity), cmx_entityKernelAction, (c_voidp)kernelArg) == U_RESULT_OK) { serializer = sd_serializerXMLMetadataNew(c_getBase(c_object(kernelArg->kernel))); if(serializer != NULL){ meta_data = sd_serializerFromString(serializer, type); if (meta_data != NULL) { topicType = c_type(sd_serializerDeserialize(serializer, meta_data)); if (topicType == NULL) { msg = sd_serializerLastValidationMessage(serializer); OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Data type could not be registered, " "because it is not valid: %s", msg); result = CMX_RESULT_FAILED; } else { result = CMX_RESULT_OK; } sd_serializedDataFree(meta_data); } else { OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Construction of serialized data failed."); result = CMX_RESULT_FAILED; } sd_serializerFree(serializer); } else { OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Serializer could not be initialized"); result = CMX_RESULT_FAILED; } } else { OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Kernel object could not be retrieved"); result = CMX_RESULT_FAILED; } os_free(kernelArg); cmx_entityRelease(ce); } else { result = CMX_RESULT_FAILED; } return result; }
v_actionResult cmx_readerCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; struct cmx_readerArg *arg; v_dataReaderSample sample, older; v_actionResult result = 0; v_lifespanSample next; arg = (struct cmx_readerArg *)args; if(o != NULL){ sample = v_dataReaderSample(o); older = sample->older; next = sample->_parent._parent.next; sample->older = NULL; sample->_parent._parent.next = NULL; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->older = older; sample->_parent._parent.next = next; } return result; }
char * idl_genXMLmeta ( c_type type) { sd_serializer metaSer; sd_serializedData serData; char *metaDescription = NULL; c_iter replaceInfo; c_iter replaceInfoStac; replaceInfo = idl_catsDefConvertAll(idl_catsDefDefGet()); replaceInfoStac = idl_stacDefConvertAll(idl_stacDefDefGet()); metaSer = sd_serializerXMLTypeinfoNew (c_getBase(c_object(type)), TRUE); if (metaSer) { serData = sd_serializerSerialize (metaSer, c_object(type)); if (serData) { metaDescription = sd_serializerToString (metaSer, serData); } sd_serializerFree (metaSer); } idl_catsDefRestoreAll(idl_catsDefDefGet(), replaceInfo); idl_stacDefRestoreAll(idl_stacDefDefGet(), replaceInfoStac); return metaDescription; }
c_bool cmx_readerReadCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; v_dataReaderSample sample, prev; struct cmx_readerArg *arg; c_bool result; result = FALSE; if(o != NULL){ sample = v_dataReaderSample(o); if(v_stateTest(v_readerSampleState(sample), L_READ)){ result = TRUE; } else { sample = v_dataReaderSample(o); prev = sample->prev; sample->prev = NULL; arg = (struct cmx_readerArg *)args; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->prev = prev; } } return result; }
c_bool cmx_readerCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; struct cmx_readerArg *arg; v_dataReaderSample sample, prev; arg = (struct cmx_readerArg *)args; if(o != NULL){ sample = v_dataReaderSample(o); prev = sample->prev; sample->prev = NULL; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->prev = prev; } return FALSE; }
static c_type cloneType( c_base src, c_base dst, c_type object) { sd_serializer serializer, deserializer; sd_serializedData data; c_char* xmlData; c_type result; result = NULL; serializer = sd_serializerXMLTypeinfoNew(src, FALSE); deserializer = sd_serializerXMLTypeinfoNew(dst, FALSE); if(serializer && deserializer){ data = sd_serializerSerialize(serializer, object); if(data){ xmlData = sd_serializerToString(serializer, data); sd_serializedDataFree(data); if(xmlData){ data = sd_serializerFromString(deserializer, xmlData); if(data){ result = c_type(sd_serializerDeserializeValidated( deserializer, data)); sd_serializedDataFree(data); } os_free(xmlData); } } sd_serializerFree(serializer); sd_serializerFree(deserializer); } return result; }
jni_result jni_writerFree( jni_writer wri) { jni_result r; if(wri != NULL){ r = jni_convertResult(u_writerFree(wri->uwriter)); sd_serializerFree(wri->deserializer); os_free(wri); } else{ r = JNI_RESULT_BAD_PARAMETER; } return r; }
void cmx_writerUnregisterCopy( v_entity entity, c_voidp args) { v_writer kw; v_message message; void *to; sd_serializer ser; sd_serializedData data; sd_validationResult valResult; struct cmx_writerArg *arg; arg = (struct cmx_writerArg *)args; kw = v_writer(entity); message = v_topicMessageNew(kw->topic); to = C_DISPLACE(message,v_topicDataOffset(kw->topic)); ser = sd_serializerXMLNewTyped(v_topicDataType(kw->topic)); data = sd_serializerFromString(ser, arg->result); sd_serializerDeserializeIntoValidated(ser, data, to); valResult = sd_serializerLastValidationResult(ser); if(valResult != SD_VAL_SUCCESS){ OS_REPORT_2(OS_ERROR, CM_XML_CONTEXT, 0, "Unregister of userdata failed.\nReason: %s\nError: %s\n", sd_serializerLastValidationMessage(ser), sd_serializerLastValidationLocation(ser)); arg->success = CMX_RESULT_FAILED; } else { arg->success = CMX_RESULT_OK; } sd_serializedDataFree(data); sd_serializerFree(ser); /* Note that the last param of v_writerWriteDispose is NULL, performance can be improved if the instance is provided. */ v_writerUnregister(kw,message,v_timeGet(),NULL); c_free(message); }
jni_writer jni_writerNew( jni_publisher pub, jni_topic top, v_writerQos qos) { jni_writer wri; u_result ur; struct jni_writerTypeArg arg; if((pub == NULL) || (top == NULL)){ OS_REPORT_2(OS_ERROR, "jni_writerNew", 0, "Bad parameter; jni_publisher (%p) and jni_topic (%p) may not be NULL.", pub, top); goto err_badParam; } assert(pub->upublisher); assert(top->utopic); if((ur = u_entityAction(u_entity(top->utopic), jni_writerTypeAction, &arg)) != U_RESULT_OK){ OS_REPORT_1(OS_ERROR, "jni_writerNew", ur, "Failed to invoke jni_writerTypeAction(...) on top->utopic; u_entityAction(...) returned %s.", u_resultImage(ur)); goto err_getWriterType; } if(arg.type == NULL){ /* Error reported by jni_writerTypeAction */ goto err_getWriterType; } if((wri = os_malloc(sizeof *wri)) == NULL){ OS_REPORT_1(OS_ERROR, "jni_writerNew", 0, "Memory claim of %" PA_PRIuSIZE " denied.", sizeof *wri); goto err_malloc; } if((wri->deserializer = sd_serializerXMLNewTyped(arg.type)) == NULL){ /* Error reported by sd_serializerXMLNewTyped */ goto err_sd_serializerXMLNewTyped; } if((wri->uwriter = u_writerNew(pub->upublisher, NULL, top->utopic, jni_writerCopy, qos, TRUE)) == NULL){ /* Error reported by u_writerNew */ goto err_uwriterNew; } wri->publisher = pub; wri->topic = top; return wri; /* Error handling */ err_uwriterNew: sd_serializerFree(wri->deserializer); err_sd_serializerXMLNewTyped: os_free(wri); err_malloc: /* No undo for jni_writerTypeAction */ err_getWriterType: err_badParam: return NULL; }
void cmx_readerSnapshotNewAction( v_entity e, c_voidp args) { v_dataReader reader; c_iter instances; v_dataReaderInstance instance; v_dataReaderSample sample, prev; v_query query; c_bool release; sd_serializer ser; sd_serializedData data; struct cmx_readerSnapshotArg* arg; release = FALSE; arg = (struct cmx_readerSnapshotArg*)args; reader = NULL; instances = NULL; ser = NULL; switch(v_object(e)->kind){ case K_DATAREADER: reader = v_dataReader(e); arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); if(reader->index->objects){ instances = c_select(reader->index->notEmptyList, 0); } break; case K_QUERY: case K_DATAREADERQUERY: query = v_query(e); reader = v_dataReader(v_querySource(query)); if(reader != NULL){ release = TRUE; arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); switch(v_object(query)->kind){ case K_DATAREADERQUERY: if(v_dataReaderQuery(query)->instanceQ){ instances = c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0); } break; default: OS_REPORT_1(OS_ERROR, CM_XML_CONTEXT, 0, "cmx_readerSnapshotNewAction unknown kind (%d).", v_object(query)->kind); break; } } break; default: break; } if(arg->success == TRUE){ arg->snapshot->samples = c_iterNew(NULL); } if(instances != NULL){ instance = v_dataReaderInstance(c_iterTakeFirst(instances)); while(instance != NULL){ sample = c_keep(v_dataReaderInstanceHead(instance)); if(sample != NULL){ prev = sample->prev; sample->prev = NULL; if(ser == NULL){ ser = sd_serializerXMLNewTyped(c_getType(c_object(sample))); } data = sd_serializerSerialize(ser, c_object(sample)); arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data)); sd_serializedDataFree(data); sample->prev = prev; c_free(sample); } c_free(instance); instance = v_dataReaderInstance(c_iterTakeFirst(instances)); } c_iterFree(instances); } if(reader != NULL){ v_observerUnlock(v_observer(reader)); if(release == TRUE){ c_free(reader); } } if(ser != NULL){ sd_serializerFree(ser); } }
void idl_registerType ( c_base base, const char *basename, c_iter typeNames ) { sd_serializer metaSer; sd_serializedData serData; char *metaDescription = NULL; char *typeName; c_char *fname; c_metaObject type; int i; fname = os_malloc((size_t)((int)strlen(basename)+20)); snprintf (fname, (size_t)((int)strlen(basename)+20), "%s_register.h", basename); idl_fileSetCur (idl_fileOutNew (fname, "w")); if (idl_fileCur () == NULL) { idl_reportOpenError (fname); } idl_registerHeaderFile (basename); idl_fileOutFree (idl_fileCur()); snprintf (fname, (size_t)((int)strlen(basename)+20), "%s_register.c", basename); idl_fileSetCur (idl_fileOutNew (fname, "w")); if (idl_fileCur () == NULL) { idl_reportOpenError (fname); } idl_registerBodyHeader (basename); for (i = 0; i < c_iterLength(typeNames); i++) { typeName = c_iterObject(typeNames, i); type = c_metaResolve ((c_metaObject)base, (const char *)typeName); if (type) { metaSer = sd_serializerXMLTypeinfoNew (base, TRUE); if (metaSer) { serData = sd_serializerSerialize (metaSer, c_object(type)); if (serData) { metaDescription = sd_serializerToString (metaSer, serData); if (metaDescription) { idl_registerBody (typeName, metaDescription); os_free (metaDescription); } } sd_serializerFree (metaSer); } } else { printf ("Specified type %s not found\n", typeName); } } idl_fileOutPrintf (idl_fileCur(), "\n"); idl_fileOutPrintf (idl_fileCur(), "void\n"); idl_fileOutPrintf (idl_fileCur(), "%s__register_types (c_base base)\n", basename); idl_fileOutPrintf (idl_fileCur(), "{\n"); for (i = 0; i < c_iterLength(typeNames); i++) { typeName = c_iterObject(typeNames, i); idl_fileOutPrintf (idl_fileCur(), " %s__register_type (base);\n", idl_cScopedTypeName(typeName)); } idl_fileOutPrintf (idl_fileCur(), "}\n"); idl_fileOutFree (idl_fileCur()); os_free (fname); }
void cmx_readerDataTypeAction( v_entity entity, c_voidp args) { sd_serializer ser; sd_serializedData data; c_type type; v_dataReader r; v_query query; v_topic topic; struct cmx_readerArg *arg; arg = (struct cmx_readerArg *)args; type = NULL; switch(v_object(entity)->kind){ case K_DATAREADER: r = v_dataReader(entity); v_observerLock(v_observer(r)); topic = v_dataReaderGetTopic(r); type = v_topicDataType(topic); c_free(topic); v_observerUnlock(v_observer(r)); break; case K_DATAREADERQUERY: query = v_query(entity); r = v_dataReader(v_querySource(query)); v_observerLock(v_observer(r)); topic = v_dataReaderGetTopic(r); type = v_topicDataType(topic); c_free(topic); v_observerUnlock(v_observer(r)); c_free(r); break; case K_NETWORKREADER: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Resolving data type of networkReader unsupported.\n"); assert(FALSE); break; case K_GROUPQUEUE: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Resolving data type of groupQueue unsupported.\n"); assert(FALSE); break; default: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Trying to resolve dataType of unknown reader type.\n"); assert(FALSE); break; } if(type != NULL){ ser = sd_serializerXMLMetadataNew(c_getBase(type)); data = sd_serializerSerialize(ser, type); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); } }
void cmx_readerSnapshotNewAction( v_public p, c_voidp args) { v_dataReader reader; c_iter instances; v_dataReaderInstance instance; v_dataReaderSample sample; v_query query; c_bool release; sd_serializer ser; sd_serializedData data; struct cmx_readerSnapshotArg* arg; release = FALSE; arg = (struct cmx_readerSnapshotArg*)args; reader = NULL; instances = NULL; ser = NULL; switch(v_object(p)->kind){ case K_DATAREADER: reader = v_dataReader(p); arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); if(reader->index->objects){ instances = ospl_c_select(reader->index->notEmptyList, 0); } break; case K_QUERY: case K_DATAREADERQUERY: query = v_query(p); reader = v_dataReader(v_querySource(query)); if(reader != NULL){ release = TRUE; arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); switch(v_object(query)->kind){ case K_DATAREADERQUERY: if(v_dataReaderQuery(query)->instanceQ){ instances = ospl_c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0); } break; default: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "cmx_readerSnapshotNewAction unknown kind (%d).", v_object(query)->kind); break; } } break; default: break; } if(arg->success == TRUE){ arg->snapshot->samples = c_iterNew(NULL); } if(instances != NULL){ v_dataReaderSample sampleShallowCopy = NULL; instance = v_dataReaderInstance(c_iterTakeFirst(instances)); while(instance != NULL){ v_state ivState = instance->_parent._parent.state & (L_DISPOSED | L_NOWRITERS | L_NEW); sample = v_dataReaderInstanceOldest(instance); if (sample != NULL) { do { v_state state = ivState | ((sample->_parent.sampleState & (L_READ | L_LAZYREAD)) ? L_READ : 0); if (sampleShallowCopy == NULL) { sampleShallowCopy = c_new(c_getType(c_object(sample))); } memcpy(sampleShallowCopy, sample, c_typeSize(c_getType(sampleShallowCopy))); sampleShallowCopy->newer = NULL; sampleShallowCopy->_parent.sampleState &= ~(L_DISPOSED | L_NOWRITERS | L_NEW | L_READ | L_LAZYREAD); sampleShallowCopy->_parent.sampleState |= state; if(ser == NULL){ ser = sd_serializerXMLNewTyped(c_getType(c_object(sampleShallowCopy))); } data = sd_serializerSerialize(ser, c_object(sampleShallowCopy)); arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data)); sd_serializedDataFree(data); sample = sample->newer; } while (sample != NULL); } c_free(instance); instance = v_dataReaderInstance(c_iterTakeFirst(instances)); } c_iterFree(instances); if (sampleShallowCopy != NULL) { memset(sampleShallowCopy, 0, c_typeSize(c_getType(sampleShallowCopy))); c_free(sampleShallowCopy); } } if(reader != NULL){ v_observerUnlock(v_observer(reader)); if(release == TRUE){ c_free(reader); } } if(ser != NULL){ sd_serializerFree(ser); } }