static c_char *
createInstanceKeyExpr (
c_base base,
v_topic topic)
{
c_char fieldName[16];
c_char *keyExpr;
c_long i,nrOfKeys,totalSize;
c_array keyList;
assert(C_TYPECHECK(topic,v_topic));
keyList = v_topicMessageKeyList(topic);
nrOfKeys = c_arraySize(keyList);
if (nrOfKeys>0) {
totalSize = nrOfKeys * strlen("key.field0,");
if (nrOfKeys > 9) {
totalSize += (nrOfKeys-9);
if (nrOfKeys > 99) {
totalSize += (nrOfKeys-99);
}
}
keyExpr = c_stringMalloc(base, totalSize);
keyExpr[0] = 0;
for (i=0;i<nrOfKeys;i++) {
os_sprintf(fieldName,"key.field%d",i);
os_strcat(keyExpr,fieldName);
if (i<(nrOfKeys-1)) { os_strcat(keyExpr,","); }
}
} else {
keyExpr = NULL;
}
return keyExpr;
}
u_bool
u_topicContentFilterValidate2 (
const u_topic _this,
const q_expr expr,
const c_value params[],
os_uint32 nrOfParams)
{
v_topic topic;
u_bool result;
v_filter filter;
u_result uResult;
assert(_this);
assert(expr);
result = FALSE;
filter = NULL;
uResult = u_topicReadClaim(_this, &topic, C_MM_RESERVATION_LOW);
if (uResult == U_RESULT_OK) {
assert(topic);
filter = v_filterNew(v_topicMessageType(topic), v_topicMessageKeyList(topic), expr, params, nrOfParams);
u_topicRelease(_this, C_MM_RESERVATION_LOW);
}
if (filter != NULL) {
result = TRUE;
c_free(filter);
}
return result;
}
void
jni_getTopicKeyExpression(
v_entity entity,
c_voidp args)
{
v_kernel vk;
c_iter vtopics;
c_array keyList;
c_char* keyExpr;
c_long nrOfKeys, totalSize, i;
c_string fieldName, actualFieldName;
struct jni_topicArg *arg;
arg = (struct jni_topicArg *)args;
vk = v_objectKernel(entity);
if(vk != NULL){
vtopics = v_resolveTopics(vk, arg->topicName);
if(c_iterLength(vtopics) == 0){
c_iterFree(vtopics);
}
else{
keyList = v_topicMessageKeyList(c_iterTakeFirst(vtopics));
c_iterFree(vtopics);
nrOfKeys = c_arraySize(keyList);
if (nrOfKeys>0) {
totalSize = 0;
for (i=0;i<nrOfKeys;i++) {
fieldName = c_fieldName(keyList[i]);
totalSize += (strlen(fieldName)+1-9/*skip 'userdata.'*/);
}
keyExpr = (c_char *)os_malloc((size_t)(totalSize+1));
keyExpr[0] = 0;
for (i=0;i<nrOfKeys;i++) {
fieldName = c_fieldName(keyList[i]);
actualFieldName = c_skipUntil(fieldName, ".");
actualFieldName++; /*skip '.' */
os_strcat(keyExpr,actualFieldName);
if (i<(nrOfKeys-1)) {
os_strcat(keyExpr,",");
}
}
arg->keyExpr = keyExpr;
} else{
/*No keys, do nothing.*/
}
arg->result = U_RESULT_OK;
}
}
}
static d_instance
d_instanceNew(
d_groupInfo groupInfo,
const v_groupAction action)
{
d_instance instance;
c_type type;
c_long nrOfKeys, i;
c_array messageKeyList, instanceKeyList;
instanceKeyList = c_tableKeyList(groupInfo->instances);
type = c_subType(groupInfo->instances);
instance = d_instance(c_new(type));
c_free(type);
if(instance){
/*
* copy the key value of the message into the newly created instance.
*/
messageKeyList = v_topicMessageKeyList(v_groupTopic(action->group));
nrOfKeys = c_arraySize(messageKeyList);
assert(nrOfKeys == c_arraySize(instanceKeyList));
for (i=0;i<nrOfKeys;i++) {
c_fieldCopy(messageKeyList[i],action->message,
instanceKeyList[i], instance);
}
c_free(instanceKeyList);
d_instanceSetHead(instance, NULL);
d_instanceSetTail(instance, NULL);
instance->messageCount = 0;
instance->count = 0;
instance->state = 0;
v_stateSet(instance->state, L_EMPTY);
} else {
OS_REPORT(OS_ERROR,
"d_instanceNew",0,
"Failed to allocate instance.");
assert(FALSE);
}
return instance;
}
static v_message
createUnregisterMessage(
v_group group,
v_message message)
{
c_array messageKeyList;
c_long i, nrOfKeys;
v_message unregisterMessage;
assert(!v_stateTest(v_nodeState(message), L_UNREGISTER));
/* Create new message objec */
unregisterMessage = v_topicMessageNew
(group->topic);
/* Copy keyvalues to unregistermessage */
messageKeyList = v_topicMessageKeyList(v_groupTopic(group));
nrOfKeys = c_arraySize(messageKeyList);
for (i=0;i<nrOfKeys;i++) {
c_fieldAssign (messageKeyList[i],
unregisterMessage,
c_fieldValue(messageKeyList[i],message));
}
/* Set instance & writer GID */
unregisterMessage->writerGID =
message->writerGID;
unregisterMessage->writerInstanceGID =
message->writerInstanceGID;
/* Copy messageQos */
c_keep (message->qos);
unregisterMessage->qos = message->qos;
/* Set nodestate to unregister */
v_nodeState(unregisterMessage) = L_UNREGISTER;
unregisterMessage->writeTime = v_timeGet();
#ifndef _NAT_
unregisterMessage->allocTime = unregisterMessage->writeTime;
#endif
return unregisterMessage;
}
static void
checkTopicKeyList (
v_entity e,
c_voidp arg)
{
c_array keyList = v_topicMessageKeyList(e);
checkTopicKeyListArg *info = (checkTopicKeyListArg *) arg;
c_long i;
gapi_char *name;
c_long size;
c_iter iter;
gapi_boolean equal = TRUE;
iter = c_splitString(info->keyList, " \t,");
if ( iter ) {
size = c_arraySize(keyList);
for ( i = 0; equal && (i < size); i++ ) {
name = (gapi_char *)c_iterResolve(iter,
topicKeyCompare,
keyNameFromField(keyList[i]));
if ( !name ) {
equal = FALSE;
OS_REPORT_2(OS_API_INFO,
"gapi::kernelCheckTopicKeyList", 0,
"incompatible key <%s> found for topic <%s>",
keyNameFromField(keyList[i]),
v_entityName(e));
}
}
name = c_iterTakeFirst(iter);
while ( name ) {
os_free(name);
name = c_iterTakeFirst(iter);
}
c_iterFree(iter);
}
info->equal = equal;
}
static void
topicGetKeys(
v_entity e,
c_voidp arg)
{
c_array keyList = v_topicMessageKeyList(e);
gapi_char **keys = (gapi_char **) arg;
gapi_char *ptr;
c_ulong i;
c_ulong size;
c_ulong total = 0;
c_ulong len = 0;
size = c_arraySize(keyList);
for ( i = 0; i < size; i++ ) {
total += strlen(c_fieldName(keyList[i])) + 1;
}
if ( total > 0 ) {
*keys = (gapi_char *)os_malloc(total);
memset(*keys, 0, total);
} else {
*keys = (gapi_char *)os_malloc(1);
**keys = '\0';
}
ptr = *keys;
for ( i = 0; i < size; i++ ) {
if ( i == 0 ) {
len = os_sprintf(ptr, "%s", keyNameFromField(keyList[i]));
} else {
len = os_sprintf(ptr, ",%s", keyNameFromField(keyList[i]));
}
ptr = &(ptr[len]);
}
}
u_bool
u_topicContentFilterValidate (
const u_topic _this,
const q_expr expr,
const c_value params[],
os_uint32 nrOfParams)
{
v_topic topic;
u_bool result;
q_expr subexpr, term;
int i;
v_filter filter;
u_result uResult;
assert(_this);
assert(expr);
result = FALSE;
filter = NULL;
uResult = u_topicReadClaim(_this, &topic, C_MM_RESERVATION_LOW);
if (uResult == U_RESULT_OK) {
assert(topic);
i = 0;
subexpr = q_getPar(expr, i); /* get rid of Q_EXPR_PROGRAM */
while ((term = q_getPar(subexpr, i++)) != NULL) {
if (q_getTag(term) == Q_EXPR_WHERE) {
filter = v_filterNew(v_topicMessageType(topic), v_topicMessageKeyList(topic), term, params, nrOfParams);
}
}
u_topicRelease(_this, C_MM_RESERVATION_LOW);
}
if (filter != NULL) {
result = TRUE;
c_free(filter);
}
return result;
}
static d_instance
d_groupInfoLookupInstance (
d_groupInfo _this,
const v_groupAction action)
{
c_long i, nrOfKeys;
c_value keyValues[32];
d_instance instance;
c_array messageKeyList;
assert(C_TYPECHECK(action->message,v_message));
messageKeyList = v_topicMessageKeyList(action->group->topic);
nrOfKeys = c_arraySize(messageKeyList);
if (nrOfKeys > 32) {
OS_REPORT_1(OS_ERROR,
"d_groupInfoGetInstance",0,
"too many keys %d exceeds limit of 32",
nrOfKeys);
instance = NULL;
} else {
for (i=0;i<nrOfKeys;i++) {
keyValues[i] = c_fieldValue(messageKeyList[i],action->message);
}
instance = c_tableFind(_this->instances, &keyValues[0]);
c_keep(instance);
for (i=0;i<nrOfKeys;i++) {
c_valueFreeRef(keyValues[i]);
}
}
return instance;
}
static c_type
createInstanceType (
v_topic topic,
c_char *keyExpr,
c_array *keyListRef)
{
c_metaObject o;
c_type instanceType, baseType, foundType;
c_type sampleType, keyType, keyInstanceType;
c_base base;
c_char *name;
os_size_t length;
int sres;
assert(C_TYPECHECK(topic,v_topic));
foundType = NULL;
if (keyExpr) {
keyType = v_topicKeyTypeCreate(topic,keyExpr,keyListRef);
} else {
keyExpr = v_topicKeyExpr(topic);
keyType = v_topicKeyType(topic);
*keyListRef = c_keep(v_topicMessageKeyList(topic));
}
sampleType = sampleTypeNew(topic);
if (sampleType) {
base = c_getBase(topic);
baseType = v_dataReaderInstance_t(base);
instanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
if (instanceType != NULL) {
c_class(instanceType)->extends = c_keep(c_class(baseType));
o = c_metaDeclare(c_metaObject(instanceType),
"sample",M_ATTRIBUTE);
c_property(o)->type = c_keep(sampleType);
c_free(o);
o = c_metaDeclare(c_metaObject(instanceType),
"oldest",M_ATTRIBUTE);
c_property(o)->type = (c_type)c_metaResolveType(c_metaObject(base),
"c_voidp");
assert(c_property(o)->type);
c_free(o);
c_metaFinalize(c_metaObject(instanceType));
#define INSTANCE_NAME "v_indexInstance<v_indexSample<>>"
#define INSTANCE_FORMAT "v_indexInstance<v_indexSample<%s>>"
/* The sizeof contains \0 */
length = sizeof(INSTANCE_NAME) + strlen(v_topicName(topic));
name = os_alloca(length);
sres = snprintf(name,length,INSTANCE_FORMAT,v_topicName(topic));
assert(sres >= 0 && (os_size_t) sres == (length-1));
OS_UNUSED_ARG(sres);
#undef INSTANCE_NAME
#undef INSTANCE_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(instanceType)));
if (foundType == NULL) {
OS_REPORT(OS_ERROR,
"v_index::createInstanceType",V_RESULT_INTERNAL_ERROR,
"Could not create instance type");
}
os_freea(name);
if (keyType != NULL) {
keyInstanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
if (keyInstanceType) {
c_class(keyInstanceType)->extends = c_keep(c_class(instanceType));
o = c_metaDeclare(c_metaObject(keyInstanceType),
"key",M_ATTRIBUTE);
c_property(o)->type = c_keep(keyType);
c_free(o);
c_metaFinalize(c_metaObject(keyInstanceType));
#define INSTANCE_NAME "v_indexKeyInstance<v_indexSample<>,>"
#define INSTANCE_FORMAT "v_indexKeyInstance<v_indexSample<%s>,%s>"
/* The sizeof contains \0 */
length = sizeof(INSTANCE_NAME) +
strlen(v_topicName(topic)) +
strlen(keyExpr);
name = os_alloca(length);
sres = snprintf(name,
length,
INSTANCE_FORMAT,
v_topicName(topic),
keyExpr);
assert(sres >= 0 && (os_size_t) sres == (length-1));
OS_UNUSED_ARG(sres);
#undef INSTANCE_NAME
#undef INSTANCE_FORMAT
c_free(foundType); /* Will be overwritten, so free */
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(keyInstanceType)));
if (foundType == NULL) {
OS_REPORT(OS_ERROR,
"v_index::createInstanceType",V_RESULT_INTERNAL_ERROR,
"Could not create key instance type");
}
os_freea(name);
c_free(keyInstanceType);
}
c_free(keyType);
}
c_free(instanceType);
c_free(baseType);
} else {
foundType = baseType; /* transfer refCount to caller */
}
c_free(sampleType);
}
return foundType;
}
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;
}
