/************************************************************** * Public functions **************************************************************/ c_bool v_readerSubscribe( v_reader r, v_partition d) { c_bool result; assert(C_TYPECHECK(r,v_reader)); switch(v_objectKind(r)) { case K_DATAREADER: result = v_dataReaderSubscribe(v_dataReader(r),d); break; case K_DELIVERYSERVICE: result = v_deliveryServiceSubscribe(v_deliveryService(r),d); break; case K_GROUPQUEUE: result = v_groupStreamSubscribe(v_groupStream(r),d); break; case K_NETWORKREADER: result = v_networkReaderSubscribe(v_networkReader(r),d); break; default: OS_REPORT_1(OS_ERROR,"v_readerSubscribe failed",0, "illegal reader kind (%d) specified", v_objectKind(r)); assert(FALSE); result = FALSE; break; } readerGetHistoricalData(r); return result; }
c_bool v_readerUnSubscribe( v_reader r, v_partition d) { assert(C_TYPECHECK(r,v_reader)); switch(v_objectKind(r)) { case K_DATAREADER: return v_dataReaderUnSubscribe(v_dataReader(r),d); case K_DELIVERYSERVICE: return v_deliveryServiceUnSubscribe(v_deliveryService(r),d); case K_GROUPQUEUE: return v_groupStreamUnSubscribe(v_groupStream(r),d); case K_NETWORKREADER: return v_networkReaderUnSubscribe(v_networkReader(r),d); default: OS_REPORT_1(OS_ERROR,"v_readerUnSubscribe failed",0, "illegal reader kind (%d) specified", v_objectKind(r)); assert(FALSE); } return TRUE; }
c_bool v_readerUnSubscribeGroup( v_reader reader, v_group group) { c_bool result; assert(C_TYPECHECK(reader, v_reader)); switch(v_objectKind(reader)) { case K_DATAREADER: result = v_dataReaderUnSubscribeGroup(v_dataReader(reader), group); break; case K_GROUPQUEUE: result = v_groupStreamUnSubscribeGroup(v_groupStream(reader), group); break; case K_NETWORKREADER: result = v_networkReaderUnSubscribeGroup(v_networkReader(reader), group); break; default: OS_REPORT_1(OS_ERROR,"v_readerUnSubscribeGroup failed",0, "illegal reader kind (%d) specified", v_objectKind(reader)); assert(FALSE); result = FALSE; } return result; }
u_result u_readerGetMatchedPublications ( u_reader _this, v_statusAction action, c_voidp arg) { v_dataReader reader; v_spliced spliced; v_kernel kernel; u_result result; c_iter participants; v_participant participant; result = U_RESULT_PRECONDITION_NOT_MET; if (_this != NULL) { result = u_entityReadClaim(u_entity(_this), (v_entity*)(&reader)); if ((result == U_RESULT_OK) && (reader != NULL)) { kernel = v_objectKernel(reader); participants = v_resolveParticipants(kernel, V_SPLICED_NAME); assert(c_iterLength(participants) == 1); participant = v_participant(c_iterTakeFirst(participants)); spliced = v_spliced(participant); c_free(participant); c_iterFree(participants); result = u_resultFromKernel( v_splicedGetMatchedPublications(spliced, v_dataReader(reader), action, arg)); u_entityRelease(u_entity(_this)); } } return result; }
void v_publicDispose( v_public o) { assert(C_TYPECHECK(o,v_public)); if (o == NULL) { return; } switch(v_objectKind(o)) { case K_PARTICIPANT: v_participantDeinit(v_participant(o)); break; case K_PUBLISHER: v_publisherDeinit(v_publisher(o)); break; case K_SUBSCRIBER: v_subscriberDeinit(v_subscriber(o)); break; case K_WRITER: v_writerDeinit(v_writer(o)); break; case K_DATAREADER: v_dataReaderDeinit(v_dataReader(o)); break; case K_DELIVERYSERVICE:v_deliveryServiceDeinit(v_deliveryService(o)); break; case K_NETWORKREADER: v_networkReaderDeinit(v_networkReader(o)); break; case K_READER: v_readerDeinit(v_reader(o)); break; case K_GROUPQUEUE: v_groupQueueDeinit(v_groupQueue(o)); break; case K_TOPIC: v_topicDeinit(v_topic(o)); break; case K_ENTITY: break; case K_DOMAIN: v_partitionDeinit(v_partition(o)); break; case K_GROUP: v_groupDeinit(v_group(o)); break; case K_SERVICEMANAGER: /* Is never freed! */ break; case K_SPLICED: v_splicedDeinit(v_spliced(o)); break; case K_NETWORKING: case K_DURABILITY: case K_CMSOAP: case K_SERVICE: v_serviceDeinit(v_service(o)); break; case K_SERVICESTATE: /* Is never freed! */ break; case K_CONFIGURATION: break; case K_QUERY: OS_REPORT(OS_ERROR, "v_publicDispose failure", 0, "deinit of abstract class K_QUERY"); break; case K_DATAREADERQUERY: v_dataReaderQueryDeinit(v_dataReaderQuery(o)); break; case K_DATAVIEWQUERY: v_dataViewQueryDeinit(v_dataViewQuery(o)); break; case K_DATAVIEW: v_dataViewDeinit(v_dataView(o)); break; case K_WAITSET: v_waitsetDeinit(v_waitset(o)); break; case K_WRITERINSTANCE: v_writerInstanceDeinit(v_writerInstance(o)); break; case K_DATAREADERINSTANCE: v_dataReaderInstanceDeinit(v_dataReaderInstance(o)); break; case K_DATAVIEWINSTANCE: v_dataViewInstanceDeinit(v_dataViewInstance(o)); break; default: OS_REPORT_1(OS_ERROR,"v_publicDispose failed",0, "illegal entity kind (%d) specified",v_objectKind(o)); assert(FALSE); break; } c_free(o); }
void v_dataReaderSampleFree( v_dataReaderSample sample) { v_dataReaderInstance instance; v_index index; v_dataReader dataReader; v_message message; if (sample) { assert(C_TYPECHECK(sample, v_dataReaderSample)); if (c_refCount(sample) == 1) { /* Free the slave-samples as well */ instance = v_readerSample(sample)->instance; index = v_index(instance->index); dataReader = v_dataReader(index->reader); if (!v_readerSampleTestState(sample,L_READ)) { dataReader->notReadCount--; } #ifdef _SL_ if (dataReader->cachedSampleCount < 1000) { message = v_dataReaderSampleMessage(sample); c_free(message); v_dataReaderSampleTemplate(sample)->message = NULL; sample->prev = dataReader->cachedSample; dataReader->cachedSample = sample; dataReader->cachedSampleCount++; #else if (dataReader->cachedSample == NULL) { dataReader->cachedSample = sample; message = v_dataReaderSampleMessage(sample); c_free(message); v_dataReaderSampleTemplate(sample)->message = NULL; #endif } else { c_free(sample); } } else { c_free(sample); } } } void v_dataReaderSampleRemoveFromLifespanAdmin( v_dataReaderSample sample) { v_dataReaderInstance instance; v_index index; if (sample) { assert(C_TYPECHECK(sample, v_dataReaderSample)); instance = v_readerSample(sample)->instance; index = v_index(instance->index); v_lifespanAdminRemove(v_dataReaderEntry(index->entry)->lifespanAdmin, v_lifespanSample(sample)); } }
void v_subscriberFree( v_subscriber s) { v_kernel kernel; v_participant p; v_reader o; v_entity found; c_long sc; kernel = v_objectKernel(s); sc = (c_long)pa_decrement(&(s->shareCount)); if (sc > 0) return; if(sc == 0){ v_observableRemoveObserver(v_observable(kernel->groupSet),v_observer(s), NULL); if (s->qos->share.enable) { found = v_removeShare(kernel,v_entity(s)); assert(found == v_entity(s)); c_free(found); } while ((o = c_take(s->readers)) != NULL) { switch (v_objectKind(o)) { case K_DATAREADER: v_dataReaderFree(v_dataReader(o)); break; case K_DELIVERYSERVICE: v_deliveryServiceFree(v_deliveryService(o)); break; case K_GROUPQUEUE: v_groupQueueFree(v_groupQueue(o)); break; case K_NETWORKREADER: v_networkReaderFree(v_networkReader(o)); break; default: OS_REPORT_1(OS_ERROR, "v_subscriber", 0, "Unknown reader %d", v_objectKind(o)); assert(FALSE); break; } c_free(o); } p = v_participant(s->participant); if (p != NULL) { v_participantRemove(p,v_entity(s)); s->participant = NULL; } v_publicFree(v_public(s)); } else { OS_REPORT_1(OS_ERROR, "v_subscriberFree", 0, "subscriber already freed (shareCount is now %d).", sc); assert(sc == 0); } }
static void getCopyInfo ( v_entity e, c_voidp argument) { v_topic kt; c_type sampleType; c_property messageAttr; _DataReader dataReader = (_DataReader)argument; sampleType = v_dataReaderSampleType(v_dataReader(e)); kt = v_dataReaderGetTopic(v_dataReader(e)); dataReader->userdataOffset = v_topicDataOffset(kt); c_free(kt); messageAttr = c_property(c_metaResolve(c_metaObject(sampleType),"message")); dataReader->messageOffset = messageAttr->offset; c_free(messageAttr); }
c_char* cmx_dataReaderInit( v_dataReader entity) { char buf[512]; v_dataReader dr; dr = v_dataReader(entity); snprintf(buf, 24, "<kind>DATAREADER</kind>"); return (c_char*)(os_strdup(buf)); }
/* ----------------------------------- Private ------------------------------ */ static c_bool qosChangedAction( c_object o, c_voidp arg) { v_dataReader r; if (v_objectKind(o) == K_DATAREADER) { r = v_dataReader(o); v_dataReaderUpdateConnections(r,(v_dataReaderConnectionChanges *)arg); v_dataReaderNotifyChangedQos(r); } return TRUE; }
u_instanceHandle u_instanceHandleFix( u_instanceHandle _this, v_collection reader) { u_instanceHandleTranslator translator; struct v_publicationInfo *data; v_topic topic; v_message message; v_public instance; translator.handle = _this; if (translator.lid.lifecycleId & HANDLE_GLOBAL_MASK) { /* Is a GID therefore fix handle by lookup. */ while (v_objectKind(v_entity(reader)) == K_QUERY || v_objectKind(v_entity(reader)) == K_DATAREADERQUERY || v_objectKind(v_entity(reader)) == K_DATAVIEWQUERY) { /* If the entity derives from a query entity it can be cast to a v_query */ reader = v_querySource(v_query(reader)); } while (v_objectKind(v_entity(reader)) == K_DATAVIEW) { reader = v_collection(v_dataViewGetReader(v_dataView(reader))); } topic = v_dataReaderGetTopic(v_dataReader(reader)); message = v_topicMessageNew(topic); data = (c_voidp)C_DISPLACE(message, v_topicDataOffset(topic)); data->key = u_instanceHandleToGID(_this); instance = (v_public)v_dataReaderLookupInstance(v_dataReader(reader), message); translator.handle = u_instanceHandleNew(instance); c_free(instance); c_free(topic); c_free(message); } return translator.handle; }
v_result v_readerSetQos( v_reader r, v_readerQos qos) { v_result result; v_qosChangeMask cm; assert(C_TYPECHECK(r,v_reader)); v_readerEntrySetLock(r); result = v_readerQosSet(r->qos, qos, v_entity(r)->enabled, &cm); v_readerEntrySetUnlock(r); if ((result == V_RESULT_OK) && (cm != 0)) { if (v_objectKind(r) == K_DATAREADER) { v_dataReaderNotifyChangedQos(v_dataReader(r)); } } return result; }
/************************************************************** * Protected functions **************************************************************/ c_bool v_readerSubscribeGroup( v_reader _this, v_group group) { c_bool result; assert(C_TYPECHECK(_this, v_reader)); switch(v_objectKind(_this)) { case K_DATAREADER: /* ES, dds1576: For the K_DATAREADER object we need to verify if * the access rights are correct. No subscriptions may be made onto * groups which have a v_accessMode of write only. */ if(v_groupPartitionAccessMode(group) == V_ACCESS_MODE_READ_WRITE || v_groupPartitionAccessMode(group) == V_ACCESS_MODE_READ) { result = v_dataReaderSubscribeGroup(v_dataReader(_this), group); readerGetHistoricalData(_this); } else { result = FALSE; } break; case K_GROUPQUEUE: result = v_groupStreamSubscribeGroup(v_groupStream(_this), group); break; case K_NETWORKREADER: result = v_networkReaderSubscribeGroup(v_networkReader(_this), group); readerGetHistoricalData(_this); break; default: OS_REPORT_1(OS_ERROR,"v_readerSubscribeGroup failed",0, "illegal reader kind (%d) specified", v_objectKind(_this)); assert(FALSE); result = FALSE; } return result; }
v_query v_queryNew ( v_collection source, const c_char *name, q_expr predicate, c_value params[]) { v_query q; v_dataReader reader; v_dataView readerView; assert(C_TYPECHECK(source,v_collection)); q = NULL; switch(v_objectKind(source)) { case K_DATAREADER: reader = v_dataReader(source); q = v_query(v_dataReaderQueryNew( reader, name, predicate, params)); break; case K_DATAVIEW: readerView = v_dataView(source); q = v_query(v_dataViewQueryNew( readerView, name, predicate, params)); break; default: OS_REPORT_1(OS_ERROR, "v_queryNew failed",0, "illegal source kind (%d) specified", v_objectKind(source)); } return q; }
void readerDeadlineMissed( v_leaseAction leaseAction, c_time now) { v_object o; v_handleResult r; assert(leaseAction != NULL); assert(C_TYPECHECK(leaseAction, v_leaseAction)); r = v_handleClaim(leaseAction->actionObject, &o); if (r == V_HANDLE_OK) { v_dataReaderCheckDeadlineMissed(v_dataReader(o), now); r = v_handleRelease(leaseAction->actionObject); if(r != V_HANDLE_OK) { OS_REPORT_1(OS_WARNING, "v_leaseManager", 0, "Handle release failed with result code %d ", r); } } }
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); } }
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); } }
d_readerRequest d_readerRequestNew( d_admin admin, v_handle source, c_char* filter, c_char** filterParams, c_long filterParamsCount, struct v_resourcePolicy resourceLimits, c_time minSourceTimestamp, c_time maxSourceTimestamp) { d_readerRequest request; c_long i; v_handleResult handleResult; v_reader vreader, *vreaderPtr; c_iter partitions; v_partition partition; v_topic topic; d_group dgroup; c_char *topicName; d_quality quality; request = d_readerRequest(os_malloc(C_SIZEOF(d_readerRequest))); if(request){ d_lockInit(d_lock(request), D_READER_REQUEST, d_readerRequestDeinit); request->admin = admin; request->readerHandle.index = source.index; request->readerHandle.serial = source.serial; request->readerHandle.server = source.server; request->requests = d_tableNew(d_chainCompare, d_chainFree); if(filter){ request->filter = os_strdup(filter); } else { request->filter = NULL; } request->resourceLimits = resourceLimits; request->minSourceTimestamp = minSourceTimestamp; request->maxSourceTimestamp = maxSourceTimestamp; request->filterParamsCount = filterParamsCount; if(filterParamsCount > 0){ request->filterParams = (c_char**)(os_malloc( filterParamsCount*sizeof(c_char*))); for(i=0; i<filterParamsCount; i++){ request->filterParams[i] = os_strdup(filterParams[i]); } } else { request->filterParams = NULL; } request->groups = d_tableNew(d_groupCompare, d_groupFree); handleResult = v_handleClaim(source, (v_object*)(vreaderPtr = &vreader)); if(handleResult == V_HANDLE_OK){ if(v_object(vreader)->kind == K_DATAREADER){ topic = v_dataReaderGetTopic(v_dataReader(vreader)); topicName = v_entity(topic)->name; partitions = ospl_c_select(v_subscriber(vreader->subscriber)->partitions->partitions, 0); partition = v_partition(c_iterTakeFirst(partitions)); while(partition){ quality.seconds = 0; quality.nanoseconds = 0; dgroup = d_groupNew( v_entity(partition)->name, topicName, topic->qos->durability.kind, D_GROUP_KNOWLEDGE_UNDEFINED, quality); d_tableInsert(request->groups, dgroup); c_free(partition); partition = v_partition(c_iterTakeFirst(partitions)); } c_free(topic); } else { d_readerRequestFree(request); request = NULL; } v_handleRelease(source); } else { d_readerRequestFree(request); request = NULL; } } return request; }
v_dataReaderSample v_dataReaderSampleNew( v_dataReaderInstance instance, v_message message) { v_dataReader dataReader; v_dataReaderSample sample; v_readerQos readerQos; v_index index; os_timeE msgEpoch; assert(instance != NULL); assert(C_TYPECHECK(message,v_message)); index = v_index(instance->index); dataReader = v_dataReader(index->reader); readerQos = v_reader(dataReader)->qos; assert(readerQos); sample = v_dataReaderSample(c_new(dataReader->sampleType)); if (sample != NULL) { v_readerSample(sample)->instance = (c_voidp)instance; v_readerSample(sample)->viewSamples = NULL; v_readerSample(sample)->sampleState = 0; sample->insertTime = os_timeWGet(); /* The expiry time calculation is dependent on the DestinationOrderQos(readerQos->orderby.v.kind): * In case of the by_reception_timestamp kind the expiry time is determined based on insertion time(sample->insertTime). * In case of the by_source_timestamp kind the expiry time is determined based on source time (message->writeTime). */ msgEpoch = os_timeEGet(); if (readerQos->orderby.v.kind == V_ORDERBY_SOURCETIME) { /* assuming wall clocks of source and destination are aligned! * calculate the age of the message and then correct the message epoch. */ os_duration message_age = os_timeWDiff(os_timeWGet(), message->writeTime); msgEpoch = os_timeESub(msgEpoch, message_age); } v_dataReaderSampleTemplate(sample)->message = c_keep(message); sample->disposeCount = instance->disposeCount; sample->noWritersCount = instance->noWritersCount; sample->publicationHandle = message->writerGID; sample->readId = 0; sample->newer = NULL; /* When both ReaderLifespanQos(readerQos->lifespan.used) and the inline LifespanQos (v_messageQos_getLifespanPeriod(message->qos)) * are set the expiryTime will be set to the earliest time among them. */ if (message->qos) { os_duration lifespan = v_messageQos_getLifespanPeriod(message->qos); if (readerQos->lifespan.v.used) { if (os_durationCompare(readerQos->lifespan.v.duration, lifespan) == OS_LESS) { v_lifespanSample(sample)->expiryTime = os_timeEAdd(msgEpoch, readerQos->lifespan.v.duration); } else { v_lifespanSample(sample)->expiryTime = os_timeEAdd(msgEpoch, lifespan); } v_lifespanAdminInsert(v_dataReaderEntry(index->entry)->lifespanAdmin, v_lifespanSample(sample)); } else { if (OS_DURATION_ISINFINITE(lifespan)) { v_lifespanSample(sample)->expiryTime = OS_TIMEE_INFINITE; } else { v_lifespanSample(sample)->expiryTime = os_timeEAdd(msgEpoch, lifespan); v_lifespanAdminInsert(v_dataReaderEntry(index->entry)->lifespanAdmin, v_lifespanSample(sample)); } } } else { if (readerQos->lifespan.v.used) { v_lifespanSample(sample)->expiryTime = os_timeEAdd(msgEpoch,readerQos->lifespan.v.duration); v_lifespanAdminInsert(v_dataReaderEntry(index->entry)->lifespanAdmin, v_lifespanSample(sample)); } else { v_lifespanSample(sample)->expiryTime = OS_TIMEE_INFINITE; } } } else { OS_REPORT(OS_FATAL, OS_FUNCTION, V_RESULT_INTERNAL_ERROR, "Failed to allocate v_dataReaderSample."); } return sample; }
v_dataReaderSample v_dataReaderSampleNew( v_dataReaderInstance instance, v_message message) { v_dataReader dataReader; v_dataReaderSample sample; v_readerQos readerQos; v_index index; assert(instance != NULL); assert(C_TYPECHECK(message,v_message)); index = v_index(instance->index); dataReader = v_dataReader(index->reader); readerQos = v_reader(dataReader)->qos; if (dataReader->cachedSample != NULL) { sample = dataReader->cachedSample; /* Unfinished proto for cache size control * #define _SL_ */ #ifdef _SL_ dataReader->cachedSample = sample->prev; sample->prev = NULL; dataReader->cachedSampleCount--; #else dataReader->cachedSample = NULL; #endif } else { sample = v_dataReaderSample(c_extentCreate(dataReader->sampleExtent)); } v_readerSample(sample)->instance = (c_voidp)instance; v_readerSample(sample)->viewSamples = NULL; if ((message->transactionId != 0) && (v_reader(dataReader)->subQos->presentation.coherent_access)) { v_readerSample(sample)->sampleState = L_TRANSACTION; } else { v_readerSample(sample)->sampleState = 0; } #ifdef _NAT_ sample->insertTime = v_timeGet(); #else #define _INCORRECT_BUT_LOW_INSERT_LATENCY_ #ifdef _INCORRECT_BUT_LOW_INSERT_LATENCY_ if (v_timeIsZero(v_reader(dataReader)->qos->latency.duration)) { sample->insertTime = v_timeGet(); } else { sample->insertTime = message->allocTime; } #else sample->insertTime = v_timeGet(); #endif #endif if (readerQos->lifespan.used) { v_lifespanSample(sample)->expiryTime = c_timeAdd(sample->insertTime, readerQos->lifespan.duration); } else { v_lifespanSample(sample)->expiryTime = c_timeAdd(sample->insertTime, v_messageQos_getLifespanPeriod(message->qos)); } sample->disposeCount = instance->disposeCount; sample->noWritersCount = instance->noWritersCount; sample->publicationHandle = message->writerGID; sample->readId = 0; sample->prev = NULL; assert(message); v_dataReaderSampleTemplate(sample)->message = c_keep(message); v_lifespanAdminInsert(v_dataReaderEntry(index->entry)->lifespanAdmin, v_lifespanSample(sample)); dataReader->notReadCount++; return sample; }
/** * PRE: v_observerLock has been called. * * When the text 'intentionally no break' is set after a case label * the class specified by the label has not implemented the notify * method. */ void v_observerNotify( v_observer _this, v_event event, c_voidp userData) { /* This Notify method is part of the observer-observable pattern. * It is designed to be invoked when _this object as observer receives * an event from an observable object. * It must be possible to pass the event to the subclass of itself by * calling <subclass>Notify(_this, event, userData). * This implies that _this cannot be locked within any Notify method * to avoid deadlocks. * For consistency _this must be locked by v_observerLock(_this) before * calling this method. */ c_ulong trigger; assert(_this != NULL); assert(C_TYPECHECK(_this,v_observer)); /* The observer will be made insensitive to event as soon as the * observer is deinitialized. However it may be that destruction * of the observer has started before the deinit of the observer * is called. In that case the V_EVENT_OBJECT_DESTROYED flag will * be set to avoid processing of incomming events. */ if ((_this->eventFlags & V_EVENT_OBJECT_DESTROYED) == 0) { /* The observer is valid so the event can be processed. */ if (event != NULL ) { trigger = event->kind & _this->eventMask; } else { /* NULL-event always notifies observers */ trigger = V_EVENT_TRIGGER; } /* The following code invokes the observers subclass specific * notification method. * This is a bit strange that the observer has knowledge about * the subclass notification methods, a better model is that * subclasses register the notification method to the observer * instead. The reason for this model is that registering a * function pointer is only valid in the process scope and this * method will typically be called from another process. */ if (trigger != 0) { switch (v_objectKind(_this)) { case K_DATAREADER: v_dataReaderNotify(v_dataReader(_this), event, userData); break; case K_WAITSET: v_waitsetNotify(v_waitset(_this), event, userData); break; case K_PARTICIPANT: v_participantNotify(v_participant(_this), event, userData); break; case K_TOPIC: v_topicNotify(v_topic(_this), event, userData); break; case K_QUERY: /* v_queryNotify(v_query(_this), event, userData); */ break; case K_SPLICED: /* intentionally no break */ case K_SERVICE: case K_NETWORKING: case K_DURABILITY: case K_CMSOAP: v_serviceNotify(v_service(_this), event, userData); break; case K_SERVICEMANAGER: v_serviceManagerNotify(v_serviceManager(_this), event, userData); break; case K_WRITER: /* no action for the following observers */ case K_PUBLISHER: case K_SUBSCRIBER: case K_GROUPQUEUE: break; default: OS_REPORT_1(OS_INFO,"Kernel Observer",0, "Notify an unknown observer type: %d", v_objectKind(_this)); break; } /* * Only trigger condition variable if at least * one thread is waiting AND the event is seen for the first time. */ if ((_this->waitCount > 0) && ((trigger == V_EVENT_TRIGGER) || (~_this->eventFlags & trigger))) { _this->eventFlags |= trigger; /* store event */ c_condBroadcast(&_this->cv); } else { _this->eventFlags |= trigger; /* store event */ } } } /* else observer object destroyed, skip notification */ }
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); } }