static void
userDataQosPolicyCopyout (
const struct v_userDataPolicy *src,
gapi_userDataQosPolicy *dst)
{
unsigned long len = c_arraySize(src->value);
if ( dst->value._maximum > 0 ) {
if ( len != dst->value._maximum ) {
if ( dst->value._release ) {
gapi_free(dst->value._buffer);
}
dst->value._maximum = 0;
dst->value._length = 0;
dst->value._buffer = NULL;
}
}
if ( len > 0 ) {
if ( dst->value._length == 0 ) {
if ( dst->value._maximum == 0 ) {
dst->value._buffer = gapi_octetSeq_allocbuf(len) ;
dst->value._maximum = len;
dst->value._length = 0;
dst->value._release = TRUE;
}
if ( dst->value._maximum >= len ) {
memcpy(dst->value._buffer, src->value, len);
}
}
}
dst->value._length = len;
}
static gapi_boolean
copySubscriberQosOut (
const v_subscriberQos srcQos,
gapi_subscriberQos *dstQos)
{
assert(srcQos);
assert(dstQos);
if ( dstQos->group_data.value._maximum > 0 ) {
if ( dstQos->group_data.value._release ) {
gapi_free(dstQos->group_data.value._buffer);
}
}
if ( (srcQos->groupData.size > 0) && srcQos->groupData.value ) {
dstQos->group_data.value._buffer = gapi_octetSeq_allocbuf(srcQos->groupData.size);
if ( dstQos->group_data.value._buffer ) {
dstQos->group_data.value._maximum = srcQos->groupData.size;
dstQos->group_data.value._length = srcQos->groupData.size;
dstQos->group_data.value._release = TRUE;
memcpy(dstQos->group_data.value._buffer,
srcQos->groupData.value,
srcQos->groupData.size);
}
} else {
dstQos->group_data.value._maximum = 0;
dstQos->group_data.value._length = 0;
dstQos->group_data.value._release = FALSE;
dstQos->group_data.value._buffer = NULL;
}
gapi_string_to_StringSeq(srcQos->partition,",",&dstQos->partition.name);
dstQos->presentation.access_scope =
srcQos->presentation.access_scope;
dstQos->presentation.coherent_access =
srcQos->presentation.coherent_access;
dstQos->presentation.ordered_access =
srcQos->presentation.ordered_access;
dstQos->entity_factory.autoenable_created_entities =
srcQos->entityFactory.autoenable_created_entities;
if ( srcQos->share.enable ) {
dstQos->share.enable = TRUE;
dstQos->share.name = gapi_strdup(srcQos->share.name);
} else {
dstQos->share.enable = FALSE;
dstQos->share.name = NULL;
}
return TRUE;
}
saj_returnCode saj_octetSequenceCopyIn(
JNIEnv *env,
jbyteArray jArray,
gapi_octetSeq *out)
{
jsize arrayLength;
jbyte *vmManagedByteArray;
saj_returnCode rc;
assert(out != NULL);
rc = SAJ_RETCODE_OK;
if (jArray != NULL)
{
arrayLength = (*env)->GetArrayLength(env, jArray);
saj_exceptionCheck(env);
out->_maximum = arrayLength;
out->_length = arrayLength;
/* allocate a buffer of the right size */
out->_buffer = gapi_octetSeq_allocbuf(arrayLength);
out->_release = FALSE;
vmManagedByteArray =
(*env)->GetPrimitiveArrayCritical(env, jArray, NULL);
if(vmManagedByteArray != NULL){
memcpy(out->_buffer, vmManagedByteArray, arrayLength);
/* don't copy the content of vmManagedByteArray to jArray */
(*env)->ReleasePrimitiveArrayCritical(
env, jArray, vmManagedByteArray, JNI_ABORT);
saj_exceptionCheck(env);
}
else
{
rc = SAJ_RETCODE_ERROR;
}
}
return rc;
}
void DDS::ccpp_AllocateGapiSeq(gapi_octet* *buffer, gapi_unsigned_long len)
{
*buffer = gapi_octetSeq_allocbuf(len);
}
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;
}
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;
}
