os_boolean in_messageDeserializerReadPropertyAction( c_object object, c_voidp arg) { in_messageDeserializerPropertyActionArg* a = (in_messageDeserializerPropertyActionArg*)arg; c_property property; c_type type; c_voidp data; assert(object); assert(arg); assert(a->object); assert(a->transformer); assert(in_messageDeserializerIsValid(a->transformer)); /* For now, we are interested in properties only */ if (c_baseObjectKind(object) == M_ATTRIBUTE) { property = c_property(object); type = c_typeActualType(property->type); data = C_DISPLACE(a->object, (c_address)property->offset); in_messageDeserializerReadType(a->transformer, type, data); } return OS_TRUE; }
c_iter c_bindAttributes( c_metaObject scope, c_iter declarations, c_type type, c_bool isReadOnly) { c_iter attributes; c_declarator d; c_metaObject o; if (isReadOnly) { /* suppress warnings */ } attributes = NULL; d = (c_declarator)c_iterTakeFirst(declarations); while (d != NULL) { o = c_metaDefine(scope,M_ATTRIBUTE); c_property(o)->type = c_declaratorType(d,type); c_metaFinalize(o); c_metaBind(scope,d->name,o); attributes = c_iterInsert(attributes,o); os_free(d); d = (c_declarator)c_iterTakeFirst(declarations); } c_iterFree(declarations); return attributes; }
static c_bool walkProperty( c_metaObject object, c_metaWalkActionArg actionArg) { toolActionData actionData = (toolActionData)actionArg; c_object o; c_voidp addr; o = c_iterObject(actionData->stack, 0); if (c_baseObjectKind(object) == M_ATTRIBUTE) { addr = C_DISPLACE(o, (c_address)c_property(object)->offset); if (c_typeIsRef(c_property(object)->type)) { addr = *(c_voidp *)addr; if (c_baseObjectKind(c_property(object)->type) == M_COLLECTION) { if (addr) { if (c_iterContains(actionData->stack, addr)) { printf("Ignore cyclic reference 0x"PA_ADDRFMT"\n", (os_address)addr); } else { OBJECT_PUSH(actionData, addr); iprintf("%s ",_METANAME(object)); printType(c_property(object)->type, actionData); OBJECT_POP(actionData); } } else { iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr); } } else { iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr); if (addr) { /* Section for code to print additional type specific info. */ if (c_property(object)->type == v_topic_t) { printf(" /* topic name is: %s */", v_topicName(addr)); } if (c_property(object)->type == v_partition_t) { printf(" /* Partition: %s */", v_partitionName(addr)); } if (c_property(object)->type == c_type_t(c_getBase(object))) { printf(" /* Type: %s */", _METANAME(c_type(addr))); } } } printf("\n"); } else { OBJECT_PUSH(actionData, addr); iprintf("%s ",_METANAME(object)); printType(c_property(object)->type, actionData); printf("\n"); OBJECT_POP(actionData); } } return TRUE; }
static c_type createInstanceType( c_type messageType, d_topicInfo topicInfo) { c_type instanceType, baseType, foundType; c_metaObject o; c_char *name; c_long length,sres; c_base base; base = c_getBase(messageType); baseType = c_resolve(base,"durabilityModule2::d_instanceTemplate"); assert(baseType != NULL); instanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS)); c_class(instanceType)->extends = c_class(baseType); foundType = createTopicKeyType(messageType, topicInfo->keyExpr); if ( foundType != NULL) { o = c_metaDeclare(c_metaObject(instanceType),"key",M_ATTRIBUTE); c_property(o)->type = foundType; c_free(o); } c_metaObject(instanceType)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(instanceType)); #define INSTANCE_NAME "d_instance<d_sample<>>" #define INSTANCE_FORMAT "d_instance<d_sample<%s>>" length = sizeof(INSTANCE_NAME) + strlen(topicInfo->name); name = os_malloc(length); sres = snprintf(name,length,INSTANCE_FORMAT,topicInfo->name); assert(sres == (length-1)); #undef INSTANCE_NAME #undef INSTANCE_FORMAT foundType = c_type(c_metaBind(c_metaObject(base), name, c_metaObject(instanceType))); os_free(name); c_free(instanceType); return foundType; }
static c_type createSampleType( c_type messageType, const c_char* topicName) { c_base base; c_type sampleType, baseType, foundType, found; c_metaObject o; c_char *name; c_long length,sres; base = c_getBase(messageType); baseType = c_resolve(base, "durabilityModule2::d_sample"); assert(baseType != NULL); sampleType = c_type(c_metaDefine(c_metaObject(base),M_CLASS)); c_class(sampleType)->extends = c_class(baseType); o = c_metaDefine(c_metaObject(sampleType),M_ATTRIBUTE); c_property(o)->type = c_keep(messageType); found = c_type(c_metaBind(c_metaObject(sampleType),"message",o)); c_free(o); c_free(found); c_metaObject(sampleType)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(sampleType)); #define SAMPLE_NAME "d_sample<>" #define SAMPLE_FORMAT "d_sample<%s>" /* Create a name and bind type to name */ /* The sizeof contains \0 */ length = sizeof(SAMPLE_NAME) + strlen(topicName); name = os_malloc(length); sres = snprintf(name,length,SAMPLE_FORMAT,topicName); assert(sres == (length-1)); #undef SAMPLE_NAME #undef SAMPLE_FORMAT foundType = c_type(c_metaBind(c_metaObject(base), name, c_metaObject(sampleType))); os_free(name); c_free(sampleType); return foundType; }
void createField( v_entity entity, c_voidp argument ) { c_type type; c_metaObject userData; struct createFieldArg * arg = (struct createFieldArg *)argument; type = c_resolve(c_getBase(entity), arg->typeName); assert(type != NULL); userData = c_metaResolve(c_metaObject(type), arg->fieldName); c_free(type); arg->fieldOffset = c_property(userData)->offset; c_free(userData); }
static c_type messageTypeNew( c_base base, const c_char *typeName) { c_metaObject o; c_type baseType,dataType,type, foundType; c_char *name; c_long length, sres; if (base == NULL) { return NULL; } dataType = c_resolve(base,typeName); if (dataType == NULL) { return NULL; } baseType = c_resolve(base, "kernelModule::v_message"); assert(baseType != NULL); type = c_type(c_metaDefine(c_metaObject(base),M_CLASS)); c_class(type)->extends = c_keep(c_class(baseType)); o = c_metaDeclare(c_metaObject(type), USERDATA_FIELD_NAME, M_ATTRIBUTE); c_property(o)->type = dataType; c_free(o); c_metaObject(type)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(type)); #define MESSAGE_FORMAT "v_message<%s>" #define MESSAGE_NAME "v_message<>" length = sizeof(MESSAGE_NAME) + strlen(typeName); name = os_malloc(length); sres = snprintf(name,length,MESSAGE_FORMAT,typeName); assert(sres == (length-1)); #undef MESSAGE_FORMAT #undef MESSAGE_NAME foundType = c_type(c_metaBind(c_metaObject(base),name,c_metaObject(type))); os_free(name); c_free(type); return foundType; }
static void getCopyInfo ( v_entity e, c_voidp argument) { v_topic kt; c_type sampleType; c_property messageAttr; _DataReader dataReader = (_DataReader)argument; sampleType = v_dataReaderSampleType(v_dataReader(e)); kt = v_dataReaderGetTopic(v_dataReader(e)); dataReader->userdataOffset = v_topicDataOffset(kt); c_free(kt); messageAttr = c_property(c_metaResolve(c_metaObject(sampleType),"message")); dataReader->messageOffset = messageAttr->offset; c_free(messageAttr); }
static c_bool sd_deepwalkInterface( c_metaObject object, c_metaWalkActionArg actionArg) { sd_interfaceContext context = (sd_interfaceContext)actionArg; c_property property; c_object propertyData; /* For now, we are interested in properties only */ assert(c_baseObject(object)->kind == M_ATTRIBUTE); property = c_property(object); propertyData = C_DISPLACE(*context->objectPtr, property->offset); sd_deepwalkType(property->type, &propertyData, context->action, context->actionArg); return TRUE; }
static void copyInterfaceReferences( c_interface m, c_voidp dest, c_voidp data) { c_long i,length; c_property property; c_type type; c_object *ref; if (m->references == NULL) { return; } length = c_arraySize(m->references); for (i=0;i<length;i++) { property = c_property(m->references[i]); type = c_typeActualType(property->type); switch (c_baseObject(type)->kind) { case M_CLASS: case M_INTERFACE: case M_COLLECTION: case M_BASE: ref = C_DISPLACE(dest,property->offset); c_copyIn(type,C_REFGET(data,property->offset),ref); break; case M_EXCEPTION: case M_STRUCTURE: case M_UNION: copyReferences(type,C_DISPLACE(dest,property->offset), C_DISPLACE(data,property->offset)); break; default: assert(FALSE); break; } } }
static c_bool c_deepwalkProperty( c_metaObject object, c_metaWalkActionArg actionArg) { c_interfaceContext context = (c_interfaceContext)actionArg; c_property property; c_type propertyType; c_object propertyData; /* For now, we are interested in properties only */ if (c_baseObject(object)->kind == M_ATTRIBUTE) { property = c_property(object); propertyType = c_typeActualType(property->type); /* For now, skip attributes which are class-references */ propertyData = C_DISPLACE(*context->objectPtr, (c_address)property->offset); c_deepwalkType(propertyType, &propertyData, context->action, context->actionArg); } return TRUE; }
struct v_messageExtCdrInfo * v_messageExtCdrInfoNew( c_type topicMessageType, const struct sd_cdrControl *control) { static const char headerTypeName[] = "kernelModule::v_messageExt"; c_base base = c_getBase (topicMessageType); c_property userDataProperty = c_property(c_metaResolve(c_metaObject(topicMessageType),"userData")); c_type topicDataType = userDataProperty->type; c_type headerClass = c_resolve (base, headerTypeName); c_type dataClass; c_type type; c_object o; c_array members; struct v_messageExtCdrInfo *xci; struct c_type_s const *tstk[2]; c_free(userDataProperty); /* Wrap user data in a class, so that we can make a struct with a pointer to it */ dataClass = c_type(c_metaDefine(c_metaObject(base), M_CLASS)); c_class(dataClass)->extends = NULL; o = c_metaDeclare(c_metaObject(dataClass), "userData", M_ATTRIBUTE); c_property(o)->type = c_keep(topicDataType); c_metaObject(dataClass)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(dataClass)); c_free(o); /* Make a struct containing two pointers, one to the v_messageExt class, and one to the just-created anonymous dataClass type, corresponding to struct v_messageExtCdrTmp */ type = c_type(c_metaDefine(c_metaObject(base),M_STRUCTURE)); members = c_arrayNew(c_member_t(base),2); members[0] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER); c_specifier(members[0])->name = c_stringNew(base,"h"); c_specifier(members[0])->type = c_keep(headerClass); members[1] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER); c_specifier(members[1])->name = c_stringNew(base,"d"); c_specifier(members[1])->type = c_keep(dataClass); c_structure(type)->members = members; c_metaObject(type)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(type)); c_free(dataClass); c_free(headerClass); xci = os_malloc(sizeof(*xci)); xci->ci = sd_cdrInfoNewControl(type, control); /* Note: current simplistic annotation processing requires the annotations to be made in the order in which they are encountered when walking the type */ tstk[0] = type; tstk[1] = headerClass; if (sd_cdrNoteQuietRef(xci->ci, 2, tstk) < 0) { goto err_note; } tstk[1] = dataClass; if (sd_cdrNoteQuietRef(xci->ci, 2, tstk) < 0) { goto err_note; } if (sd_cdrCompile(xci->ci) < 0) { goto err_compile; } xci->vmsgType = c_keep(topicMessageType); c_free(type); return xci; err_compile: err_note: os_free(xci); c_free(type); return NULL; }
c_field c_fieldNew ( c_type type, const c_char *fieldName) { c_array path; c_field field; c_metaObject o; c_long n,length; c_address offset; c_iter nameList, refsList; c_string name; c_base base; if ((fieldName == NULL) || (type == NULL)) { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "illegal parameter"); return NULL; } base = c__getBase(type); if (base == NULL) { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to retreive base"); return NULL; } nameList = c_splitString(fieldName,"."); length = c_iterLength(nameList); field = NULL; if (length > 0) { o = NULL; offset = 0; refsList = NULL; path = c_newArray(c_fieldPath_t(base),length); if (path) { for (n=0;n<length;n++) { name = c_iterTakeFirst(nameList); o = c_metaResolve(c_metaObject(type),name); os_free(name); if (o == NULL) { c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); c_iterFree(refsList); c_free(path); return NULL; } path[n] = o; switch (c_baseObject(o)->kind) { case M_ATTRIBUTE: case M_RELATION: type = c_property(o)->type; offset += c_property(o)->offset; break; case M_MEMBER: type = c_specifier(o)->type; offset += c_member(o)->offset; break; default: c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); c_iterFree(refsList); c_free(path); return NULL; } switch (c_baseObject(type)->kind) { case M_INTERFACE: case M_CLASS: case M_COLLECTION: /*Longs are inserted in an iterator? Explanation please...*/ refsList = c_iterInsert(refsList,(c_voidp)offset); offset = 0; break; default: break; } } if (offset > 0) { refsList = c_iterInsert(refsList,(c_voidp)offset); } field = c_new(c_field_t(base)); field->name = c_stringNew(base,fieldName); field->path = path; field->type = c_keep(type); field->kind = c_metaValueKind(o); field->refs = NULL; if (refsList) { length = c_iterLength(refsList); field->offset = 0; if (length > 0) { field->refs = c_newArray(c_fieldRefs_t(base),length); if (field->refs) { for (n=(length-1);n>=0;n--) { field->refs[n] = c_iterTakeFirst(refsList); } } else { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to allocate field->refs array"); c_free(field); field = NULL; } } c_iterFree(refsList); } else { field->offset = offset; } } else { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to allocate field->path array"); c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); } c_iterFree(nameList); } else { OS_REPORT_1(OS_ERROR, "c_fieldNew failed",0, "failed to process field name <%s>", fieldName); } return field; }
static c_bool c__cloneReferences ( c_type type, c_voidp data, c_voidp dest) { c_type refType; c_class cls; c_array references, labels, ar, destar; c_sequence seq, destseq; c_property property; c_member member; c_long i,j,length,size; c_long nrOfRefs,nrOfLabs; c_value v; switch (c_baseObject(type)->kind) { case M_CLASS: cls = c_class(type); while (cls) { length = c_arraySize(c_interface(cls)->references); for (i=0;i<length;i++) { property = c_property(c_interface(cls)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } cls = cls->extends; } break; case M_INTERFACE: length = c_arraySize(c_interface(type)->references); for (i=0;i<length;i++) { property = c_property(c_interface(type)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } break; case M_EXCEPTION: case M_STRUCTURE: length = c_arraySize(c_structure(type)->references); for (i=0;i<length;i++) { member = c_member(c_structure(type)->references[i]); refType = c_specifier(member)->type; _cloneReference(refType, C_DISPLACE(data, member->offset), C_DISPLACE(dest, member->offset)); } break; case M_UNION: #define _CASE_(k,t) case k: v = t##Value(*((t *)data)); break switch (c_metaValueKind(c_metaObject(c_union(type)->switchType))) { _CASE_(V_BOOLEAN, c_bool); _CASE_(V_OCTET, c_octet); _CASE_(V_SHORT, c_short); _CASE_(V_LONG, c_long); _CASE_(V_LONGLONG, c_longlong); _CASE_(V_USHORT, c_ushort); _CASE_(V_ULONG, c_ulong); _CASE_(V_ULONGLONG, c_ulonglong); _CASE_(V_CHAR, c_char); _CASE_(V_WCHAR, c_wchar); default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal union switch type detected"); assert(FALSE); return FALSE; break; } #undef _CASE_ references = c_union(type)->references; if (references != NULL) { i=0; refType=NULL; nrOfRefs = c_arraySize(references); while ((i<nrOfRefs) && (refType == NULL)) { labels = c_unionCase(references[i])->labels; j=0; nrOfLabs = c_arraySize(labels); while ((j<nrOfLabs) && (refType == NULL)) { if (c_valueCompare(v,c_literal(labels[j])->value) == C_EQ) { c__cloneReferences(c_type(references[i]), C_DISPLACE(data, c_type(type)->alignment), C_DISPLACE(dest, c_type(type)->alignment)); refType = c_specifier(references[i])->type; } j++; } i++; } } break; case M_COLLECTION: refType = c_typeActualType(c_collectionType(type)->subType); switch (c_collectionType(type)->kind) { case C_ARRAY: ar = c_array(data); destar = c_array(dest); length = c_collectionType(type)->maxSize; if (length == 0) { length = c_arraySize(ar); } if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, ar[i], &destar[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(data, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; case C_SEQUENCE: seq = c_sequence(data); destseq = c_sequence(dest); length = c_sequenceSize(seq); if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, seq[i], &destseq[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(seq, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal collectionType found"); break; } break; case M_BASE: break; case M_TYPEDEF: c__cloneReferences(c_type(c_typeDef(type)->alias), data, dest); break; case M_ATTRIBUTE: case M_RELATION: refType = c_typeActualType(c_property(type)->type); _cloneReference(refType, C_DISPLACE(data, c_property(type)->offset), C_DISPLACE(dest, c_property(type)->offset)); break; case M_MEMBER: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, C_DISPLACE(data, c_member(type)->offset), C_DISPLACE(dest, c_member(type)->offset)); break; case M_UNIONCASE: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, data, dest); break; case M_MODULE: /* Do nothing */ break; case M_PRIMITIVE: /* Do nothing */ break; case M_EXTENT: case M_EXTENTSYNC: default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal meta object specified"); assert(FALSE); return FALSE; } return TRUE; }
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; }
void v_indexInit( v_index index, c_type instanceType, c_array keyList, v_reader reader) { c_property keyProperty; c_structure keyStructure; c_char fieldName[16]; c_char *keyExpr; c_size i,nrOfKeys,totalSize; assert(index != NULL); assert(C_TYPECHECK(index,v_index)); assert(C_TYPECHECK(instanceType,c_type)); keyProperty = c_property(c_metaResolve(c_metaObject(instanceType),"key")); if (keyProperty) { keyStructure = c_structure(keyProperty->type); nrOfKeys = c_arraySize(keyStructure->members); c_free(keyProperty); } else { nrOfKeys = 0; } if (nrOfKeys>0) { totalSize = nrOfKeys * strlen("key.field0,"); if (nrOfKeys > 9) { /* For each key number greater than one digit * i.e. number of keys > 9 add one additional * character space to the total size. */ totalSize += (nrOfKeys-9); if (nrOfKeys > 99) { /* For each key number greater than two digits * i.e. number of keys > 99 add one additional * character space to the total size. */ totalSize += (nrOfKeys-99); } } keyExpr = (char *)os_alloca(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; } index->reader = reader; index->sourceKeyList = createKeyList(instanceType, keyList); index->messageKeyList = c_keep(keyList); /* keyList is either topic->messageKeyList or a user-defined keylist */ index->objects = c_tableNew(instanceType,keyExpr); index->notEmptyList = c_tableNew(instanceType,keyExpr); if(keyExpr){ os_freea(keyExpr); } index->objectType = c_keep(instanceType); }
static c_type sampleTypeNew( v_topic topic) { c_metaObject o; c_type msgType,sampleType,foundType; c_base base; c_char *name; os_size_t length; int sres; assert(C_TYPECHECK(topic,v_topic)); assert(topic); name = NULL; foundType = NULL; if (v_topicName(topic) == NULL) { OS_REPORT(OS_ERROR, "v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM, "failed to retreive topic name"); return NULL; } base = c_getBase(topic); if (base == NULL) { OS_REPORT(OS_ERROR, "v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM, "failed to retreive base"); return NULL; } msgType = c_keep(v_topicMessageType(topic)); if (msgType == NULL) { OS_REPORT(OS_ERROR, "v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM, "failed to retreive topic message type"); return NULL; } sampleType = c_type(c_metaDefine(c_metaObject(base),M_CLASS)); if (sampleType) { c_class(sampleType)->extends = v_dataReaderSample_t(base); o = c_metaDeclare(c_metaObject(sampleType),"message",M_ATTRIBUTE); if (o) { c_property(o)->type = c_keep(msgType); c_metaObject(sampleType)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(sampleType)); #define SAMPLE_FORMAT "v_indexSample<%s>" #define SAMPLE_NAME "v_indexSample<>" /* sizeof contains \0 */ length = sizeof(SAMPLE_NAME) + strlen(v_topicName(topic)); name = os_malloc(length); sres = snprintf(name,length,SAMPLE_FORMAT,v_topicName(topic)); assert(sres >= 0 && (os_size_t) sres == (length-1)); OS_UNUSED_ARG(sres); #undef SAMPLE_FORMAT #undef SAMPLE_NAME foundType = c_type(c_metaBind(c_metaObject(base), name, c_metaObject(sampleType))); c_free(o); } else { foundType = NULL; } c_free(sampleType); } else { OS_REPORT(OS_ERROR, "v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM, "failed to retreive topic sample type"); } os_free(name); c_free(msgType); return foundType; }