void
d_statusListenerInit(
d_statusListener listener,
d_subscriber subscriber)
{
d_admin admin;
d_durability durability;
d_configuration config;
admin = d_subscriberGetAdmin(subscriber);
durability = d_adminGetDurability(admin);
config = d_durabilityGetConfiguration(durability);
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
assert(d_objectIsValid(d_object(admin), D_ADMIN) == TRUE);
assert(d_objectIsValid(d_object(durability), D_DURABILITY) == TRUE);
assert(d_objectIsValid(d_object(config), D_CONFIGURATION) == TRUE);
d_readerListenerInit( d_readerListener(listener),
d_statusListenerAction, subscriber,
D_STATUS_TOPIC_NAME, D_STATUS_TOP_NAME,
V_RELIABILITY_RELIABLE,
V_HISTORY_KEEPLAST,
1, config->heartbeatScheduling,
d_statusListenerDeinit);
listener->cleanupAction = NULL;
}
c_bool
d_readerRequestRemoveChain(
d_readerRequest request,
d_chain chain)
{
d_chain found;
c_bool result;
assert(d_objectIsValid(d_object(request), D_READER_REQUEST) == TRUE);
assert(d_objectIsValid(d_object(chain), D_CHAIN) == TRUE);
if(request && chain){
d_lockLock(d_lock(request));
found = d_tableRemove(request->requests, chain);
d_lockUnlock(d_lock(request));
if(found){
result = TRUE;
d_chainFree(found);
} else {
result = FALSE;
}
} else {
result = FALSE;
}
return result;
}
c_bool
d_waitsetDetach(
d_waitset waitset,
d_waitsetEntity we)
{
u_result ur;
c_bool result = FALSE;
int i;
d_waitsetHelper helper;
helper = NULL;
assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);
if(waitset && we){
d_lockLock(d_lock(waitset));
if(c_iterContains(waitset->entities, we) == TRUE) {
if(waitset->runToCompletion == TRUE){
ur = u_waitsetDetach(waitset->uwaitset, u_entity(we->dispatcher));
} else {
for(i=0; i<c_iterLength(waitset->threads) && !helper; i++){
helper = d_waitsetHelper(c_iterObject(waitset->threads, i));
if(helper->entity != we){
helper = NULL;
}
}
assert(helper);
c_iterTake(waitset->threads, helper);
helper->terminate = TRUE;
u_waitsetNotify(helper->userWaitset, NULL);
os_threadWaitExit(helper->tid, NULL);
ur = u_waitsetDetach(helper->userWaitset, u_entity(we->dispatcher));
u_waitsetFree(helper->userWaitset);
os_free(helper);
}
if(ur == U_RESULT_OK) {
c_iterTake(waitset->entities, we);
we->waitset = NULL;
result = TRUE;
}
}
d_lockUnlock(d_lock(waitset));
}
return result;
}
c_bool
d_readerRequestAddGroup(
d_readerRequest request,
d_group group)
{
c_bool result;
d_group found;
assert(d_objectIsValid(d_object(request), D_READER_REQUEST) == TRUE);
if(request){
d_lockLock(d_lock(request));
found = d_tableInsert(request->groups, group);
d_lockUnlock(d_lock(request));
if(!found){
d_objectKeep(d_object(group));
result = TRUE;
} else {
result = FALSE;
}
} else {
result = FALSE;
}
return result;
}
void
d_objectFree(
d_object object,
d_kind kind)
{
os_uint32 refCount;
OS_UNUSED_ARG(kind);
assert(d_objectIsValid(object, kind) == TRUE);
if(object){
assert(object->confidence == D_CONFIDENCE);
assert(object->kind == kind);
assert(object->refCount >= 1);
refCount = pa_decrement(&(object->refCount));
if(refCount == 0){
if(object->deinit){
object->deinit(object);
}
object->confidence = D_CONFIDENCE_NULL;
object->kind = D_BAD_TYPE;
os_free(object);
assert(doSub(kind));
}
#if CHECK_REF
if (kind == CHECK_REF_TYPE) {
UT_TRACE("\n\n============ Free(%p): %d -> %d =============\n",
(void*)object, refCount+1, refCount);
}
#endif
}
}
u_subscriber
d_subscriberGetPersistentSubscriber(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
return subscriber->persistentSubscriber;
}
d_waitset
d_subscriberGetWaitset(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
return subscriber->waitset;
}
d_admin
d_subscriberGetAdmin(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
return subscriber->admin;
}
void
d_readerListenerInitDataReader(
d_readerListener listener,
d_subscriber subscriber,
const c_char* name,
v_reliabilityKind reliability,
v_historyQosKind historyKind,
c_long historyDepth)
{
v_readerQos readerQos;
u_subscriber s;
d_networkAddress unaddressed, myAddr;
d_admin admin;
c_char *query;
q_expr expr;
assert(d_objectIsValid(d_object(listener), D_LISTENER));
if(listener && subscriber){
readerQos = d_readerQosNew(V_DURABILITY_VOLATILE, reliability);
readerQos->history.kind = historyKind;
readerQos->history.depth = historyDepth;
readerQos->lifecycle.autopurge_nowriter_samples_delay.seconds = 60;
readerQos->lifecycle.autopurge_nowriter_samples_delay.nanoseconds = 0;
readerQos->lifecycle.autopurge_disposed_samples_delay.seconds = 10;
readerQos->lifecycle.autopurge_disposed_samples_delay.nanoseconds = 0;
s = d_subscriberGetSubscriber(subscriber);
admin = d_subscriberGetAdmin(subscriber);
myAddr = d_adminGetMyAddress(admin);
unaddressed = d_networkAddressUnaddressed();
/*
* Message is:
* - meant for me or
* - meant for all and not sent by me
*/
#define FILTER_EXPRESSION "select * from %s where " \
"parentMsg.addressee.systemId=%u OR " \
"parentMsg.addressee.systemId=%u AND " \
"parentMsg.senderAddress.systemId!=%u"
query = (c_char*)(os_malloc(strlen(listener->name) +
strlen(FILTER_EXPRESSION) + 32));
os_sprintf(query, FILTER_EXPRESSION, listener->name,
myAddr->systemId, unaddressed->systemId, myAddr->systemId);
expr = q_parse(query);
listener->dataReader =
u_dataReaderNew (s, name, expr, NULL, readerQos, TRUE);
q_dispose(expr);
os_free(query);
#undef FILTER_EXPRESSION
d_networkAddressFree(myAddr);
d_networkAddressFree(unaddressed);
d_readerQosFree(readerQos);
}
}
void
d_readerRequestDeinit(
d_object object)
{
d_readerRequest request;
c_ulong i;
assert(d_objectIsValid(object, D_READER_REQUEST) == TRUE);
if(object){
request = d_readerRequest(object);
if(request->requests){
d_tableFree(request->requests);
request->requests = NULL;
}
if(request->filter){
os_free(request->filter);
request->filter = NULL;
}
for(i=0; i<request->filterParamsCount; i++){
os_free(request->filterParams[i]);
}
if(request->filterParams){
os_free(request->filterParams);
request->filterParams = NULL;
}
if(request->groups){
d_tableFree(request->groups);
request->groups = NULL;
}
}
return;
}
void
d_eventListenerDeinit(
d_object object)
{
assert(d_objectIsValid(object, D_EVENT_LISTENER) == TRUE);
return;
}
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));
}
}
void
d_subscriberFree(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(subscriber){
d_objectFree(d_object(subscriber), D_SUBSCRIBER);
}
}
void
d_waitsetEntityFree(
d_waitsetEntity we)
{
assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);
if(we) {
d_objectFree(d_object(we), D_WAITSET_ENTITY);
}
}
void
d_readerListenerFree(
d_readerListener listener)
{
assert(d_objectIsValid(d_object(listener), D_LISTENER));
if(listener){
d_listenerFree(d_listener(listener));
}
}
void
d_eventListenerFree(
d_eventListener listener)
{
assert(d_objectIsValid(d_object(listener), D_EVENT_LISTENER) == TRUE);
if(listener) {
d_objectFree(d_object(listener), D_EVENT_LISTENER);
}
}
void
d_waitsetFree(
d_waitset waitset)
{
assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
if(waitset){
d_lockFree(d_lock(waitset), D_WAITSET);
}
}
void
d_publisherFree(
d_publisher publisher)
{
assert(d_objectIsValid(d_object(publisher), D_PUBLISHER) == TRUE);
if(publisher){
d_objectFree(d_object(publisher), D_PUBLISHER);
}
}
void
d_subscriberInitGroupsRequestListener(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(!subscriber->groupsRequestListener){
subscriber->groupsRequestListener = d_groupsRequestListenerNew(subscriber);
assert(subscriber->groupsRequestListener);
}
}
void
d_subscriberInitSampleChainListener(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(!subscriber->sampleChainListener){
subscriber->sampleChainListener = d_sampleChainListenerNew(subscriber);
assert(subscriber->sampleChainListener);
}
}
void
d_subscriberInitNameSpacesListener(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(!subscriber->nameSpacesListener){
subscriber->nameSpacesListener = d_nameSpacesListenerNew(subscriber);
assert(subscriber->nameSpacesListener);
}
}
void
d_subscriberInitDeleteDataListener(
d_subscriber subscriber)
{
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(!subscriber->deleteDataListener){
subscriber->deleteDataListener = d_deleteDataListenerNew(subscriber);
assert(subscriber->deleteDataListener);
}
}
void
d_lockFree(
d_lock lock,
d_kind kind)
{
assert(d_objectIsValid(d_object(lock), kind) == TRUE);
if(lock){
d_objectFree(d_object(lock), kind);
}
}
void
d_readerRequestFree(
d_readerRequest request)
{
assert(d_objectIsValid(d_object(request), D_READER_REQUEST) == TRUE);
if(request){
d_lockFree(d_lock(request), D_READER_REQUEST);
}
return;
}
void
d_groupCreationQueueFree(
d_groupCreationQueue queue)
{
assert(d_objectIsValid(d_object(queue), D_GROUP_CREATION_QUEUE) == TRUE);
if(queue) {
d_lockFree(d_lock(queue), D_GROUP_CREATION_QUEUE);
}
return;
}
d_subscriber
d_waitsetGetSubscriber(
d_waitset waitset)
{
d_subscriber subscriber = NULL;
assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
if(waitset) {
subscriber = waitset->subscriber;
}
return subscriber;
}
c_voidp
d_eventListenerGetUserData(
d_eventListener listener)
{
c_voidp userData = NULL;
assert(d_objectIsValid(d_object(listener), D_EVENT_LISTENER) == TRUE);
if(listener) {
userData = listener->args;
}
return userData;
}
d_groupLocalListener
d_subscriberGetGroupLocalListener(
d_subscriber subscriber)
{
d_groupLocalListener listener = NULL;
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(subscriber){
listener = subscriber->groupLocalListener;
}
return listener;
}
d_sampleChainListener
d_subscriberGetSampleChainListener(
d_subscriber subscriber)
{
d_sampleChainListener listener = NULL;
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(subscriber){
listener = subscriber->sampleChainListener;
}
return listener;
}
d_nameSpacesRequestListener
d_subscriberGetNameSpacesRequestListener(
d_subscriber subscriber)
{
d_nameSpacesRequestListener listener = NULL;
assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);
if(subscriber){
listener = subscriber->nameSpacesRequestListener;
}
return listener;
}
