C++ (Cpp) d_waitsetFree Examples

Example #1

File: d_waitset.c Project: xrl/opensplice_dds

d_waitset
d_waitsetNew(
    d_subscriber subscriber,
    c_bool runToCompletion,
    c_bool timedWait)
{
    d_durability durability;
    d_admin admin;
    u_participant uparticipant;
    os_threadAttr attr;
    os_result osr;
    c_ulong mask;

    d_waitset waitset = NULL;

    assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE);

    if(subscriber){
        waitset = d_waitset(os_malloc(C_SIZEOF(d_waitset)));

        if(waitset) {
            d_lockInit(d_lock(waitset), D_WAITSET, d_waitsetDeinit);
            admin                    = d_subscriberGetAdmin(subscriber);
            durability               = d_adminGetDurability(admin);
            uparticipant             = u_participant(d_durabilityGetService(durability));
            waitset->terminate       = FALSE;
            waitset->subscriber      = subscriber;
            waitset->entities        = c_iterNew(NULL);
            waitset->runToCompletion = runToCompletion;
            waitset->timedWait       = timedWait;

            if(runToCompletion == TRUE){
                waitset->uwaitset   = u_waitsetNew(uparticipant);
                mask = V_EVENT_DATA_AVAILABLE;
                mask |= V_EVENT_NEW_GROUP;
                mask |= V_EVENT_HISTORY_DELETE;
                mask |= V_EVENT_HISTORY_REQUEST;
                mask |= V_EVENT_PERSISTENT_SNAPSHOT;
                mask |= V_EVENT_TRIGGER;
                u_waitsetSetEventMask(waitset->uwaitset, mask);

                osr = os_threadAttrInit(&attr);

                if(osr == os_resultSuccess) {
                    osr = os_threadCreate(&waitset->thread, "waitsetThread", &attr,
                                d_waitsetEventHandlerRunToCompletion, waitset);
                }

                if(osr != os_resultSuccess) {
                    d_waitsetFree(waitset);
                }
                waitset->threads = NULL;
            } else {
                waitset->threads = c_iterNew(NULL);
                waitset->uwaitset = NULL;
                waitset->thread = OS_THREAD_ID_NONE;
            }
        }
    }
    return waitset;
}

Example #2

File: d_subscriber.c Project: S73417H/opensplice

void
d_subscriberDeinit(
    d_object object)
{
    d_subscriber subscriber;
    d_durability durability;

    assert(d_objectIsValid(object, D_SUBSCRIBER) == TRUE);

    if(object){
        subscriber = d_subscriber(object);
        durability = d_adminGetDurability(subscriber->admin);

        if(subscriber->statusListener){
            d_statusListenerFree(subscriber->statusListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "statusListener freed\n");
            subscriber->statusListener = NULL;
        }
        if(subscriber->groupLocalListener){
            if(subscriber->sampleChainListener){
                d_sampleChainListenerStop(subscriber->sampleChainListener);
            }
            d_groupLocalListenerFree(subscriber->groupLocalListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupLocalListener freed\n");
            subscriber->groupLocalListener = NULL;
        }
        if(subscriber->groupRemoteListener){
            d_groupRemoteListenerFree(subscriber->groupRemoteListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupRemoteListener freed\n");
            subscriber->groupRemoteListener = NULL;
        }
        if(subscriber->groupsRequestListener){
            d_groupsRequestListenerFree(subscriber->groupsRequestListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupsRequestListener freed\n");
            subscriber->groupsRequestListener = NULL;
        }
       if(subscriber->sampleRequestListener){
            d_sampleRequestListenerFree(subscriber->sampleRequestListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "sampleRequestListener freed\n");
            subscriber->sampleRequestListener = NULL;
        }
        if(subscriber->sampleChainListener){
            d_sampleChainListenerFree(subscriber->sampleChainListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "sampleChainListener freed\n");
            subscriber->sampleChainListener = NULL;
        }
        if(subscriber->nameSpacesRequestListener){
            d_nameSpacesRequestListenerFree(subscriber->nameSpacesRequestListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "nameSpacesRequestListener freed\n");
            subscriber->nameSpacesRequestListener = NULL;
        }
        if(subscriber->nameSpacesListener){
            d_nameSpacesListenerFree(subscriber->nameSpacesListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "nameSpacesListener freed\n");
            subscriber->nameSpacesListener = NULL;
        }
        if(subscriber->deleteDataListener){
            d_deleteDataListenerFree(subscriber->deleteDataListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "deleteDataListener freed\n");
            subscriber->deleteDataListener = NULL;
        }
        if(subscriber->persistentDataListener){
            d_persistentDataListenerFree(subscriber->persistentDataListener);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "persistentDataListener freed\n");
            subscriber->persistentDataListener = NULL;
        }
        if(subscriber->persistentStore){
            d_storeClose(subscriber->persistentStore);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "persistent store closed\n");
            subscriber->persistentStore = NULL;
        }
        if(subscriber->waitset) {
            d_waitsetFree(subscriber->waitset);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "waitset freed\n");
            subscriber->waitset = NULL;
        }
        if(subscriber->persistentSubscriber){
            u_subscriberFree(subscriber->persistentSubscriber);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "user persistent subscriber freed\n");
            subscriber->persistentSubscriber = NULL;
        }
        if(subscriber->subscriber){
            u_subscriberFree(subscriber->subscriber);
            d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "user subscriber freed\n");
            subscriber->subscriber = NULL;
        }
    }
}