c_bool
v_querySetParams(
v_query q,
q_expr predicate,
c_value params[])
{
c_bool result = FALSE;
assert(C_TYPECHECK(q,v_query));
if (q != NULL) {
switch (v_objectKind(q)) {
case K_DATAREADERQUERY:
result = v_dataReaderQuerySetParams(v_dataReaderQuery(q),
predicate,
params);
break;
case K_DATAVIEWQUERY:
result = v_dataViewQuerySetParams(v_dataViewQuery(q),
predicate,
params);
break;
default:
OS_REPORT_1(OS_ERROR,
"v_querySetParams failed",0,
"illegal query kind (%d) specified",
v_objectKind(q));
assert(FALSE);
}
}
return result;
}
c_bool
v_queryTriggerTest(
v_query q)
{
c_bool result = FALSE;
if (q == NULL) {
return FALSE;
}
assert(C_TYPECHECK(q,v_query));
switch (v_objectKind(q)) {
case K_DATAREADERQUERY:
result = v_dataReaderQueryTriggerTest(v_dataReaderQuery(q));
break;
case K_DATAVIEWQUERY:
result = v_dataViewQueryTest(v_dataViewQuery(q));
break;
default:
OS_REPORT_1(OS_ERROR,
"v_queryTest failed",0,
"illegal query kind (%d) specified",
v_objectKind(q));
assert(FALSE);
}
return result;
}
c_bool
v_queryNotifyDataAvailable(
v_query _this,
v_event event)
{
c_bool result = TRUE;
switch (v_objectKind(_this)) {
case K_DATAREADERQUERY:
result = v_dataReaderQueryNotifyDataAvailable(
v_dataReaderQuery(_this),
event);
break;
case K_DATAVIEWQUERY:
result = v_dataViewQueryNotifyDataAvailable(
v_dataViewQuery(_this),
event);
break;
default:
break;
OS_REPORT_1(OS_ERROR,
"v_queryNotifyDataAvailable failed",0,
"illegal query kind (%d) specified",
v_objectKind(_this));
assert(FALSE);
result = TRUE;
}
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);
}
static c_bool
v_queryTakeInternal(
v_query q,
v_dataReaderInstance instance,
c_bool readNext,
c_action action,
c_voidp arg)
{
c_bool proceed;
v_dataReaderQuery drq;
v_dataViewQuery dvq;
if (q == NULL) {
return FALSE;
}
assert(C_TYPECHECK(q,v_query));
switch (v_objectKind(q)) {
case K_DATAREADERQUERY:
drq = v_dataReaderQuery(q);
if (readNext) {
proceed = v_dataReaderQueryTakeNextInstance(drq, instance,
(v_readerSampleAction)action,arg);
} else {
if (instance) {
proceed = v_dataReaderQueryTakeInstance(drq,
instance,
(v_readerSampleAction)action, arg);
} else {
proceed = v_dataReaderQueryTake(drq,
(v_readerSampleAction)action, arg);
}
}
break;
case K_DATAVIEWQUERY:
dvq = v_dataViewQuery(q);
if (readNext) {
proceed = v_dataViewQueryTakeNextInstance(dvq,
(v_dataViewInstance)instance,
(v_readerSampleAction)action, arg);
} else {
if (instance) {
proceed = v_dataViewQueryTakeInstance(dvq,
(v_dataViewInstance)instance,
(v_readerSampleAction)action,
arg);
} else {
proceed = v_dataViewQueryTake(dvq,
(v_readerSampleAction)action, arg);
}
}
break;
default:
OS_REPORT_1(OS_ERROR,"v_queryTake failed",0,
"illegal query kind (%d) specified",v_objectKind(q));
assert(FALSE);
proceed = FALSE;
}
return proceed;
}
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);
}
}
c_char*
cmx_queryInit(
v_query entity)
{
v_dataReaderQuery query;
char buf[512];
query = v_dataReaderQuery(entity);
if(query->expression){
if(query->params){
os_sprintf(buf,
"<kind>QUERY</kind>"
"<expression><![CDATA[%s]]></expression>"
"<params><![CDATA[%s]]></params>"
"<instanceState>%u</instanceState>"
"<sampleState>%u</sampleState>"
"<viewState>%u</viewState>",
query->expression, query->params,
query->instanceMask,
query->sampleMask,
query->viewMask);
} else {
os_sprintf(buf,
"<kind>QUERY</kind>"
"<expression><![CDATA[%s]]></expression>"
"<params></params>"
"<instanceState>%u</instanceState>"
"<sampleState>%u</sampleState>"
"<viewState>%u</viewState>",
query->expression,
query->instanceMask,
query->sampleMask,
query->viewMask);
}
} else {
if(query->params){
os_sprintf(buf,
"<kind>QUERY</kind>"
"<expression></expression>"
"<params><![CDATA[%s]]></params>"
"<instanceState>%u</instanceState>"
"<sampleState>%u</sampleState>"
"<viewState>%u</viewState>",
query->params,
query->instanceMask,
query->sampleMask,
query->viewMask);
} else {
os_sprintf(buf,
"<kind>QUERY</kind>"
"<expression></expression>"
"<params></params>"
"<instanceState>%u</instanceState>"
"<sampleState>%u</sampleState>"
"<viewState>%u</viewState>",
query->instanceMask,
query->sampleMask,
query->viewMask);
}
}
return (c_char*)(os_strdup(buf));
}
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);
}
}
