c_iter
v_resolveMMFGroups(
c_set groups,
const c_char *partitionExpr,
const c_char *topicExpr)
{
c_collection q;
q_expr expr;
c_iter list;
c_value params[2];
assert(groups != NULL);
expr = (q_expr)q_parse("partition.name like %0 and topic.name like %1");
if (expr == NULL) {
assert(expr != NULL);
return NULL;
}
params[0] = c_stringValue((c_string)partitionExpr);
params[1] = c_stringValue((c_string)topicExpr);
q = c_queryNew(groups, expr, params);
if (q == NULL) {
list = NULL;
} else {
list = ospl_c_select(q,0);
}
assert(q != NULL);
c_free(q);
q_dispose(expr);
return list;
}
void
v_participantDeleteHistoricalData(
v_participant participant,
const c_char* partitionExpr,
const c_char* topicExpr)
{
c_iter matchingGroups;
v_group group;
c_time t;
c_value params[2];
C_STRUCT(v_event) event;
C_STRUCT(v_historyDeleteEventData) hde;
assert(participant != NULL);
assert(C_TYPECHECK(participant, v_participant));
assert(partitionExpr);
assert(topicExpr);
if(partitionExpr && topicExpr){
params[0] = c_stringValue((c_string)partitionExpr);
params[1] = c_stringValue((c_string)topicExpr);
c_lockRead(&participant->lock);
t = v_timeGet();
matchingGroups = v_groupSetSelect(
v_objectKernel(participant)->groupSet,
"partition.name like %0 AND topic.name like %1",
params);
c_lockUnlock(&participant->lock);
group = v_group(c_iterTakeFirst(matchingGroups));
while(group){
v_groupDeleteHistoricalData(group, t);
c_free(group);
group = v_group(c_iterTakeFirst(matchingGroups));
}
c_iterFree(matchingGroups);
hde.partitionExpression = (c_char *)partitionExpr;
hde.topicExpression = (c_char *)topicExpr;
hde.deleteTime = t;
event.kind = V_EVENT_HISTORY_DELETE;
event.source = v_publicHandle(v_public(participant));
event.userData = &hde;
v_observableNotify(v_observable(v_objectKernel(participant)),&event);
}
return;
}
d_groupInfo
d_storeMMFKernelGetGroupInfo(
d_storeMMFKernel _this,
const char *partition,
const char *topic )
{
d_groupInfo result;
c_value keyValues[2];
keyValues[0] = c_stringValue((c_string)partition);
keyValues[1] = c_stringValue((c_string)topic);
result = c_tableFind(_this->groups, keyValues); /* c_tableFind already performs keep. */
return result;
}
static c_bool
v_partitionAdminRemoveExpression(
v_partitionAdmin da,
const char *partitionExpr)
{
c_bool result = FALSE;
v_partitionInterest partitionInterest, found;
q_expr expr;
c_collection q;
c_iter list;
c_value params[1];
assert(!v_partitionExpressionIsAbsolute(partitionExpr));
expr = (q_expr)q_parse("expression like %0");
params[0] = c_stringValue((char *)partitionExpr);
q = c_queryNew(da->partitionInterests, expr, params);
q_dispose(expr);
list = ospl_c_select(q,0);
assert(c_iterLength(list) <= 1);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
while (partitionInterest) {
result = TRUE;
found = c_tableRemove(da->partitionInterests, partitionInterest, NULL, NULL);
c_free(partitionInterest);
c_free(found);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
}
c_free(q);
c_iterFree(list);
return result;
}
d_storeResult
d_storeMMFKernelIsNameSpaceComplete(
d_storeMMFKernel kernel,
const d_nameSpace nameSpace,
c_bool* isComplete)
{
d_nameSpaceInfo nsInfo;
c_char* name;
d_storeResult result;
c_value keyValues[1];
if(kernel && nameSpace){
name = d_nameSpaceGetName(nameSpace);
keyValues[0] = c_stringValue((c_string)name);
nsInfo = c_tableFind(kernel->nameSpaces, keyValues);
if(nsInfo){
*isComplete = nsInfo->complete;
result = D_STORE_RESULT_OK;
} else {
*isComplete = FALSE;
result = D_STORE_RESULT_OK;
}
} else {
result = D_STORE_RESULT_ILL_PARAM;
}
return result;
}
c_bool
u_cfValueScan(
c_value value,
c_valueKind valueKind,
c_value *valuePtr)
{
int i;
c_bool result = FALSE;
if (value.kind == V_STRING) {
switch (valueKind) {
__CASE__(CHAR,c_char);
__CASE__(SHORT,c_short);
__CASE__(USHORT,c_ushort);
__CASE__(LONG,c_long);
__CASE__(ULONG,c_ulong);
__CASE__(LONGLONG,c_longlong);
__CASE__(ULONGLONG,c_ulonglong);
__CASE__(FLOAT,c_float);
case V_BOOLEAN:
{
c_bool dest;
result = u_cfValueScanBoolean(value.is.String, &dest);
if (result) {
*valuePtr = c_boolValue(dest);
}
}
break;
case V_STRING:
{
c_char *str;
c_ulong length;
length = (c_ulong)strlen(value.is.String);
str = os_malloc(length + 1U);
os_strncpy(str, value.is.String, length);
str[length] = 0;
*valuePtr = c_stringValue(str);
result = TRUE;
}
break;
case V_OCTET:
case V_DOUBLE:
default:
result = FALSE;
assert(0); /* Catch unhandled case */
break;
}
} else {
result = FALSE;
}
return result;
}
static d_topicInfo
d_storeMMFKernelGetTopicInfo(
d_storeMMFKernel _this,
const char* topic)
{
d_topicInfo result;
c_value keyValue;
keyValue = c_stringValue((c_string)topic);
result = c_tableFind(_this->topics, &keyValue); /* c_tableFind already performs keep. */
return result;
}
static d_topicInfo
d_storeMMFKernelGetTopicInfo(
d_storeMMFKernel _this,
const char* topic)
{
d_topicInfo result;
c_value keyValue;
keyValue = c_stringValue((c_string)topic);
result = c_tableFind(_this->topics, &keyValue);
return c_keep(result);
}
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;
}
static c_iter
v_resolveMMFNameSpaces(
d_storeMMFKernel kernel,
const c_char *name)
{
c_iter list;
c_collection q;
q_expr expr;
c_value params[1];
assert(kernel != NULL);
assert(C_TYPECHECK(kernel,v_kernel));
expr = (q_expr)q_parse("name like %0");
params[0] = c_stringValue((char *)name);
q = c_queryNew(kernel->nameSpaces,expr,params);
q_dispose(expr);
list = ospl_c_select(q,0);
c_free(q);
return list;
}
c_iter
v_resolveTopics(
v_kernel kernel,
const c_char *name)
{
c_iter list;
c_collection q;
q_expr expr;
c_value params[1];
assert(kernel != NULL);
assert(C_TYPECHECK(kernel,v_kernel));
expr = (q_expr)q_parse("name like %0");
params[0] = c_stringValue((char *)name);
q = c_queryNew(kernel->topics,expr,params);
q_dispose(expr);
c_lockRead(&kernel->lock);
list = c_select(q,0);
c_lockUnlock(&kernel->lock);
c_free(q);
return list;
}
static c_bool
v__partitionAdminRemove(
v_partitionAdmin da,
const char *partitionName,
v_partition *partitionRemoved)
{
c_bool result;
v_partition partition, found;
q_expr expr;
c_collection q;
c_iter list;
c_value params[1];
assert(v_partitionExpressionIsAbsolute(partitionName));
expr = (q_expr)q_parse("name like %0");
params[0] = c_stringValue((char *)partitionName);
q = c_queryNew(da->partitions, expr, params);
q_dispose(expr);
list = ospl_c_select(q,0);
assert(c_iterLength(list) <= 1);
partition = v_partition(c_iterTakeFirst(list));
if (partition) {
found = c_tableRemove(da->partitions, partition, NULL, NULL);
*partitionRemoved = found;
c_free(partition);
result = TRUE;
} else {
*partitionRemoved = NULL;
result = FALSE;
}
c_free(q);
c_iterFree(list);
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::DataReader::nlReq_init (
DDS::OpenSplice::Subscriber *subscriber,
const DDS::DataReaderQos &qos,
DDS::OpenSplice::TopicDescription *a_topic,
const char *name)
{
DDS::OpenSplice::ContentFilteredTopic *contentFilteredTopic;
DDS::ULong i = 0;
DDS::ULong length = 0;
DDS::ULong bytes = 0;
DDS::ReturnCode_t result = DDS::RETCODE_OK;
u_readerQos uReaderQos = NULL;
u_dataReader uReader = NULL;
const char *expression = NULL;
c_value *uParameters = NULL;
assert (subscriber != NULL);
/* Only check for QoS consistency here in debug builds. It's unnecessary to
to verify it twice in release builds. */
assert (DDS::OpenSplice::Utils::qosIsConsistent (qos) == DDS::RETCODE_OK);
assert (a_topic != NULL);
assert (name != NULL);
uReaderQos = u_readerQosNew (NULL);
if (uReaderQos != NULL) {
result = DDS::OpenSplice::Utils::copyQosIn (qos, uReaderQos);
} else {
result = DDS::RETCODE_OUT_OF_RESOURCES;
CPP_REPORT(result, "Could not copy DataReaderQos.");
}
if (result == DDS::RETCODE_OK) {
result = this->pimpl->views->init();
}
if (result == DDS::RETCODE_OK) {
result = this->pimpl->conditions->init();
}
if (result == DDS::RETCODE_OK) {
result = a_topic->write_lock();
if (result == DDS::RETCODE_OK) {
expression = a_topic->rlReq_get_topic_expression ();
assert(expression);
switch (a_topic->rlReq_get_kind()) {
case DDS::OpenSplice::CONTENTFILTEREDTOPIC:
contentFilteredTopic =
dynamic_cast<DDS::OpenSplice::ContentFilteredTopic *>(a_topic);
if (contentFilteredTopic != NULL) {
length = contentFilteredTopic->filterParameters.length ();
if(length > 0) {
bytes = length * sizeof (struct c_value);
uParameters = (c_value *)os_malloc (bytes);
for (i = 0; i < length; i++) {
const c_string param = (const c_string) contentFilteredTopic->filterParameters[i].in();
uParameters[i] = c_stringValue(param);
}
}
} else {
result = DDS::RETCODE_BAD_PARAMETER;
CPP_REPORT(result, "a_topic invalid, not of type '%s'",
"DDS::OpenSplice::ContentFilteredTopic");
}
break;
case DDS::OpenSplice::TOPIC:
default:
uParameters = NULL;
break;
}
}
if (result == DDS::RETCODE_OK) {
uReader = u_dataReaderNew (
u_subscriber (subscriber->rlReq_get_user_entity ()),
name,
expression,
uParameters,
length,
uReaderQos);
if (uReader == NULL) {
result = DDS::RETCODE_OUT_OF_RESOURCES;
CPP_REPORT(result, "Could not create DataReader.");
}
}
if (result == DDS::RETCODE_OK) {
result = DDS::OpenSplice::Entity::nlReq_init (u_entity (uReader));
if (result == DDS::RETCODE_OK) {
(void) DDS::Subscriber::_duplicate(subscriber);
this->pimpl->subscriber = subscriber;
(void) DDS::TopicDescription::_duplicate(a_topic);
this->pimpl->topic = a_topic;
a_topic->wlReq_incrNrUsers();
setDomainId(subscriber->getDomainId());
}
}
a_topic->unlock();
}
if (uReaderQos) {
u_readerQosFree (uReaderQos);
}
if (uParameters) {
os_free (uParameters);
}
return result;
}
static in_result
in_ddsiStreamReaderImplDerializePayloadByKeyHash(
in_ddsiStreamReaderImpl _this,
in_ddsiSubmessageData submessage,
in_connectivityPeerWriter peerWriter,
v_topic topic,
v_message *messageObject,
c_octet* keyHash)
{
in_result result;
c_long nrOfKeys, i, bytesCopied;
c_array messageKeyList;
c_value value;
c_base base;
assert(_this);
assert(submessage);
assert(peerWriter);
assert(topic);
assert(*messageObject);
messageKeyList = v_topicMessageKeyList(topic);
nrOfKeys = c_arraySize(messageKeyList);
bytesCopied = 0;
base = c_getBase(topic);
result = IN_RESULT_OK;
/*TODO: In case key is larger then 16 bytes, MD5 must be used*/
for (i=0;(i<nrOfKeys) && (result == IN_RESULT_OK);i++)
{
switch(c_fieldValueKind(messageKeyList[i]))
{
case V_BOOLEAN:
value = c_boolValue(*((c_bool*)&(keyHash[bytesCopied])));
bytesCopied += sizeof(c_bool);
break;
case V_OCTET:
value = c_octetValue(*((c_octet*)&(keyHash[bytesCopied])));
bytesCopied += sizeof(c_octet);
break;
case V_SHORT:
#ifdef PA_BIG_ENDIAN
value = c_shortValue(*((c_short*)&(keyHash[bytesCopied])));
#else
value = c_shortValue(IN_UINT16_SWAP_LE_BE(*((c_short*)&(keyHash[bytesCopied]))));
#endif
bytesCopied += sizeof(c_short);
break;
case V_USHORT:
#ifdef PA_BIG_ENDIAN
value = c_ushortValue(*((c_ushort*)&(keyHash[bytesCopied])));
#else
value = c_ushortValue(IN_UINT16_SWAP_LE_BE(*((c_ushort*)&(keyHash[bytesCopied]))));
#endif
bytesCopied += sizeof(c_ushort);
break;
case V_LONG:
#ifdef PA_BIG_ENDIAN
value = c_longValue(*((c_long*)&(keyHash[bytesCopied])));
#else
value = c_longValue(IN_UINT32_SWAP_LE_BE(*((c_long*)&(keyHash[bytesCopied]))));
#endif
bytesCopied += sizeof(c_long);
break;
case V_ULONG:
#ifdef PA_BIG_ENDIAN
value = c_ulongValue(*((c_ulong*)&(keyHash[bytesCopied])));
#else
value = c_ulongValue(IN_UINT32_SWAP_LE_BE(*((c_ulong*)&(keyHash[bytesCopied]))));
#endif
bytesCopied += sizeof(c_long);
break;
case V_CHAR:
value = c_charValue(*((c_char*)&(keyHash[bytesCopied])));
bytesCopied += sizeof(c_char);
break;
case V_STRING:
#ifdef PA_BIG_ENDIAN
value = c_ulongValue(*((c_ulong*)&(keyHash[bytesCopied])));
#else
value = c_ulongValue(IN_UINT32_SWAP_LE_BE(*((c_ulong*)&(keyHash[bytesCopied]))));
#endif
bytesCopied += 4;
/*TODO: validate the string copy algorithm*/
if(value.is.ULong != 0)
{
value = c_stringValue(
c_stringNew(base,((c_string)(&(keyHash[bytesCopied])))));
bytesCopied += strlen(value.is.String) + 1;
} else
{
value = c_stringValue(c_stringNew(base, ""));
bytesCopied += 1;
}
break;
case V_DOUBLE:
value = c_undefinedValue();
bytesCopied += sizeof(c_double);
result = IN_RESULT_PRECONDITION_NOT_MET;
break;
case V_FLOAT:
value = c_undefinedValue();
bytesCopied += sizeof(c_float);
result = IN_RESULT_PRECONDITION_NOT_MET;
break;
case V_ULONGLONG:
value = c_undefinedValue();
bytesCopied += sizeof(c_ulonglong);
result = IN_RESULT_PRECONDITION_NOT_MET;
break;
case V_LONGLONG:
value = c_undefinedValue();
bytesCopied += sizeof(c_longlong);
result = IN_RESULT_PRECONDITION_NOT_MET;
break;
default:
value = c_undefinedValue();
assert(FALSE);
result = IN_RESULT_ERROR;
break;
}
c_fieldAssign(messageKeyList[i],*messageObject, value);
c_valueFreeRef(value);
}
return result;
}
