C++ (Cpp) d_nameSpace Examples

Example #1

File: d_nameSpacesListener.c Project: xrl/opensplice_dds

static void
checkFellowMasterWalk(
    void* o,
    c_voidp userData)
{
    struct checkFellowMasterHelper* helper;
    d_networkAddress master;
    d_nameSpace nameSpace;

    helper = (struct checkFellowMasterHelper*)userData;
    nameSpace = d_nameSpace(o);
    master = d_nameSpaceGetMaster (nameSpace);

    if (d_nameSpaceIsMasterConfirmed (nameSpace)) {
        if (!d_networkAddressCompare (helper->fellow, master)) {
            d_adminReportMaster (helper->admin, nameSpace, helper->oldNameSpace);
        }
    }

    d_networkAddressFree (master);
}

Example #2

File: d_nameSpacesListener.c Project: diorahman/opensplice

static void
checkFellowMasterWalk(
    void* o,
    c_voidp userData)
{
    struct checkFellowMasterHelper* helper;
    d_networkAddress master, fellow;
    d_nameSpace nameSpace;

    helper = (struct checkFellowMasterHelper*)userData;
    nameSpace = d_nameSpace(o);
    master = d_nameSpaceGetMaster (nameSpace);
    fellow = d_fellowGetAddress(helper->fellow);

    if (!d_networkAddressCompare (fellow, master)) {
        d_adminReportMaster (helper->admin, helper->fellow, nameSpace, helper->oldNameSpace);
    }

    d_networkAddressFree(master);
    d_networkAddressFree(fellow);
}

Example #3

File: d_nameSpacesListener.c Project: S73417H/opensplice

static void
checkFellowDelayAlignmentWalk(
    void* o,
    c_voidp userData)
{
    d_admin admin;
    d_nameSpace nameSpace;
    d_fellow fellow;
    d_quality q;
    struct checkDelayAlignmentHelper* data;

    data = (struct checkDelayAlignmentHelper*)userData;
    nameSpace = d_nameSpace(o);
    admin = data->admin;
    fellow = data->fellow;

    /* Get quality of fellow namespace */
    q = d_nameSpaceGetInitialQuality(nameSpace);

    /* Report potential delayed initial dataset if quality is non-zero and not infinite */
    if((q.seconds || q.nanoseconds) && ((q.seconds != C_TIME_INFINITE.seconds) && (q.nanoseconds != C_TIME_INFINITE.nanoseconds))) {
        d_adminReportDelayedInitialSet(admin, nameSpace, fellow);
    }
}

Example #4

File: d_nameSpacesListener.c Project: S73417H/opensplice

static void
checkFellowMasterWalk(
    void* o,
    c_voidp userData)
{
    struct checkFellowMasterHelper* helper;
    d_networkAddress master, fellow;
    d_nameSpace nameSpace;

    helper = (struct checkFellowMasterHelper*)userData;
    nameSpace = d_nameSpace(o);                     /* the namespace of the fellow */
    master = d_nameSpaceGetMaster (nameSpace);      /* the master of the namespace of the fellow */
    fellow = d_fellowGetAddress(helper->fellow);    

    /* Only start checking for conflicts if the fellow is a master
     * for the namespace and the namespace is confirmed
     */
    if (!d_networkAddressCompare (fellow, master) && d_nameSpaceIsMasterConfirmed(nameSpace)) {
        d_adminReportMaster (helper->admin, helper->fellow, nameSpace, helper->oldNameSpace);
    }

    d_networkAddressFree(master);
    d_networkAddressFree(fellow);
}

Example #5

File: d_subscriber.c Project: S73417H/opensplice

static c_char*
getPersistentPartitionExpression(
    d_admin admin,
    d_durability durability)
{
    c_char *result, *expr;
    d_nameSpace ns;
    d_durabilityKind dkind;
    c_ulong length;
    c_long i, j;
    c_iter nameSpaces;

    result = NULL;

    assert (admin);

    /* Collect namespaces */
    nameSpaces = d_adminNameSpaceCollect(admin);

    if(admin){
        length = 0;
        j = 0;

        for(i=0; i<c_iterLength(nameSpaces); i++){
            ns    = d_nameSpace(c_iterObject(nameSpaces, i));
            dkind = d_nameSpaceGetDurabilityKind(ns);

            if((dkind == D_DURABILITY_PERSISTENT) || (dkind == D_DURABILITY_ALL)){
                expr = d_nameSpaceGetPartitions(ns);
                if(j==0){
                    length += strlen(expr);
                } else {
                    length += strlen(expr) + 1; /*for the comma*/
                }
                os_free(expr);
                j++;
            }
        }

        if(length > 0){
            result = (c_char*)(os_malloc(length + 1));
            result[0] = '\0';
            j = 0;

            for(i=0; i<c_iterLength(nameSpaces); i++){
                ns    = d_nameSpace(c_iterObject(nameSpaces, i));
                dkind = d_nameSpaceGetDurabilityKind(ns);

                if((dkind == D_DURABILITY_PERSISTENT) || (dkind == D_DURABILITY_ALL)){
                    expr = d_nameSpaceGetPartitions(ns);

                    if(j != 0){
                        os_strcat(result, ",");
                    }
                    os_strcat(result, expr);
                    os_free(expr);
                    j++;
                }
            }
        }

        d_adminNameSpaceCollectFree(admin, nameSpaces);
    }

    if(result){
        d_printTimedEvent(durability, D_LEVEL_FINE,
            D_THREAD_PERISTENT_DATA_LISTENER,
            "Persistent partition expression is: '%s'\n", result);
    } else {
        d_printTimedEvent(durability, D_LEVEL_FINE,
            D_THREAD_PERISTENT_DATA_LISTENER,
            "Persistent partition expression is empty.\n");
    }
    return result;
}