C++ (Cpp) kernelCopyOutDuration Examples

Example #1

File: gapi_dataWriter.c Project: AmitShah/opensplice

static gapi_boolean
copyWriterQosOut (
    const v_writerQos  srcQos,
    gapi_dataWriterQos *dstQos)
{
    assert(srcQos);
    assert(dstQos);

    kernelCopyOutDuration(&srcQos->deadline.period, &dstQos->deadline.period);
    dstQos->durability.kind = srcQos->durability.kind;

    dstQos->history.kind = srcQos->history.kind;
    dstQos->history.depth = srcQos->history.depth;
    kernelCopyOutDuration(&srcQos->latency.duration,
                          &dstQos->latency_budget.duration);
    kernelCopyOutDuration(&srcQos->lifespan.duration,
                          &dstQos->lifespan.duration);
    dstQos->liveliness.kind = srcQos->liveliness.kind;
    kernelCopyOutDuration(&srcQos->liveliness.lease_duration,
                          &dstQos->liveliness.lease_duration);
    dstQos->destination_order.kind = srcQos->orderby.kind;
    dstQos->reliability.kind = srcQos->reliability.kind;
    kernelCopyOutDuration(&srcQos->reliability.max_blocking_time,
                          &dstQos->reliability.max_blocking_time);
    dstQos->reliability.synchronous = srcQos->reliability.synchronous;
    dstQos->resource_limits.max_samples = srcQos->resource.max_samples;
    dstQos->resource_limits.max_instances = srcQos->resource.max_instances;
    dstQos->resource_limits.max_samples_per_instance = srcQos->resource.max_samples_per_instance;
    dstQos->transport_priority.value = srcQos->transport.value;
    dstQos->ownership.kind = srcQos->ownership.kind;
    dstQos->ownership_strength.value = srcQos->strength.value;
    dstQos->writer_data_lifecycle.autodispose_unregistered_instances = srcQos->lifecycle.autodispose_unregistered_instances;
    kernelCopyOutDuration(&srcQos->lifecycle.autopurge_suspended_samples_delay,
                          &dstQos->writer_data_lifecycle.autopurge_suspended_samples_delay);
    kernelCopyOutDuration(&srcQos->lifecycle.autounregister_instance_delay,
                          &dstQos->writer_data_lifecycle.autounregister_instance_delay);

    if ( dstQos->user_data.value._maximum > 0 ) {
        if ( dstQos->user_data.value._release ) {
            gapi_free(dstQos->user_data.value._buffer);
        }
    }

    if ( (srcQos->userData.size > 0) && srcQos->userData.value ) {
        dstQos->user_data.value._buffer = gapi_octetSeq_allocbuf(srcQos->userData.size);
        if ( dstQos->user_data.value._buffer ) {
            dstQos->user_data.value._maximum = srcQos->userData.size;
            dstQos->user_data.value._length  = srcQos->userData.size;
            dstQos->user_data.value._release = TRUE;
            memcpy(dstQos->user_data.value._buffer,
                   srcQos->userData.value,
                   srcQos->userData.size);
        }
    } else {
            dstQos->user_data.value._maximum = 0;
            dstQos->user_data.value._length  = 0;
            dstQos->user_data.value._release = FALSE;
            dstQos->user_data.value._buffer = NULL;
    }

    return TRUE;
}

Example #2

File: gapi_kernel.c Project: diorahman/opensplice

gapi_boolean
gapi_kernelReaderQosCopyOut (
    const v_readerQos   srcQos,
    gapi_dataReaderQos *dstQos)
{
    gapi_boolean copied = TRUE;

    if ( dstQos->user_data.value._maximum > 0 ) {
        if ( dstQos->user_data.value._release ) {
            gapi_free(dstQos->user_data.value._buffer);
        }
    }

    if ( (srcQos->userData.size > 0) && srcQos->userData.value ) {
        dstQos->user_data.value._buffer = gapi_octetSeq_allocbuf(srcQos->userData.size);
        if ( dstQos->user_data.value._buffer ) {
            dstQos->user_data.value._maximum = srcQos->userData.size;
            dstQos->user_data.value._length  = srcQos->userData.size;
            dstQos->user_data.value._release = TRUE;
            memcpy(dstQos->user_data.value._buffer, srcQos->userData.value, srcQos->userData.size);
        } else {
            copied = FALSE;
        }
    } else {
            dstQos->user_data.value._maximum = 0;
            dstQos->user_data.value._length  = 0;
            dstQos->user_data.value._release = FALSE;
            dstQos->user_data.value._buffer = NULL;
    }

    if ( copied ) {
        dstQos->durability.kind = srcQos->durability.kind;
        kernelCopyOutDuration(&srcQos->deadline.period, &dstQos->deadline.period);
        kernelCopyOutDuration(&srcQos->latency.duration, &dstQos->latency_budget.duration);
        dstQos->liveliness.kind = srcQos->liveliness.kind;
        kernelCopyOutDuration(&srcQos->liveliness.lease_duration, &dstQos->liveliness.lease_duration);
        dstQos->reliability.kind = srcQos->reliability.kind;
        kernelCopyOutDuration(&srcQos->reliability.max_blocking_time, &dstQos->reliability.max_blocking_time);
        dstQos->reliability.synchronous = srcQos->reliability.synchronous;
        dstQos->destination_order.kind = srcQos->orderby.kind;
        dstQos->history.kind  = srcQos->history.kind;
        dstQos->history.depth = srcQos->history.depth;
        dstQos->resource_limits.max_samples              = srcQos->resource.max_samples;
        dstQos->resource_limits.max_instances            = srcQos->resource.max_instances;
        dstQos->resource_limits.max_samples_per_instance = srcQos->resource.max_samples_per_instance;
        dstQos->ownership.kind = srcQos->ownership.kind;
        kernelCopyOutDuration(&srcQos->pacing.minSeperation, &dstQos->time_based_filter.minimum_separation);
        kernelCopyOutDuration(&srcQos->lifecycle.autopurge_nowriter_samples_delay,
                              &dstQos->reader_data_lifecycle.autopurge_nowriter_samples_delay);
        kernelCopyOutDuration(&srcQos->lifecycle.autopurge_disposed_samples_delay,
                              &dstQos->reader_data_lifecycle.autopurge_disposed_samples_delay);
        dstQos->reader_data_lifecycle.enable_invalid_samples = srcQos->lifecycle.enable_invalid_samples;

        dstQos->reader_lifespan.use_lifespan = srcQos->lifespan.used;
        kernelCopyOutDuration(&srcQos->lifespan.duration, &dstQos->reader_lifespan.duration);


        dstQos->share.enable = srcQos->share.enable;
        if ( srcQos->share.enable ) {
            assert(srcQos->share.name);
            dstQos->share.name = gapi_string_dup(srcQos->share.name);
        } else {
            dstQos->share.name = NULL;
        }

        dstQos->subscription_keys.use_key_list = srcQos->userKey.enable;
        if ( srcQos->userKey.enable ) {
            if ( !gapi_string_to_StringSeq(srcQos->userKey.expression, ",", &dstQos->subscription_keys.key_list) ) {
                copied = FALSE;
            }
        } else {
            gapi_stringSeq_set_length(&dstQos->subscription_keys.key_list, 0UL);
        }
    }

    return copied;
}