void
cms_clientFree(
cms_client client)
{
struct soap* soap;
cms_soapThread soapThread;
cms_thread(client)->terminate = TRUE;
os_mutexLock(&client->conditionMutex);
os_condSignal(&client->condition);
os_mutexUnlock(&client->conditionMutex);
cms_threadDeinit(cms_thread(client));
if(client->soapEnvs){
os_mutexLock(&client->soapMutex);
soap = (struct soap*)(c_iterTakeFirst(client->soapEnvs));
while(soap){
soap->error = soap_receiver_fault(soap, "Service is terminating.", NULL);
soap_send_fault(soap);
soap_destroy(soap);
soap_end(soap);
soap_done(soap);
os_free(soap);
soap = (struct soap*)(c_iterTakeFirst(client->soapEnvs));
}
c_iterFree(client->soapEnvs);
client->soapEnvs = NULL;
os_mutexUnlock(&client->soapMutex);
}
if(client->threads){
soapThread = cms_soapThread(c_iterTakeFirst(client->threads));
while(soapThread){
cms_soapThreadFree(soapThread);
(void)u_observableAction(u_observable(client->service->uservice), cms_clientStatisticsThreadRemove, client->service);
soapThread = cms_soapThread(c_iterTakeFirst(client->threads));
}
c_iterFree(client->threads);
client->threads = NULL;
}
os_mutexDestroy(&client->soapMutex);
os_mutexDestroy(&client->threadMutex);
os_mutexDestroy(&client->conditionMutex);
os_condDestroy(&client->condition);
client->initCount = 0;
if(client->service->configuration->verbosity >= 5){
OS_REPORT(OS_INFO, CMS_CONTEXT, 0,
"Client thread stopped for IP: %d.%d.%d.%d",
(int)(client->ip>>24)&0xFF,
(int)(client->ip>>16)&0xFF,
(int)(client->ip>>8)&0xFF,
(int)(client->ip&0xFF));
}
void
d_waitsetDeinit(
d_object object)
{
d_waitset waitset;
d_waitsetEntity we;
d_waitsetHelper helper;
assert(d_objectIsValid(object, D_WAITSET) == TRUE);
if(object){
waitset = d_waitset(object);
waitset->terminate = TRUE;
if(waitset->runToCompletion == TRUE){
if(os_threadIdToInteger(waitset->thread)) {
u_waitsetNotify(waitset->uwaitset, NULL);
os_threadWaitExit(waitset->thread, NULL);
}
} else {
if(waitset->threads){
helper = d_waitsetHelper(c_iterTakeFirst(waitset->threads));
while(helper){
helper->terminate = TRUE;
u_waitsetNotify(helper->userWaitset, NULL);
os_threadWaitExit(helper->tid, NULL);
u_waitsetDetach(helper->userWaitset, u_entity(helper->entity->dispatcher));
u_waitsetFree(helper->userWaitset);
os_free(helper);
helper = d_waitsetHelper(c_iterTakeFirst(waitset->threads));
}
c_iterFree(waitset->threads);
waitset->threads = NULL;
}
}
d_lockLock(d_lock(waitset));
if(waitset->entities) {
we = d_waitsetEntity(c_iterTakeFirst(waitset->entities));
while(we) {
if(waitset->runToCompletion == TRUE){
u_waitsetDetach(waitset->uwaitset, u_entity(we->dispatcher));
}
d_waitsetEntityFree(we);
we = d_waitsetEntity(c_iterTakeFirst(waitset->entities));
}
c_iterFree(waitset->entities);
}
if(waitset->runToCompletion == TRUE){
if(waitset->uwaitset) {
u_waitsetFree(waitset->uwaitset);
}
}
d_lockUnlock(d_lock(waitset));
}
}
jni_result
jni_participantFree(
jni_participant p)
{
jni_result r;
jni_partition partition;
r = JNI_RESULT_OK;
if(p != NULL){
if((p->publishers != NULL) && (c_iterLength(p->publishers) != 0)){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else if((p->subscribers != NULL) && (c_iterLength(p->subscribers) != 0)){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else if((p->topics != NULL) && (c_iterLength(p->topics) != 0)){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else if((p->partitions != NULL) && (c_iterLength(p->partitions) != 0)){
partition = jni_partition(c_iterTakeFirst(p->partitions));
while((partition != NULL) && (r == JNI_RESULT_OK)){
r = jni_partitionFree(partition);
partition = jni_partition(c_iterTakeFirst(p->partitions));
}
}
else{
/*DO NOTHING.*/
}
if(r == JNI_RESULT_OK){
if(p->publishers != NULL){
c_iterFree(p->publishers);
}
if(p->subscribers != NULL){
c_iterFree(p->subscribers);
}
if(p->topics != NULL){
c_iterFree(p->topics);
}
if(p->partitions != NULL){
c_iterFree(p->partitions);
}
if(p->uparticipant != NULL){
r = jni_convertResult(u_participantFree(p->uparticipant));
}
else{
r = JNI_RESULT_OK;
}
os_free(p);
}
}
else{
r = JNI_RESULT_BAD_PARAMETER;
}
return r;
}
void
jni_getTopicKeyExpression(
v_entity entity,
c_voidp args)
{
v_kernel vk;
c_iter vtopics;
c_array keyList;
c_char* keyExpr;
c_long nrOfKeys, totalSize, i;
c_string fieldName, actualFieldName;
struct jni_topicArg *arg;
arg = (struct jni_topicArg *)args;
vk = v_objectKernel(entity);
if(vk != NULL){
vtopics = v_resolveTopics(vk, arg->topicName);
if(c_iterLength(vtopics) == 0){
c_iterFree(vtopics);
}
else{
keyList = v_topicMessageKeyList(c_iterTakeFirst(vtopics));
c_iterFree(vtopics);
nrOfKeys = c_arraySize(keyList);
if (nrOfKeys>0) {
totalSize = 0;
for (i=0;i<nrOfKeys;i++) {
fieldName = c_fieldName(keyList[i]);
totalSize += (strlen(fieldName)+1-9/*skip 'userdata.'*/);
}
keyExpr = (c_char *)os_malloc((size_t)(totalSize+1));
keyExpr[0] = 0;
for (i=0;i<nrOfKeys;i++) {
fieldName = c_fieldName(keyList[i]);
actualFieldName = c_skipUntil(fieldName, ".");
actualFieldName++; /*skip '.' */
os_strcat(keyExpr,actualFieldName);
if (i<(nrOfKeys-1)) {
os_strcat(keyExpr,",");
}
}
arg->keyExpr = keyExpr;
} else{
/*No keys, do nothing.*/
}
arg->result = U_RESULT_OK;
}
}
}
c_iter
v_partitionLookupSubscribers(
v_partition partition)
{
c_iter participants;
c_iter result;
c_iter entities;
c_iter partitions;
v_participant participant;
v_entity entity;
v_entity partition2;
result = NULL;
participants = v_resolveParticipants(v_objectKernel(partition), "*");
participant = v_participant(c_iterTakeFirst(participants));
while (participant != NULL) {
c_lockRead(&participant->lock);
entities = c_select(participant->entities, 0);
c_lockUnlock(&participant->lock);
entity = v_entity(c_iterTakeFirst(entities));
while (entity != NULL) {
if(v_objectKind(entity) == K_SUBSCRIBER) {
partitions = v_subscriberLookupPartitions(v_subscriber(entity),
v_partitionName(partition));
if (c_iterLength(partitions) > 0) {
result = c_iterInsert(result, entity); /* transfer refcount */
} else {
c_free(entity);
}
partition2 = v_entity(c_iterTakeFirst(partitions));
while (partition2 != NULL) {
c_free(partition2);
partition2 = v_entity(c_iterTakeFirst(partitions));
}
c_iterFree(partitions);
}
/* entity is already free or refcount transferred to result */
entity = v_entity(c_iterTakeFirst(entities));
}
c_iterFree(entities);
c_free(participant);
participant = v_participant(c_iterTakeFirst(participants));
}
c_iterFree(participants);
return result;
}
static void
deliveryServiceUnSubscribe(
void *o,
void *arg)
{
v_partition p = v_partition(o);
v_deliveryServiceEntry e = v_deliveryServiceEntry(arg);
v_kernel kernel;
v_group g;
c_value params[2];
c_iter list;
assert(C_TYPECHECK(e,v_deliveryServiceEntry));
assert(C_TYPECHECK(p,v_partition));
params[0] = c_objectValue(p);
params[1] = c_objectValue(e->topic);
kernel = v_objectKernel(e);
list = v_groupSetSelect(kernel->groupSet,
"partition = %0 and topic = %1",
params);
while ((g = c_iterTakeFirst(list)) != NULL) {
v_groupRemoveEntry(g,v_entry(e));
c_free(g);
}
c_iterFree(list);
}
void
_ObjectRegistryFree (
_ObjectRegistry registry)
{
gapi_handle handle;
int ptr;
assert(registry);
os_mutexLock(®istry->mutex);
ptr = 0;
while ( registry->trash[ptr] != NULL ) {
gapi__free(registry->trash[ptr]);
registry->trash[ptr] = NULL;
ptr = (ptr + 1)%TRASH_LENGTH;
}
handle = c_iterTakeFirst(registry->active);
while ( handle != NULL ) {
handle->registry = NULL;
gapi__free(handle);
handle = c_iterTakeFirst(registry->active);
}
c_iterFree(registry->active);
os_mutexUnlock(®istry->mutex);
os_mutexDestroy(®istry->mutex);
os_free(registry);
}
void
v_entryRemoveGroup(
v_entry entry,
v_group group)
{
c_query query;
q_expr qExpr;
c_value params[2];
c_iter groups;
v_proxy proxy, proxy2;
v_handle handle;
assert(entry != NULL);
assert(C_TYPECHECK(entry,v_entry));
assert(group != NULL);
assert(C_TYPECHECK(group,v_group));
handle = v_publicHandle(v_public(group));
qExpr = (q_expr)q_parse("source.index = %0 and source.server = %1");
params[0] = c_longValue(handle.index);
params[1] = c_addressValue(handle.server);
query = c_queryNew(entry->groups, qExpr, params);
q_dispose(qExpr);
groups = c_select(query, 0);
c_free(query);
assert(c_iterLength(groups) <= 1);
proxy = v_proxy(c_iterTakeFirst(groups));
proxy2 = c_remove(entry->groups, proxy, NULL, NULL);
c_iterFree(groups);
c_free(proxy);
c_free(proxy2);
}
void
v_entryFree(
v_entry entry)
{
c_iter proxies;
v_proxy proxy;
v_group group;
assert(C_TYPECHECK(entry,v_entry));
proxies = c_select(entry->groups, 0);
proxy = c_iterTakeFirst(proxies);
while (proxy != NULL) {
group = v_group(v_proxyClaim(proxy));
if (group) {
v_groupRemoveEntry(group, entry);
v_proxyRelease(proxy);
}
c_free(proxy);
proxy = c_iterTakeFirst(proxies);
}
c_iterFree(proxies);
/* No parent to call Free on */
}
c_bool
v_groupStreamUnSubscribe(
v_groupStream stream,
v_partition partition)
{
c_iter list;
v_group group;
c_bool result;
assert(C_TYPECHECK(stream, v_groupStream));
assert(C_TYPECHECK(partition, v_partition));
list = ospl_c_select(stream->groups, 0);
group = c_iterTakeFirst(list);
result = FALSE;
while (group != NULL) {
if(strcmp(v_partitionName(partition),
v_partitionName(group->partition)) == 0){
result = v_groupStreamUnSubscribeGroup(stream, group);
}
c_free(group);
group = c_iterTakeFirst(list);
}
c_iterFree(list);
return result;
}
c_bool
v_groupStreamSubscribe(
v_groupStream stream,
v_partition partition)
{
c_iter list;
v_kernel kernel;
c_value params[1];
v_group group;
assert(C_TYPECHECK(stream,v_groupStream));
kernel = v_objectKernel(v_entity(partition));
params[0] = c_objectValue(partition);
list = v_groupSetSelect(kernel->groupSet,"partition = %0 ",params);
group = c_iterTakeFirst(list);
while (group != NULL) {
v_groupStreamSubscribeGroup(stream, group);
c_free(group);
group = c_iterTakeFirst(list);
}
c_iterFree(list);
return TRUE;
}
void
cmx_readerSnapshotFreeAll()
{
cmx_readerSnapshot s;
c_char* sample;
os_mutex m;
m = cmx_getReaderSnapshotMutex();
os_mutexLock(&m);
s = cmx_readerSnapshot(c_iterTakeFirst(readerSnapshots));
while(s != NULL){
if(s->samples != NULL){
sample = (c_char*)(c_iterTakeFirst(s->samples));
while(sample != NULL){
os_free(sample);
sample = (c_char*)(c_iterTakeFirst(s->samples));
}
c_iterFree(s->samples);
}
os_free(s);
s = cmx_readerSnapshot(c_iterTakeFirst(readerSnapshots));
}
os_mutexUnlock(&m);
}
static void*
cms_soapThreadRun(
void *thr)
{
cms_soapThread thread;
struct soap* soap;
c_char* result;
thread = cms_soapThread(thr);
os_mutexLock(&thread->soapMutex);
while(cms_thread(thread)->terminate == FALSE){
if(thread->soap != NULL){
soap = thread->soap;
thread->soap = NULL;
cms_thread(thread)->results = NULL;
soap->user = thr;
soap_serve(soap);
soap_destroy(soap);
soap_end(soap);
soap_done(soap);
free(soap);
u_entityAction( u_entity(thread->client->service->uservice),
cms_soapThreadStatisticsRequestHandledAdd,
thread->client->service);
if(cms_thread(thread)->results != NULL){
result = (c_char*)(c_iterTakeFirst(cms_thread(thread)->results));
while(result){
os_free(result);
result = (c_char*)(c_iterTakeFirst(cms_thread(thread)->results));
}
c_iterFree(cms_thread(thread)->results);
cms_thread(thread)->results = NULL;
}
}
if(cms_thread(thread)->terminate == FALSE){
cms_thread(thread)->ready = TRUE;
if(thread->client->service->configuration->verbosity >= 7){
OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' ready.", cms_thread(thread)->name);
}
os_condWait(&thread->condition, &thread->soapMutex);
if(thread->client->service->configuration->verbosity >= 7){
OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' condition triggered.", cms_thread(thread)->name);
}
}
}
os_mutexUnlock(&thread->soapMutex);
if(thread->client->service->configuration->verbosity >= 6){
OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' ends.", cms_thread(thread)->name);
}
return NULL;
}
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;
}
static c_iter
getKnownServices(cf_element root)
{
c_iter services;
cf_element domain;
cf_element el;
cf_element cmd;
cf_data data;
c_iter children;
cf_attribute attr;
struct serviceInfo *si;
assert(root);
services = NULL;
if (root
&& (domain = (cf_element)cf_elementChild(root, "Domain")) )
{
children = cf_elementGetChilds(domain);
while ( (el = c_iterTakeFirst(children)) != NULL)
{
if ( strcmp(cf_nodeGetName(cf_node(el)), "Service") == 0
&& (cmd = (cf_element)cf_elementChild(el, "Command"))
&& (data = cf_data(cf_elementChild(cmd, "#text")))
&& (si = os_malloc(sizeof(struct serviceInfo))))
{
si->command = cf_dataValue(data).is.String;
attr = cf_elementAttribute(el, "name");
if (attr)
{
si->name = cf_attributeValue(attr).is.String;
}
else
{
si->name = si->command;
}
if (!si->name || !si->command)
{
/* detected an invalid service configuration, report and skip */
fprintf(stderr,
"Warning: detected invalid 'Service'"
" element (name = %s; command = %s) -> skip\n",
(si->name?si->name:"<null>"),
(si->command?si->command:"<null>"));
os_free(si);
si = NULL;
}
else
{
services = c_iterInsert(services, si);
}
}
}
c_iterFree(children);
}
return services;
}
jni_topic
jni_lookupTopic(
jni_participant p,
const char* name)
{
c_iter topics;
jni_topic topic, temp;
int found;
topic = NULL;
if((name != NULL) && (p != NULL)){
topics = c_iterCopy(p->topics);
found = 0;
temp = jni_topic(c_iterTakeFirst(topics));
while( (temp != NULL) && (!found)){
if(strcmp(jni_topicDescription(temp)->name, name) == 0){
topic = temp;
found = 1;
}
temp = jni_topic(c_iterTakeFirst(topics));
}
c_iterFree(topics);
}
return topic;
}
cm_result
cmc_entitySetFree(
cmc_entitySet es)
{
cmc_entity e;
cm_result r;
r = CM_RESULT_OK;
if( (es == NULL) || (es->entities == NULL)){
r = CM_RESULT_BAD_PARAMETER;
} else {
e = cmc_entity(c_iterTakeFirst(es->entities));
while(e != NULL){
r = cmc_entityFree(e);
if(r == CM_RESULT_OK){
e = cmc_entity(c_iterTakeFirst(es->entities));
} else{
e = NULL;
}
}
c_iterFree(es->entities);
os_free(es);
}
return r;
}
static const char *
u_usrClockConfigElementDataString (
const cf_element element,
const char *defaultValue)
{
c_iter children;
const char *data = defaultValue;
c_value dataValue;
c_ulong i;
cf_node node;
assert(element != NULL);
children = cf_elementGetChilds (element);
if (children) {
for (i = 0; i < c_iterLength (children); i++) {
node = c_iterObject (children, i);
if (cf_nodeKind (node) == CF_DATA) {
dataValue = cf_dataValue (cf_data(node));
if (dataValue.kind == V_STRING) {
data = dataValue.is.String;
}
}
}
c_iterFree(children);
}
return data;
}
const c_char*
jni_nameServiceResolveURI(
c_long domainId)
{
const c_char* result;
c_iter copy;
jni_mapping mapping;
c_bool found;
result = NULL;
if(mappings != NULL){
copy = c_iterCopy(mappings);
found = FALSE;
mapping = jni_mapping(c_iterTakeFirst(copy));
while((mapping != NULL) && (found == FALSE)){
if(mapping->domainId == domainId){
result = mapping->uri;
found = TRUE;
}
mapping = jni_mapping(c_iterTakeFirst(copy));
}
c_iterFree(copy);
}
/* if not found or mapping == NULL then result == NULL */
return result;
}
jni_result
jni_nameServiceFree()
{
u_result r;
jni_mapping mapping;
r = U_RESULT_OK;
if(ns != NULL){
ns->refCount--;
if(ns->refCount == 0){
mapping = jni_mapping(c_iterTakeFirst(mappings));
while(mapping != NULL){
os_free(mapping->uri);
os_free(mapping);
mapping = jni_mapping(c_iterTakeFirst(mappings));
}
c_iterFree(mappings);
os_free(ns);
ns = NULL;
r = u_userDetach();
} else{
r = U_RESULT_OK;
}
} else{
r = U_RESULT_NOT_INITIALISED;
}
return jni_convertResult(r);
}
u_result
u_readerDeinit(
u_reader _this)
{
u_result result;
u_query query;
if (_this != NULL) {
result = u_dispatcherDeinit(u_dispatcher(_this));
if (result == U_RESULT_OK) {
os_mutexLock(&_this->mutex);
if (_this->queries) {
query = c_iterObject(_this->queries,0);
while (query) {
os_mutexUnlock(&_this->mutex);
result = u_queryFree(query);
os_mutexLock(&_this->mutex);
query = c_iterObject(_this->queries,0);
}
c_iterFree(_this->queries);
_this->queries = NULL;
}
os_mutexUnlock(&_this->mutex);
os_mutexDestroy(&_this->mutex);
}
} else {
result = U_RESULT_ILL_PARAM;
}
return result;
}
void
cmx_participantDomainsAction(
v_public p,
c_voidp args)
{
cmx_walkEntityArg arg;
c_iter partitions;
v_entity partition;
c_bool proceed;
c_char* xmlEntity;
arg = cmx_walkEntityArg(args);
partitions = v_resolvePartitions(v_objectKernel(p), "*");
partition = v_entity(c_iterTakeFirst(partitions));
while(partition != NULL){
proceed = cmx_entityNewFromWalk(v_public(partition), &arg->entityArg);
if(proceed == TRUE){
xmlEntity = arg->entityArg.result;
arg->list = c_iterInsert(arg->list, xmlEntity);
arg->length += strlen(xmlEntity);
}
c_free(partition);
partition = v_entity(c_iterTakeFirst(partitions));
}
c_iterFree(partitions);
}
void
cmx_readerSnapshotFree(
c_char* snapshot)
{
cmx_readerSnapshot s;
c_char* sample;
os_mutex m;
s = cmx_readerSnapshotLookup(snapshot);
if(s != NULL){
m = cmx_getReaderSnapshotMutex();
os_mutexLock(&m);
c_iterTake(readerSnapshots, s);
os_mutexUnlock(&m);
if(s->samples != NULL){
sample = (c_char*)(c_iterTakeFirst(s->samples));
while(sample != NULL){
os_free(sample);
sample = (c_char*)(c_iterTakeFirst(s->samples));
}
c_iterFree(s->samples);
}
os_free(s);
os_free(snapshot);
}
}
void
cmx_participantFindTopicAction(
v_public p,
c_voidp args)
{
cmx_walkEntityArg arg;
c_iter topics;
v_entity topic;
c_bool proceed;
c_char* xmlEntity;
arg = cmx_walkEntityArg(args);
topics = v_resolveTopics(v_objectKernel(p), cmx_walkParticipantArg(arg)->topicName);
topic = v_entity(c_iterTakeFirst(topics));
while(topic != NULL){
proceed = cmx_entityNewFromWalk(v_public(topic), &arg->entityArg);
if(proceed == TRUE){
xmlEntity = arg->entityArg.result;
arg->list = c_iterInsert(arg->list, xmlEntity);
arg->length += strlen(xmlEntity);
}
c_free(topic);
topic = v_entity(c_iterTakeFirst(topics));
}
c_iterFree(topics);
}
c_array
c_metaArray(
c_metaObject scope,
c_iter iter,
c_metaKind kind)
{
c_long i;
struct copyToArrayArg arg;
c_type type;
if (kind) {
/* suppress warnings */
}
i = c_iterLength(iter);
if (i == 0) {
arg.a = NULL;
} else {
type = c_object_t(c__getBase(scope));
arg.a = c_arrayNew(type,i);
arg.index = 0;
c_iterWalk(iter,copyToArray,&arg);
c_iterFree(iter);
c_free(type);
}
return arg.a;
}
gapi_dataWriter
gapi_publisher_lookup_datawriter (
gapi_publisher _this,
const gapi_char *topic_name)
{
_Publisher publisher;
u_writer found;
gapi_dataWriter handle = NULL;
c_iter iter;
if (topic_name) {
publisher = gapi_publisherClaim(_this, NULL);
if (publisher) {
iter = u_publisherLookupWriters(U_PUBLISHER_GET(publisher), topic_name);
if (iter) {
found = c_iterTakeFirst(iter);
if (found) {
handle = u_entityGetUserData(u_entity(found));
}
c_iterFree(iter);
}
_EntityRelease(publisher);
}
}
return handle;
}
static c_bool
v_partitionAdminRemoveExpression(
v_partitionAdmin da,
const char *partitionExpr)
{
c_bool result = FALSE;
v_partitionInterest partitionInterest, found;
q_expr expr;
c_collection q;
c_iter list;
c_value params[1];
assert(!v_partitionExpressionIsAbsolute(partitionExpr));
expr = (q_expr)q_parse("expression like %0");
params[0] = c_stringValue((char *)partitionExpr);
q = c_queryNew(da->partitionInterests, expr, params);
q_dispose(expr);
list = ospl_c_select(q,0);
assert(c_iterLength(list) <= 1);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
while (partitionInterest) {
result = TRUE;
found = c_tableRemove(da->partitionInterests, partitionInterest, NULL, NULL);
c_free(partitionInterest);
c_free(found);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
}
c_free(q);
c_iterFree(list);
return result;
}
gapi_returnCode_t
gapi_publisher_delete_contained_entities (
gapi_publisher _this)
{
_Publisher publisher;
_DataWriter dataWriter;
gapi_dataWriter handle;
gapi_returnCode_t result = GAPI_RETCODE_OK;
c_iter writers;
u_writer w;
void *userData;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher != NULL ) {
/* delete all datawriters in the datawriterSet */
writers = u_publisherLookupWriters(U_PUBLISHER_GET(publisher),NULL);
w = c_iterTakeFirst(writers);
while (w) {
handle = u_entityGetUserData(u_entity(w));
dataWriter = gapi_dataWriterClaimNB(handle,&result);
if (dataWriter) {
userData = _ObjectGetUserData(_Object(dataWriter));
_DataWriterFree(dataWriter);
}
w = c_iterTakeFirst(writers);
}
c_iterFree(writers);
_EntityRelease(publisher);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return result;
}
c_iter
c_bindAttributes(
c_metaObject scope,
c_iter declarations,
c_type type,
c_bool isReadOnly)
{
c_iter attributes;
c_declarator d;
c_metaObject o;
if (isReadOnly) {
/* suppress warnings */
}
attributes = NULL;
d = (c_declarator)c_iterTakeFirst(declarations);
while (d != NULL) {
o = c_metaDefine(scope,M_ATTRIBUTE);
c_property(o)->type = c_declaratorType(d,type);
c_metaFinalize(o);
c_metaBind(scope,d->name,o);
attributes = c_iterInsert(attributes,o);
os_free(d);
d = (c_declarator)c_iterTakeFirst(declarations);
}
c_iterFree(declarations);
return attributes;
}
c_iter
u_cfElementGetAttributes(
u_cfElement element)
{
u_result r;
v_cfElement ke;
v_cfAttribute attr;
c_iter ka;
c_iter attributes;
u_participant p;
attributes = c_iterNew(NULL);
if (element != NULL) {
r = u_cfNodeReadClaim(u_cfNode(element), (v_cfNode*)(&ke));
if (r == U_RESULT_OK) {
p = u_cfNodeParticipant(u_cfNode(element));
ka = v_cfElementGetAttributes(ke);
attr = c_iterTakeFirst(ka);
while (attr != NULL) {
c_iterInsert(attributes, u_cfAttributeNew(p, attr));
attr = c_iterTakeFirst(ka);
}
c_iterFree(ka);
u_cfNodeRelease(u_cfNode(element));
}
}
return attributes;
}
