v_result v_participantCandMCommandSetDisposeAllData(v_participant participant,
v_message msg,
char *topicExpr,
char *partitionExpr)
{
v_kernel kernel;
v_topic topic;
c_base base;
v_controlAndMonitoringCommand *command;
struct v_commandDisposeAllData *disposeCmd;
assert(participant != NULL);
assert(C_TYPECHECK(participant,v_participant));
assert(msg != NULL );
assert(C_TYPECHECK(msg,v_message));
kernel = v_objectKernel(participant);
topic = v_builtinTopicLookup(kernel->builtin, V_C_AND_M_COMMAND_ID);
command = v_builtinControlAndMonitoringCommandData(kernel->builtin, msg);
command->u._d = V_COMMAND_DISPOSE_ALL_DATA;
base = c_getBase(c_object(topic));
disposeCmd = &command->u._u.dispose_all_data_info;
disposeCmd->topicExpr = c_stringNew(base, topicExpr);
disposeCmd->partitionExpr = c_stringNew(base, partitionExpr);
return ( ( disposeCmd->topicExpr != NULL
&& disposeCmd->partitionExpr != NULL )
? V_RESULT_OK
: V_RESULT_OUT_OF_MEMORY );
}
c_bool
__rcl_interfaces_msg_dds__Parameter___copyIn(
c_base base,
struct ::rcl_interfaces::msg::dds_::Parameter_ *from,
struct _rcl_interfaces_msg_dds__Parameter_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
#ifdef OSPL_BOUNDS_CHECK
if(from->name_){
to->name_ = c_stringNew(base, from->name_);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'rcl_interfaces::msg::dds_::Parameter_.name_' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->name_ = c_stringNew(base, from->name_);
#endif
if(result){
extern c_bool __rcl_interfaces_msg_dds__ParameterValue___copyIn(c_base, ::rcl_interfaces::msg::dds_::ParameterValue_ *, _rcl_interfaces_msg_dds__ParameterValue_ *);
result = __rcl_interfaces_msg_dds__ParameterValue___copyIn(base, &from->value_, &to->value_);
}
return result;
}
v_persistentSnapshotRequest
v_persistentSnapshotRequestNew(
v_kernel kernel,
const c_char* partition_expression,
const c_char* topic_expression,
const c_char* uri)
{
v_persistentSnapshotRequest request;
c_base base;
request = c_new(v_kernelType(kernel,K_PERSISTENTSNAPSHOTREQUEST));
if(request)
{
base = c_getBase(kernel);
if(partition_expression)
{
request->partitionExpr = c_stringNew(base, partition_expression);
}
if(topic_expression)
{
request->topicExpr = c_stringNew(base, topic_expression);
}
if(uri)
{
request->uri = c_stringNew(base, uri);
}
} else {
OS_REPORT(OS_ERROR,
"v_kernel::v_persistentSnapshotRequest",0,
"Failed to create v_persistentSnapshotRequest object.");
assert(FALSE);
}
return request;
}
c_bool
d_publisherDeleteDataWriterCopy(
c_type type,
void *data,
void *to)
{
c_bool result;
d_deleteData msgFrom = d_deleteData(data);
d_deleteData msgTo = d_deleteData(to);
c_base base = c_getBase(type);
result = d_publisherMessageWriterCopy(&msgFrom->parentMsg, &msgTo->parentMsg);
msgTo->actionTime.seconds = msgFrom->actionTime.seconds;
msgTo->actionTime.nanoseconds = msgFrom->actionTime.nanoseconds;
if(msgFrom->partitionExpr) {
msgTo->partitionExpr = c_stringNew(base, msgFrom->partitionExpr);
} else {
msgTo->partitionExpr = NULL;
}
if(msgFrom->topicExpr) {
msgTo->topicExpr = c_stringNew(base, msgFrom->topicExpr);
} else {
msgTo->topicExpr = NULL;
}
return result;
}
c_bool
__chromatic_imap_dds_chromatic_name_service__copyIn(
c_base base,
struct ::chromatic_imap_dds::chromatic_name_service *from,
struct _chromatic_imap_dds_chromatic_name_service *to)
{
c_bool result = OS_C_TRUE;
(void) base;
to->session_idx = (c_long)from->session_idx;
#ifdef OSPL_BOUNDS_CHECK
if(from->user_name){
if(((unsigned int)strlen(from->user_name)) <= 32){
to->user_name = c_stringNew(base, from->user_name);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_name_service.user_name' of type 'C_STRING<32>' is out of range.");
result = OS_C_FALSE;
}
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_name_service.user_name' of type 'C_STRING<32>' is NULL.");
result = OS_C_FALSE;
}
#else
to->user_name = c_stringNew(base, from->user_name);
#endif
return result;
}
c_bool
__sensor_msgs_msg_dds__TimeReference___copyIn(
c_base base,
struct ::sensor_msgs::msg::dds_::TimeReference_ *from,
struct _sensor_msgs_msg_dds__TimeReference_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
if(result){
extern c_bool __std_msgs_msg_dds__Header___copyIn(c_base, ::std_msgs::msg::dds_::Header_ *, _std_msgs_msg_dds__Header_ *);
result = __std_msgs_msg_dds__Header___copyIn(base, &from->header_, &to->header_);
}
if(result){
extern c_bool __DDS_Time_t__copyIn(c_base, ::DDS::Time_t *, _DDS_Time_t *);
result = __DDS_Time_t__copyIn(base, &from->time_ref_, &to->time_ref_);
}
#ifdef OSPL_BOUNDS_CHECK
if(from->source_){
to->source_ = c_stringNew(base, from->source_);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'sensor_msgs::msg::dds_::TimeReference_.source_' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->source_ = c_stringNew(base, from->source_);
#endif
return result;
}
c_bool
d_publisherGroupsRequestWriterCopy(
c_type type,
void *data,
void *to)
{
c_bool result;
d_groupsRequest msgFrom = (d_groupsRequest)data;
d_groupsRequest msgTo = (d_groupsRequest)to;
c_base base = c_getBase(type);
result = d_publisherMessageWriterCopy(&d_groupsRequest(data)->parentMsg, &d_groupsRequest(to)->parentMsg);
if(msgFrom->partition){
msgTo->partition = c_stringNew(base, msgFrom->partition);
} else {
msgTo->partition = NULL;
}
if(msgFrom->topic){
msgTo->topic = c_stringNew(base, msgFrom->topic);
} else {
msgTo->topic = NULL;
}
return result;
}
c_bool
d_publisherNewGroupWriterCopy(
c_type type,
void *data,
void *to)
{
c_bool result;
d_newGroup msgFrom = (d_newGroup)data;
d_newGroup msgTo = (d_newGroup)to;
c_base base = c_getBase(type);
result = d_publisherMessageWriterCopy(&msgFrom->parentMsg, &msgTo->parentMsg);
if(msgFrom->partition){
msgTo->partition = c_stringNew(base, msgFrom->partition);
} else {
msgTo->partition = NULL;
}
if(msgFrom->topic){
msgTo->topic = c_stringNew(base, msgFrom->topic);
} else {
msgTo->topic = NULL;
}
msgTo->completeness = msgFrom->completeness;
msgTo->durabilityKind = msgFrom->durabilityKind;
msgTo->quality = msgFrom->quality;
msgTo->alignerCount = msgFrom->alignerCount;
return result;
}
v_historicalDataRequest
v_historicalDataRequestNew(
v_kernel kernel,
c_char* filter,
c_char* params[],
c_ulong nofParams,
c_time minSourceTime,
c_time maxSourceTime,
struct v_resourcePolicy *resourceLimits)
{
v_historicalDataRequest request;
c_ulong i;
c_type type;
c_base base;
request = c_new(v_kernelType(kernel,K_HISTORICALDATAREQUEST));
if (request) {
if(filter){
base = c_getBase(kernel);
request->filter = c_stringNew(base, filter);
if(params){
type = c_string_t(base);
request->filterParams = c_arrayNew(type, nofParams);
for(i=0; i<nofParams; i++){
request->filterParams[i] = c_stringNew(base, params[i]);
}
} else {
request->filterParams = NULL;
}
} else {
request->filter = NULL;
request->filterParams = NULL;
}
if ((minSourceTime.seconds == C_TIME_INVALID.seconds) &&
(minSourceTime.nanoseconds == C_TIME_INVALID.nanoseconds)) {
request->minSourceTimestamp = C_TIME_ZERO;
} else {
request->minSourceTimestamp = minSourceTime;
}
if ((maxSourceTime.seconds == C_TIME_INVALID.seconds) &&
(maxSourceTime.nanoseconds == C_TIME_INVALID.nanoseconds)) {
request->maxSourceTimestamp = C_TIME_INFINITE;
} else {
request->maxSourceTimestamp = maxSourceTime;
}
request->resourceLimits.max_samples = resourceLimits->max_samples;
request->resourceLimits.max_instances = resourceLimits->max_instances;
request->resourceLimits.max_samples_per_instance = resourceLimits->max_samples_per_instance;
} else {
OS_REPORT(OS_ERROR,
"v_historicalDataRequestNew",0,
"Failed to allocate request.");
assert(FALSE);
}
return request;
}
c_bool
__sensor_msgs_msg_dds__CompressedImage___copyIn(
c_base base,
struct ::sensor_msgs::msg::dds_::CompressedImage_ *from,
struct _sensor_msgs_msg_dds__CompressedImage_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
if(result){
extern c_bool __std_msgs_msg_dds__Header___copyIn(c_base, ::std_msgs::msg::dds_::Header_ *, _std_msgs_msg_dds__Header_ *);
result = __std_msgs_msg_dds__Header___copyIn(base, &from->header_, &to->header_);
}
#ifdef OSPL_BOUNDS_CHECK
if(from->format_){
to->format_ = c_stringNew(base, from->format_);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'sensor_msgs::msg::dds_::CompressedImage_.format_' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->format_ = c_stringNew(base, from->format_);
#endif
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 774 */
static c_type type0 = NULL;
c_type subtype0;
c_long length0;
c_octet *dest0;
::sensor_msgs::msg::dds_::CompressedImage_::_data__seq *src = &from->data_;
if (type0 == NULL) {
subtype0 = c_type(c_metaResolve (c_metaObject(base), "c_octet"));
type0 = c_metaSequenceTypeNew(c_metaObject(base),"C_SEQUENCE<c_octet>",subtype0,0);
c_free(subtype0);
}
length0 = (c_long)(*src).length();
#ifdef OSPL_BOUNDS_CHECK
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#else
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#endif
}
return result;
}
c_bool
d_publisherSampleChainWriterCopy(
c_type type,
void *data,
void *to)
{
d_sampleChain msgFrom = d_sampleChain(data);
d_sampleChain msgTo = d_sampleChain(to);
c_base base = c_getBase(type);
static c_type type0 = NULL;
static c_type type1 = NULL;
unsigned int valueSize;
d_publisherMessageWriterCopy(&msgFrom->parentMsg, &msgTo->parentMsg);
msgTo->partition = c_stringNew(base, msgFrom->partition);
msgTo->topic = c_stringNew(base, msgFrom->topic);
msgTo->durabilityKind = msgFrom->durabilityKind;
msgTo->msgBody._d = msgFrom->msgBody._d;
msgTo->addresseesCount = msgFrom->addresseesCount;
assert(msgTo->addresseesCount > 0);
if (type1 == NULL) {
type1 = c_resolve(base, "durabilityModule2::d_networkAddress_s");
}
assert(type1 != NULL);
msgTo->addressees = c_arrayNew(type1, msgTo->addresseesCount);
assert(msgTo->addressees);
memcpy(msgTo->addressees, msgFrom->addressees, msgTo->addresseesCount*C_SIZEOF(d_networkAddress));
msgTo->source.systemId = msgFrom->source.systemId;
msgTo->source.localId = msgFrom->source.localId;
msgTo->source.lifecycleId = msgFrom->source.lifecycleId;
switch(msgTo->msgBody._d) {
case BEAD:
if (type0 == NULL) {
type0 = c_resolve(base, "c_octet");
}
assert(type0 != NULL);
valueSize = msgFrom->msgBody._u.bead.size;
msgTo->msgBody._u.bead.size = valueSize;
msgTo->msgBody._u.bead.value = c_arrayNew(type0, valueSize);
memcpy(msgTo->msgBody._u.bead.value, msgFrom->msgBody._u.bead.value, valueSize);
break;
case LINK:
msgTo->msgBody._u.link.nrSamples = msgFrom->msgBody._u.link.nrSamples;
msgTo->msgBody._u.link.completeness = msgFrom->msgBody._u.link.completeness;
break;
default:
OS_REPORT_1(OS_ERROR, "d_publisherSampleChainWriterCopy", 0,
"Illegal message body discriminant value (%d) detected.",
msgTo->msgBody._d);
assert(FALSE);
}
return TRUE;
}
v_partitionPolicyI
v_partitionPolicyAdd(
v_partitionPolicyI p,
const c_char* expr,
c_base base)
{
c_iter list;
c_char *str, *partition;
os_size_t size;
c_bool isIn;
v_partitionPolicyI newPolicy;
newPolicy.v = NULL;
assert(expr);
if(p.v){
isIn = FALSE;
list = v_partitionPolicySplit(p);
partition = c_iterTakeFirst(list);
while(partition){
if(strcmp(partition, expr) == 0){
isIn = TRUE;
}
os_free(partition);
partition = c_iterTakeFirst(list);
}
c_iterFree(list);
if(isIn){
/* It's already in there, so return the current value */
newPolicy.v = c_stringNew(base, p.v);
} else {
/* It's not in there, so add it to the existing one */
size = strlen(p.v) + 1 + strlen(expr) + 1;
str = os_malloc(size);
if (str) {
os_strncpy(str, p.v, size);
str = os_strcat(str, ",");
str = os_strcat(str, expr);
newPolicy.v = c_stringNew(base, str);
os_free(str);
} else {
/* failed to allocate, so report error and return NULL */
OS_REPORT(OS_FATAL, "v_partitionPolicyAdd", V_RESULT_OUT_OF_MEMORY, "Failed to allocate partitionPolicy");
}
}
} else {
/* No policy exists yet, so make the expr the new policy */
newPolicy.v = c_stringNew(base, expr);
}
return newPolicy;
}
c_bool
d_publisherSampleRequestWriterCopy(
c_type type,
void *data,
void *to)
{
c_bool result;
c_ulong i;
static c_type type3;
d_sampleRequest msgFrom = d_sampleRequest(data);
d_sampleRequest msgTo = d_sampleRequest(to);
c_base base = c_getBase(type);
result = d_publisherMessageWriterCopy(&msgFrom->parentMsg, &msgTo->parentMsg);
msgTo->partition = c_stringNew(base, msgFrom->partition);
msgTo->topic = c_stringNew(base, msgFrom->topic);
msgTo->durabilityKind = msgFrom->durabilityKind;
msgTo->requestTime = msgFrom->requestTime;
msgTo->withTimeRange = msgFrom->withTimeRange;
msgTo->beginTime = msgFrom->beginTime;
msgTo->endTime = msgFrom->endTime;
msgTo->source.systemId = msgFrom->source.systemId;
msgTo->source.localId = msgFrom->source.localId;
msgTo->source.lifecycleId = msgFrom->source.lifecycleId;
if(msgFrom->filter){
msgTo->filter = c_stringNew(base, msgFrom->filter);
} else {
msgTo->filter = NULL;
}
if(msgFrom->filterParams){
if (type3 == NULL) {
type3 = c_resolve(base, "c_string");
}
assert(type3 != NULL);
msgTo->filterParamsCount = msgFrom->filterParamsCount;
msgTo->filterParams = c_arrayNew(type3, msgFrom->filterParamsCount);
for(i=0; i<msgFrom->filterParamsCount; i++){
msgTo->filterParams[i] = c_stringNew(base, msgFrom->filterParams[i]);
}
}
msgTo->maxSamples = msgFrom->maxSamples;
msgTo->maxInstances = msgFrom->maxInstances;
msgTo->maxSamplesPerInstance = msgFrom->maxSamplesPerInstance;
return result;
}
static c_type
createKeyType(
const c_char *name,
c_array keyList)
{
c_base base;
c_type foundType;
c_char *typeName;
c_char keyName[16];
c_long i, length, sres;
c_array members;
c_metaObject o;
c_field field;
if (keyList == NULL) {
return NULL;
}
base = c_getBase(keyList);
length = c_arraySize(keyList);
if (length == 0) {
return NULL;
}
o = c_metaDefine(c_metaObject(base),M_STRUCTURE);
members = c_arrayNew(c_member_t(base),length);
for (i=0;i<length;i++) {
field = keyList[i];
assert(field != NULL);
members[i] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER);
sprintf(keyName,"field%d",i);
c_specifier(members[i])->name = c_stringNew(base,keyName);
c_specifier(members[i])->type = c_keep(c_fieldType(field));
}
c_structure(o)->members = members;
c_metaObject(o)->definedIn = c_metaObject(base);
c_metaFinalize(o);
#define KEY_NAME "<Key>"
#define KEY_FORMAT "%s<Key>"
if (name != NULL) {
length = sizeof(KEY_NAME) + strlen(name);
typeName = os_malloc(length);
sres = snprintf(typeName,length,KEY_FORMAT,name);
assert(sres == (length-1));
} else {
assert(FALSE);
length = 100;
typeName = os_malloc(length);
os_sprintf(typeName,PA_ADDRFMT KEY_NAME,(c_address)o);
}
#undef KEY_NAME
#undef KEY_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),typeName,o));
c_free(o);
os_free(typeName);
return foundType;
}
v_partitionPolicyI
v_partitionPolicyRemove(
v_partitionPolicyI p,
const c_char *expr,
c_base base)
{
v_partitionPolicyI newPolicy;
c_char *str;
c_char *start; /* start of expr in p */
os_size_t len;
newPolicy.v = NULL;
if (p.v != NULL) {
if (strcmp(p.v, expr) != 0) {
len = strlen(p.v);
str = os_malloc(len + 1);
start = strstr(p.v, expr);
assert(start != NULL);
assert((c_address)start >= (c_address)p.v);
os_strncpy(str, p.v, (c_address)start - (c_address)p.v); /* includes ',' */
str[(c_address)start - (c_address)p.v] = 0; /* make '\0' terminated */
if (strcmp(start, expr) != 0) { /* not at the end */
os_strcat(str, (c_char *)((c_address)start + strlen(expr) + 1 /* , */));
}
newPolicy.v = c_stringNew(base, str);
os_free(str);
}
}
return newPolicy;
}
v_subscriber
v_participantGetBuiltinSubscriber(
v_participant p)
{
v_subscriberQos sQos;
v_readerQos rQos;
v_kernel kernel;
c_bool create_builtin_readers = FALSE;
assert(p != NULL);
assert(C_TYPECHECK(p, v_participant));
c_mutexLock(&p->builtinLock);
if (p->builtinSubscriber == NULL) {
kernel = v_objectKernel(p);
sQos = v_subscriberQosNew(kernel, NULL);
sQos->presentation.access_scope = V_PRESENTATION_TOPIC;
c_free(sQos->partition);
sQos->partition = c_stringNew(c_getBase(c_object(kernel)),
V_BUILTIN_PARTITION);
sQos->entityFactory.autoenable_created_entities = TRUE;
p->builtinSubscriber = v_subscriberNew(p, V_BUILTINSUBSCRIBER_NAME,
sQos, TRUE);
v_subscriberQosFree(sQos);
create_builtin_readers = TRUE;
c_mutexUnlock(&p->builtinLock);
assert(p->builtinSubscriber != NULL);
rQos = v_readerQosNew(kernel, NULL);
rQos->durability.kind = V_DURABILITY_TRANSIENT;
rQos->reliability.kind = V_RELIABILITY_RELIABLE;
rQos->history.kind = V_HISTORY_KEEPLAST;
rQos->history.depth = 1;
#define _CREATE_READER_(topicName) {\
q_expr expr; \
v_dataReader dr; \
expr = q_parse("select * from " topicName);\
dr = v_dataReaderNew(p->builtinSubscriber, topicName "Reader", \
expr, NULL, rQos, TRUE);\
c_free(dr); \
q_dispose(expr); \
}
_CREATE_READER_(V_PARTICIPANTINFO_NAME)
_CREATE_READER_(V_TOPICINFO_NAME)
_CREATE_READER_(V_PUBLICATIONINFO_NAME)
_CREATE_READER_(V_SUBSCRIPTIONINFO_NAME)
#undef _CREATE_READER_
v_readerQosFree(rQos);
} else {
c_mutexUnlock(&p->builtinLock);
}
return c_keep(p->builtinSubscriber);
}
static void fillExprList(
void* o,
void* udata) {
c_list list = udata;
char* str = o;
/* Insert expressions into list */
c_listInsert(list, c_stringNew(c_getBase(list), str));
}
gapi_boolean
gapi_publicationBuiltinTopicData__copyIn (
c_base base,
void *_from,
void *_to)
{
#ifdef BUILTIN_TOPIC_COPY_IN
const gapi_publicationBuiltinTopicData *from = (gapi_publicationBuiltinTopicData *)_from;
struct v_publicationInfo *to = (struct v_publicationInfo *)_to;
builtinTopicKeyCopyin(&from->key, &to->key);
builtinTopicKeyCopyin(&from->participant_key, &to->participant_key);
if ( from->topic_name ) {
to->topic_name = c_stringNew(base, from->topic_name);
} else {
to->topic_name = NULL;
}
if ( from->type_name ) {
to->type_name = c_stringNew(base, from->type_name);
} else {
to->type_name = NULL;
}
durabilityQosPolicyCopyin(&from->durability, &to->durability);
deadlineQosPolicyCopyin(&from->deadline, &to->deadline);
latencyBudgetQosPolicyCopyin(&from->latency_budget, &to->latency_budget);
livelinessQosPolicyCopyin(&from->liveliness, &to->liveliness);
reliabilityQosPolicyCopyin(&from->reliability, &to->reliability);
lifespanQosPolicyCopyin(&from->lifespan, &to->lifespan);
destinationOrderQosPolicyCopyin(&from->destination_order, &to->destination_order);
builtinUserDataQosPolicyCopyin(base, &from->user_data, &to->user_data);
ownershipQosPolicyCopyin(&from->ownership, &to->ownership);
ownershipStrengthQosPolicyCopyin(&from->ownership_strength, &to->ownership_strength);
presentationQosPolicyCopyin(&from->presentation, &to->presentation);
builtinPartitionQosPolicyCopyin(base, &from->partition, &to->partition);
builtinTopicDataQosPolicyCopyin(base, &from->topic_data, &to->topic_data);
builtinGroupDataQosPolicyCopyin(base, &from->group_data, &to->group_data);
#endif
return TRUE;
}
static v_statisticsCategory
v_statisticsCategoryNew(
v_kernel k,
const char *categoryName)
{
c_base base;
v_statisticsCategory result;
base = c_getBase(k);
result = c_stringNew(base, categoryName);
return result;
}
gapi_boolean
gapi_topicBuiltinTopicData__copyIn (
c_base base,
void *_from,
void *_to)
{
#ifdef BUILTIN_TOPIC_COPY_IN
const gapi_topicBuiltinTopicData *from = (gapi_topicBuiltinTopicData *)_from;
struct v_topicInfo *to = (struct v_topicInfo *)_to;
builtinTopicKeyCopyin(&from->key, &to->key);
if ( from->name ) {
to->name = c_stringNew(base, from->name);
} else {
to->name = NULL;
}
if ( from->type_name ) {
to->type_name = c_stringNew(base, from->type_name);
} else {
to->type_name = NULL;
}
durabilityQosPolicyCopyin(&from->durability, &to->durability);
durabilityServiceQosPolicyCopyin(&from->durability_service, &to->durabilityService);
deadlineQosPolicyCopyin(&from->deadline, &to->deadline);
latencyBudgetQosPolicyCopyin(&from->latency_budget, &to->latency_budget);
livelinessQosPolicyCopyin(&from->liveliness, &to->liveliness);
reliabilityQosPolicyCopyin(&from->reliability, &to->reliability);
transportPriorityQosPolicyCopyin(&from->transport_priority, &to->transport_priority);
lifespanQosPolicyCopyin(&from->lifespan, &to->lifespan);
destinationOrderQosPolicyCopyin(&from->destination_order, &to->destination_order);
historyQosPolicyCopyin(&from->history, &to->history);
resourceLimitsQosPolicyCopyin(&from->resource_limits, &to->resource_limits);
ownershipQosPolicyCopyin(&from->ownership, &to->ownership);
builtinTopicDataQosPolicyCopyin(base, &from->topic_data, &to->topic_data);
#endif
return TRUE;
}
d_groupInfo
d_groupInfoNew (
const d_storeMMFKernel kernel,
const d_topicInfo topic,
const d_group dgroup)
{
d_groupInfo group;
c_base base;
c_char* partition;
c_type instanceType, groupInfoType;
c_char *keyExpr;
if(kernel && topic && dgroup){
base = c_getBase(kernel);
groupInfoType = c_resolve(base,"durabilityModule2::d_groupInfo");
group = d_groupInfo(c_new(groupInfoType));
c_free(groupInfoType);
if (group) {
group->kernel = kernel; /* Unmanaged pointer */
group->topic = c_keep(topic);
partition = d_groupGetPartition(dgroup);
group->partition = c_stringNew(base, partition);
os_free(partition);
group->quality = d_groupGetQuality(dgroup);
group->completeness = d_groupGetCompleteness(dgroup);
instanceType = d_topicInfoGetInstanceType(topic);
keyExpr = d_topicInfoGetInstanceKeyExpr(topic);
group->instances = c_tableNew(instanceType, keyExpr);
c_free(keyExpr);
c_free(instanceType);
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Failed to allocate d_groupInfo.");
assert(FALSE);
group = NULL;
}
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Illegal constructor parameter.");
group = NULL;
}
return group;
}
void
v_cfNodeInit (
v_cfNode node,
v_configuration config,
v_cfKind kind,
const c_char *name)
{
assert(C_TYPECHECK(node, v_cfNode));
assert(name != NULL);
node->kind = kind;
node->name = c_stringNew(c_getBase(node), name);
node->id = v_configurationIdNew(config);
node->configuration = config;
}
v_networkQueueStatistics v_networkQueueStatisticsNew(v_kernel k, const c_char *name)
{
v_networkQueueStatistics nqs;
c_string channelName;
assert(k != NULL);
assert(C_TYPECHECK(k, v_kernel));
if (networkQueueStatisticsType == NULL) {
networkQueueStatisticsType = c_resolve(c_getBase(k), "kernelModule::v_networkQueueStatistics");
}
nqs = v_networkQueueStatistics(v_new(k, networkQueueStatisticsType));
channelName = c_stringNew(c_getBase(c_object(k)),name);
v_networkQueueStatisticsInit(nqs,channelName);
return nqs;
}
void
v_cfDataInit (
v_cfData data,
v_configuration config,
c_value value)
{
assert(C_TYPECHECK(data, v_cfData));
assert(value.kind != V_UNDEFINED);
v_cfNodeInit(v_cfNode(data), config, V_CFDATA, V_CFDATANAME);
data->value.kind = value.kind;
switch (value.kind) {
case V_BOOLEAN:
case V_OCTET:
case V_SHORT:
case V_LONG:
case V_LONGLONG:
case V_USHORT:
case V_ULONG:
case V_SIZE:
case V_ULONGLONG:
case V_FLOAT:
case V_DOUBLE:
case V_CHAR:
data->value.is = value.is;
break;
case V_STRING:
data->value.is.String = c_stringNew(c_getBase(data), value.is.String);
break;
case V_WCHAR:
case V_WSTRING:
case V_FIXED:
case V_OBJECT:
case V_UNDEFINED:
case V_COUNT:
default:
data->value.kind = V_UNDEFINED;
assert(0); /* not supported! */
break;
}
}
d_storeResult
d_storeMMFKernelMarkNameSpaceComplete(
d_storeMMFKernel kernel,
const d_nameSpace nameSpace,
const c_bool isComplete)
{
d_nameSpaceInfo nsInfo;
c_type type;
c_char* name;
c_value keyValues[1];
d_storeResult result;
if(kernel && nameSpace){
name = d_nameSpaceGetName(nameSpace);
keyValues[0] = c_stringValue((c_string)name);
nsInfo = c_tableFind(kernel->nameSpaces, keyValues);
if(nsInfo){
nsInfo->complete = isComplete;
result = D_STORE_RESULT_OK;
} else {
type = c_resolve(c_getBase(kernel),
"durabilityModule2::d_nameSpaceInfo");
nsInfo = (d_nameSpaceInfo)c_new(type);
c_free(type);
if (nsInfo) {
nsInfo->name = c_stringNew(c_getBase(kernel), name);
nsInfo->complete = isComplete;
c_tableInsert(kernel->nameSpaces, nsInfo);
c_free(nsInfo);
result = D_STORE_RESULT_OK;
} else {
OS_REPORT(OS_ERROR,
"d_storeMMFKernelMarkNameSpaceComplete",0,
"Failed to allocate nameSpaceInfo.");
result = D_STORE_RESULT_OUT_OF_RESOURCES;
}
}
} else {
result = D_STORE_RESULT_ILL_PARAM;
}
return result;
}
v_partitionInterest
v_partitionInterestNew(
v_kernel kernel,
const char *partitionExpression)
{
v_partitionInterest result = NULL;
result = c_new(v_kernelType(kernel, K_DOMAININTEREST));
if (result) {
result->expression = c_stringNew(c_getBase(c_object(kernel)), partitionExpression);
} else {
OS_REPORT(OS_ERROR,
"v_partitionInterestNew",0,
"Failed to allocate partition interest.");
}
return result;
}
v_networkChannelStatistics
v_networkChannelStatisticsNew(
v_kernel k,
const c_char *name)
{
v_networkChannelStatistics ncs;
c_string channelName;
c_type type;
assert(k != NULL);
assert(C_TYPECHECK(k, v_kernel));
type = c_resolve(c_getBase(k), "kernelModuleI::v_networkChannelStatistics");
assert(type);
ncs = v_networkChannelStatistics(v_new(k, type));
c_free(type);
channelName = c_stringNew(c_getBase(c_object(k)),name);
v_networkChannelStatisticsInit(ncs,channelName);
return ncs;
}
void
c_fieldClone(
c_field srcfield,
c_object src,
c_field dstfield,
c_object dst)
{
c_long i,n;
c_array refs;
c_voidp srcp = src;
c_voidp dstp = dst;
if (srcfield->refs) {
refs = srcfield->refs;
n = c_arraySize(refs)-1;
for(i=0;i<n;i++) {
srcp = *(c_voidp *)C_DISPLACE(srcp,refs[i]);
}
srcp = C_DISPLACE(srcp,refs[n]);
} else {
srcp = C_DISPLACE(srcp,srcfield->offset);
}
if (dstfield->refs) {
refs = dstfield->refs;
n = c_arraySize(refs)-1;
for(i=0;i<n;i++) {
dstp = *(c_voidp *)C_DISPLACE(dstp,refs[i]);
}
dstp = C_DISPLACE(dstp,refs[n]);
} else {
dstp = C_DISPLACE(dstp,dstfield->offset);
}
if ((dstfield->kind == V_STRING) ||
(dstfield->kind == V_WSTRING) ||
(dstfield->kind == V_FIXED)) {
dstp = c_stringNew(c_getBase(dstfield), srcp);
} else {
memcpy(dstp,srcp,dstfield->type->size);
}
}
v_rnrStorageStatistics
v_rnrStorageStatisticsNew(
v_kernel k,
const c_char *name)
{
v_rnrStorageStatistics _this;
c_string storageName;
c_type type;
assert(k && name);
assert(C_TYPECHECK(k, v_kernel));
type = c_resolve(c_getBase(k), "kernelModule::v_rnrStorageStatistics");
_this = v_rnrStorageStatistics(c_new(type));
storageName = c_stringNew(c_getBase(c_object(k)), name);
c_free(type);
v_rnrStorageStatisticsInit(_this, k, storageName);
return _this;
}
c_bool
__chromatic_imap_dds_chromatic_imap_command__copyIn(
c_base base,
struct ::chromatic_imap_dds::chromatic_imap_command *from,
struct _chromatic_imap_dds_chromatic_imap_command *to)
{
c_bool result = OS_C_TRUE;
(void) base;
to->session_idx = (c_long)from->session_idx;
to->locale_idx = (c_long)from->locale_idx;
#ifdef OSPL_BOUNDS_CHECK
if(from->moniker){
to->moniker = c_stringNew(base, from->moniker);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.moniker' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->moniker = c_stringNew(base, from->moniker);
#endif
#ifdef OSPL_BOUNDS_CHECK
if(from->command){
if(((unsigned int)strlen(from->command)) <= 32){
to->command = c_stringNew(base, from->command);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.command' of type 'C_STRING<32>' is out of range.");
result = OS_C_FALSE;
}
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.command' of type 'C_STRING<32>' is NULL.");
result = OS_C_FALSE;
}
#else
to->command = c_stringNew(base, from->command);
#endif
#ifdef OSPL_BOUNDS_CHECK
if(from->payload){
to->payload = c_stringNew(base, from->payload);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.payload' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->payload = c_stringNew(base, from->payload);
#endif
return result;
}
