Example #1
0
/*  Description:     Call begin, check that the first field is returned, then
 *                   call next, and check that the first field is returned again,
 *                   then call next again, and ensure that the second field is
 *                   returned.
 *
 *  Expected Result: First  Check: fid - 101, value - 8
 *                   Second Check: fid - 101, value - 8
 *                   Third  Check: fid - 102, value - "This is an iteration test."
 */
TEST_F (MsgNewIteratorTestC, IteratorBeginNext)
{
    mama_fid_t      fid      = 0;
    mama_u8_t       content  = 0;
    const char*     strContent;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU8 (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ (101, fid);
    ASSERT_EQ (8, content);

    field = mamaMsgIterator_next (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU8 (field, &content);

    /* Ensure we return the first field again: */
    ASSERT_EQ (101, fid);
    ASSERT_EQ (8, content);

    field = mamaMsgIterator_next (iterator);

    mamaMsgField_getFid      (field, &fid);
    mamaMsgField_getString   (field, &strContent);

    /* Ensure we return the first field again: */
    ASSERT_EQ (102, fid);
    ASSERT_STREQ ("This is an iteration test.", strContent);
}
Example #2
0
/*  Description:     Step into the message, determine if it has a next value, 
 *                   retrieve and check the contents of that value.
 *
 *  Expected Result: Non-zero return for hasNext
 */
TEST_F (MsgNewIteratorTestC, IteratorHasNext)
{
    mama_fid_t      fid      = 0;
    mama_u64_t      content  = 0;
    mama_bool_t     hasNext  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU64 (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ(values[fid], content);

    field = mamaMsgIterator_next (iterator);

    /* Ensure we return the first field again: */
    ASSERT_EQ(values[fid], content);

    /* Check if we have a next value: */
    hasNext = mamaMsgIterator_hasNext (iterator);

    ASSERT_NE (0, hasNext);

    /* Get the next value */
    field = mamaMsgIterator_next (iterator);
    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU64 (field, &content);

    /* Ensure we return the first field again: */
    ASSERT_EQ(values[fid], content);
}
Example #3
0
void MAMACALLTYPE
displayCb  (const mamaMsg       msg,
            const mamaMsgField  field,
            void*               closure)
{
    char         value[256] = "";
    const char*  typeName   = "(null)";
    const char*  fieldName  = "(null)";
    uint16_t     fid        = 0;

    if  (MAMA_STATUS_OK != mamaMsgField_getTypeName  (field,&typeName))
    {
        printf ("Failed to get type name\n");
        return;
    }
    if  (MAMA_STATUS_OK != mamaMsgField_getName      (field,&fieldName))
    {
        printf ("Failed to get name\n");
        return;
    }
    if  (MAMA_STATUS_OK != mamaMsgField_getFid       (field,&fid))
    {
        printf ("Failed to get Fid\n");
        return;
    }

    if  (MAMA_STATUS_OK != mamaMsgField_getAsString  (field, value, 256))
    {
        printf ("Failed to get field: %d:%s\n", fid, fieldName);
        return;
    }

    printf ("    %20s %5u %20s %20s\n", fieldName, fid, typeName, value);
}
Example #4
0
/*  Description:     Step to the end of the message, check if it has a next,
 *                   expecting that it does not.
 *
 *  Expected Result: Zero return for hasNext
 */
TEST_F (MsgNewIteratorTestC, IteratorHasNoNext)
{
    mama_fid_t      fid      = 0;
    mama_u64_t      content  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU64 (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ(values[fid], content);

    field = mamaMsgIterator_next (iterator);

    /* Ensure we return the first field again: */
    ASSERT_EQ(values[fid], content);

    /* Move to the last message: */
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);

    /* Move past last message - should not crash */
    field = mamaMsgIterator_next (iterator);
    ASSERT_EQ(NULL, field);

    /* Check if we have a next value: */
    ASSERT_EQ (0, mamaMsgIterator_hasNext (iterator));
}
Example #5
0
/*  Description:     Step to the end of the message, check if it has a next,
 *                   expecting that it does not.
 *
 *  Expected Result: Zero return for hasNext
 */
TEST_F (MsgNewIteratorTestC, IteratorHasNoNext)
{
    mama_fid_t      fid      = 0;
    mama_u8_t       content  = 0;
    mama_bool_t     hasNext  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU8 (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ (101, fid);
    ASSERT_EQ (8, content);

    field = mamaMsgIterator_next (iterator);

    /* Ensure we return the first field again: */
    ASSERT_EQ (101, fid);
    ASSERT_EQ (8, content);

    /* Move to the last message: */
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);
    field = mamaMsgIterator_next (iterator);

    /* Check if we have a next value: */
    hasNext = mamaMsgIterator_hasNext (iterator);

    ASSERT_EQ (0, hasNext);
}
Example #6
0
static void msgOnField (const mamaMsg	   msg,
                        const mamaMsgField field,
                        void*              closure)
{
    
    mama_fid_t    fid  = 0;
    mamaFieldType type = MAMA_FIELD_TYPE_UNKNOWN;    
    
    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getType (field, &type);
    switch(type)
    {
        case MAMA_FIELD_TYPE_STRING:
        {
            char buffer[MAX_FIELD_STR_LEN];
            ASSERT_EQ (101, fid);
            mamaMsgField_getAsString (field, buffer, MAX_FIELD_STR_LEN);
            ASSERT_STREQ ("This is an iteration test.", buffer);
            break;
        }
        case MAMA_FIELD_TYPE_U8:
        {
            mama_u8_t buffer = 0;
            ASSERT_EQ (102, fid);
            mamaMsgField_getU8 (field, &buffer);
            ASSERT_EQ (8, buffer);
            break;
        }
        case MAMA_FIELD_TYPE_U16:
        {
            mama_u16_t buffer = 0;
            ASSERT_EQ (103, fid);
            mamaMsgField_getU16 (field, &buffer);
            ASSERT_EQ (16, buffer);
            break;
        }
        case MAMA_FIELD_TYPE_U32:
        {
            mama_u32_t buffer = 0;
            ASSERT_EQ (104, fid);
            mamaMsgField_getU32 (field, &buffer);
            ASSERT_EQ (32, buffer);
            break;
        }
        case MAMA_FIELD_TYPE_U64:
        {
            mama_u64_t buffer = 0;
            ASSERT_EQ (105, fid);
            mamaMsgField_getU64 (field, &buffer);
            ASSERT_EQ (64, buffer);
            break;
        }
        default:
            break;
    }
    
    ASSERT_EQ ((void*)2, closure);
}
Example #7
0
/*  Description:     Call begin on the already associated mamaMsgIterator, and
 *                   check that the contents of the first field are returned.
 *
 *  Expected Result: Fid should be 101, value should be 8.
 */
TEST_F (MsgNewIteratorTestC, IteratorBegin)
{
    mama_fid_t      fid      = 0;
    mama_u64_t      content  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU64 (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ(values.at(fid), content);
}
static void MAMACALLTYPE
maxIterator(const mamaMsg       msg,
            const mamaMsgField  field,
            void*               closure)
{
    mamaDictionaryImpl*  impl = (mamaDictionaryImpl*) closure;
    mama_fid_t           fid  = 0;
    if (MAMA_STATUS_OK == mamaMsgField_getFid(field, &fid))
    {
        if (impl->mMaxFid < fid)
            impl->mMaxFid = fid;
    }
}
Example #9
0
/*  Description:     Call begin on the already associated mamaMsgIterator, and
 *                   check that the contents of the first field are returned.
 *
 *  Expected Result: Fid should be 101, value should be 8.
 */
TEST_F (MsgNewIteratorTestC, IteratorBegin)
{
    mama_fid_t      fid      = 0;
    mama_u8_t       content  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU8  (field, &content);

    /* Check the contents of the field: */
    ASSERT_EQ (101, fid);
    ASSERT_EQ (8, content);
}
Example #10
0
/*  Description:     Call begin, check that the first field is returned, then
 *                   call next, and check that the first field is returned again,
 *                   then call next again, until all fields are confirmed.
 */
TEST_F (MsgNewIteratorTestC, IteratorBeginNext)
{
    mama_fid_t      fid      = 0;
    mama_u64_t      content  = 0;

    field = mamaMsgIterator_begin (iterator);

    mamaMsgField_getFid (field, &fid);
    mamaMsgField_getU64 (field, &content);

    /* Check the contents of the field match legal entry */
    ASSERT_EQ(values.at(fid), content);

    field = mamaMsgIterator_next (iterator);

    mamaMsgField_getFid (field, &fid);

    /* Ensure we return the first field again: */
    ASSERT_EQ(values[fid], content);

    /* Remove from reference map */
    values.erase(fid);

    /* For the 4 remaining fields, check contents */
    for (int i = 0; i < 4; i++)
    {
        field = mamaMsgIterator_next (iterator);
        mamaMsgField_getFid (field, &fid);
        mamaMsgField_getU64 (field, &content);
        ASSERT_EQ(values[fid], content);
        /* Remove from reference map */
        values.erase(fid);
    }

    /* Gotta catch 'em all */
    EXPECT_EQ(0, values.size());
}
Example #11
0
mama_status mamaFieldCache_updateCacheFromMsgField(mamaFieldCache fieldCache,
                                                   const mamaMsgField messageField)
{
    mama_status ret;
    mama_fid_t fid;
    mamaFieldType type = MAMA_FIELD_TYPE_UNKNOWN;
    const char* name = NULL;
    mamaFieldDescriptor descriptor = NULL;
    mamaFieldCacheField field = NULL;

    ret = mamaMsgField_getFid(messageField, &fid);
    if (ret != MAMA_STATUS_OK)
    {
        return ret;
    }

    if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &field))
    {
        ret = mamaMsgField_getType(messageField, &type);
        if (ret != MAMA_STATUS_OK)
        {
            return ret;
        }
        if (fieldCache->mUseFieldNames)
        {
            mamaMsgField_getName(messageField, &name);
        }
        mamaFieldCacheField_create(&field, fid, type, name);
        ret = mamaFieldCacheMap_add(fieldCache->mMap, field);
        if (ret != MAMA_STATUS_OK)
        {
            return ret;
        }
        fieldCache->mSize++;

        mamaMsgField_getDescriptor(messageField, &descriptor);
        if (descriptor)
        {
            mamaFieldCacheField_setDescriptor(field, descriptor);
        }
    }
    else
    {
        type = field->mType;
    }

    if (fieldCache->mTrackModified && field->mPublish && !field->mIsModified)
    {
        field->mIsModified = 1;
        mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)field);
    }

    switch (type)
    {
        case MAMA_FIELD_TYPE_BOOL:
        {
            mama_bool_t result;
            mamaMsgField_getBool(messageField, &result);
            mamaFieldCacheField_setBool(field, result);
            break;
        }
        case MAMA_FIELD_TYPE_CHAR:
        {
            char value;
            mamaMsgField_getChar(messageField, &value);
            mamaFieldCacheField_setChar(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_I8:
        {
            mama_i8_t value;
            mamaMsgField_getI8(messageField, &value);
            mamaFieldCacheField_setI8(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_U8:
        {
            mama_u8_t value;
            mamaMsgField_getU8(messageField, &value);
            mamaFieldCacheField_setU8(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_I16:
        {
            mama_i16_t value;
            mamaMsgField_getI16(messageField, &value);
            mamaFieldCacheField_setI16(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_U16:
        {
            mama_u16_t value;
            mamaMsgField_getU16(messageField, &value);
            mamaFieldCacheField_setU16(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_I32:
        {
            mama_i32_t value;
            mamaMsgField_getI32(messageField, &value);
            mamaFieldCacheField_setI32(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_U32:
        {
            mama_u32_t value;
            mamaMsgField_getU32(messageField, &value);
            mamaFieldCacheField_setU32(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_I64:
        {
            mama_i64_t value;
            mamaMsgField_getI64(messageField, &value);
            mamaFieldCacheField_setI64(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_U64:
        {
            mama_u64_t value;
            mamaMsgField_getU64(messageField, &value);
            mamaFieldCacheField_setU64(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_F32:
        {
            mama_f32_t value;
            mamaMsgField_getF32(messageField, &value);
            mamaFieldCacheField_setF32(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_QUANTITY:
        case MAMA_FIELD_TYPE_F64:
        {
            mama_f64_t value;
            mamaMsgField_getF64(messageField, &value);
            mamaFieldCacheField_setF64(field, value);
            break;
        }
        case MAMA_FIELD_TYPE_STRING:
        {
            const char* value = NULL;
            mamaMsgField_getString(messageField, &value);
            mamaFieldCacheField_setString(field, value, 0);
            break;
        }
        case MAMA_FIELD_TYPE_PRICE:
        {
            mamaMsgField_getPrice(messageField, fieldCache->mReusablePrice);
            mamaFieldCacheField_setPrice(field, fieldCache->mReusablePrice);
            break;
        }
        case MAMA_FIELD_TYPE_TIME:
        {
            mamaMsgField_getDateTime(messageField, fieldCache->mReusableDateTime);
            mamaFieldCacheField_setDateTime(field, fieldCache->mReusableDateTime);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I8:
        {
            const mama_i8_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorI8(messageField, &values, &size);
            mamaFieldCacheField_setI8Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U8:
        {
            const mama_u8_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorU8(messageField, &values, &size);
            mamaFieldCacheField_setU8Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I16:
        {
            const mama_i16_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorI16(messageField, &values, &size);
            mamaFieldCacheField_setI16Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U16:
        {
            const mama_u16_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorU16(messageField, &values, &size);
            mamaFieldCacheField_setU16Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I32:
        {
            const mama_i32_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorI32(messageField, &values, &size);
            mamaFieldCacheField_setI32Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U32:
        {
            const mama_u32_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorU32(messageField, &values, &size);
            mamaFieldCacheField_setU32Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I64:
        {
            const mama_i64_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorI64(messageField, &values, &size);
            mamaFieldCacheField_setI64Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U64:
        {
            const mama_u64_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorU64(messageField, &values, &size);
            mamaFieldCacheField_setU64Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_F32:
        {
            const mama_f32_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorF32(messageField, &values, &size);
            mamaFieldCacheField_setF32Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_F64:
        {
            const mama_f64_t* values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorF64(messageField, &values, &size);
            mamaFieldCacheField_setF64Vector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_STRING:
        {
            const char** values = NULL;
            mama_size_t size = 0;
            mamaMsgField_getVectorString(messageField, &values, &size);
            mamaFieldCacheField_setStringVector(field, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_PRICE:
        {
            /* TODO: mamaMsgField does not provide methods to get price vector
            const mamaPrice* values = NULL;
            mama_size_t size;
            mamaMsgField_getVectorPrice(messageField, &values, &size);
            mamaFieldCacheField_setPriceVector(field, values, size);
             */
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_TIME:
        {
            /* TODO: mamaMsgField does not provide methods to get time vector
            const mamaDateTime* values = NULL;
            mama_size_t size;
            mamaMsgField_getVectorDateTime(messageField, &values, &size);
            mamaFieldCacheField_setDateTimeVector(field, values, size);
             */
            break;
        }
        default:
            break;
    }
    return ret;
}
int main (int argc, const char **argv)
{

	mamaPlaybackFileParser	fileParser		= NULL;
	mamaPlaybackCapture		fileCapture		= NULL;
	char*           		headerString	= NULL;
	mamaMsg        			sourceMsg		= NULL;
	mamaMsg					targetMsg		= NULL;
	mamaMsgField			aField 			= NULL;
	mamaBridge        		gMamaBridge     = NULL;
    mamaMsgIterator 		iterator 		= NULL;
    mamaFieldType 			fieldType		= MAMA_FIELD_TYPE_UNKNOWN;
    parseCommandLine (argc, argv);

     mama_loadBridge (&gMamaBridge, "wmw");
     mama_loadBridge (&gMamaBridge, "avis");
     mama_open ();

    mamaPlaybackFileParser_allocate (&fileParser);
    mamaPlaybackFileParser_openFile(fileParser, (char*)gInputFilename);

    mamaCapture_allocate(&fileCapture);
    mamaCapture_openFile (&fileCapture, gOutputFilename);

    mamaMsgIterator_create(&iterator, NULL);

    mamaMsg_createForPayload(&targetMsg, 'A');

    while (mamaPlaybackFileParser_getNextHeader(fileParser, &headerString))
    {
        if (mamaPlaybackFileParser_getNextMsg (fileParser,
                                                &sourceMsg))
        {
            char 	temp[64];
            char*	start = headerString;
            char*	end = strchr (headerString,':');

            strncpy (temp,start, end-start); temp[end-start]='\0';
            mamaCapture_setFeedSource (&fileCapture, temp);
            end++;
            start=end;
            end = strchr (start,':');
            strncpy (temp,start, end-start);temp[end-start]='\0';
            mamaCapture_setTransportName (&fileCapture, temp);
            end++;
            start=end;
            end = strchr (start,'\0');
            strncpy (temp,start, end-start);temp[end-start]='\0';
            mamaCapture_setSymbol (&fileCapture, temp);

			mamaMsgIterator_associate(iterator, sourceMsg);
			mamaMsg_clear(targetMsg);

			while ((aField = mamaMsgIterator_next(iterator)) != NULL)
			{
				uint16_t        fid             = 0;
				mamaMsgField_getFid(aField, &fid);
				mamaMsgField_getType(aField, &fieldType);
				switch (fieldType)
				{

					case  MAMA_FIELD_TYPE_BOOL:
		               { mama_bool_t result;
		                mamaMsgField_getBool (aField, &result);
						mamaMsg_addBool(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_CHAR:
						{char result;
		                mamaMsgField_getChar (aField, &result);
						mamaMsg_addChar(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_I8:
		                {mama_i8_t result;
		                mamaMsgField_getI8 (aField, &result);
						mamaMsg_addI8(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_U8:
		                {mama_u8_t result;
		                mamaMsgField_getU8 (aField, &result);
						mamaMsg_addU8(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_I16:
		                {mama_i16_t result;
		                mamaMsgField_getI16 (aField, &result);
						mamaMsg_addI16(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_U16:
		                {mama_u16_t result;
		                mamaMsgField_getU16 (aField, &result);
						mamaMsg_addU16(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_I32:
		                {mama_i32_t result;
		                mamaMsgField_getI32 (aField, &result);
						mamaMsg_addI32(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_U32:
		                {mama_u32_t result;
		                mamaMsgField_getU32 (aField, &result);
						mamaMsg_addU32(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_I64:
		                {mama_i64_t result;
		                mamaMsgField_getI64 (aField, &result);
						mamaMsg_addI64(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_U64:
		                {mama_u64_t result;
		                mamaMsgField_getU64 (aField, &result);
						mamaMsg_addU64(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_F32:
		                {mama_f32_t result;
		                mamaMsgField_getF32 (aField, &result);
						mamaMsg_addF32(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_F64:
		                {mama_f64_t result;
		                mamaMsgField_getF64 (aField, &result);
						mamaMsg_addF64(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_STRING:
						{const char* result;
		                mamaMsgField_getString (aField, &result);
						mamaMsg_addString(targetMsg, NULL, fid, result);
						}break;
					case  MAMA_FIELD_TYPE_TIME:
						{
							mamaDateTime result;
							mamaMsgField_getDateTime (aField, result);
							mamaMsg_addDateTime(targetMsg, NULL, fid, result);
						}break;
					case MAMA_FIELD_TYPE_PRICE:
						{
							mamaPrice result;
							mamaMsgField_getPrice(aField, result);
							mamaMsg_addPrice(targetMsg, NULL, fid, result);
						}break;
					default:
						case MAMA_FIELD_TYPE_VECTOR_I8:
						case MAMA_FIELD_TYPE_VECTOR_U8:
						case MAMA_FIELD_TYPE_VECTOR_I16:
						case MAMA_FIELD_TYPE_VECTOR_U16:
						case MAMA_FIELD_TYPE_VECTOR_I32:
						case MAMA_FIELD_TYPE_VECTOR_U32:
						case MAMA_FIELD_TYPE_VECTOR_I64:
						case MAMA_FIELD_TYPE_VECTOR_U64:
						case MAMA_FIELD_TYPE_VECTOR_F32:
						case MAMA_FIELD_TYPE_VECTOR_F64:
						case MAMA_FIELD_TYPE_VECTOR_STRING:
						case MAMA_FIELD_TYPE_VECTOR_MSG:
						case MAMA_FIELD_TYPE_VECTOR_TIME:
						case MAMA_FIELD_TYPE_VECTOR_PRICE:
						case MAMA_FIELD_TYPE_QUANTITY:
						case MAMA_FIELD_TYPE_COLLECTION :
						case MAMA_FIELD_TYPE_UNKNOWN:
						case MAMA_FIELD_TYPE_OPAQUE:
						case MAMA_FIELD_TYPE_MSG:
							break;
				}
			}
            mamaCapture_saveMamaMsg (&fileCapture, &targetMsg);
        }
    }

    mamaMsgIterator_destroy(iterator);
    mamaCapture_closeFile(fileCapture);
    mamaCapture_deallocate (fileCapture);
    mamaPlaybackFileParser_closeFile(fileParser);
    mamaPlaybackFileParser_deallocate (fileParser);
    return (0);
}
Example #13
0
TEST_F (MsgIterateTestC, CreateIterator)
{   
    mama_fid_t      fid         = 0;
    mamaMsgIterator iterator    = NULL;
    mamaMsgField    field       = NULL;
    mamaFieldType   type        = MAMA_FIELD_TYPE_UNKNOWN;    

    /* Create a mama message. */
    mamaMsg msg = NULL;
    mamaMsg_create (&msg);
    
    /* add a fields to the message. */
    mamaMsg_addString (msg, "string", 101, "This is an iteration test.");
    mamaMsg_addU8     (msg, "u8", 102, 8);
    mamaMsg_addU16    (msg, "u16", 103, 16);
    mamaMsg_addU32    (msg, "u32", 104, 32);
    mamaMsg_addU64    (msg, "u64", 105, 64);
   
    /* Create iterator and message field required.*/
    ASSERT_EQ (MAMA_STATUS_OK, 
               mamaMsgIterator_create (&iterator,NULL));
    
    mamaMsgIterator_associate (iterator,msg);
    
    while ((field = mamaMsgIterator_next(iterator)) != NULL)
    {
        /* Operate on contents of each field. */
        mamaMsgField_getFid (field, &fid);
        mamaMsgField_getType (field, &type);
        switch(type)
        {
            case MAMA_FIELD_TYPE_STRING:
            {
                char buffer[MAX_FIELD_STR_LEN];
                ASSERT_EQ (101, fid);
                mamaMsgField_getAsString (field, buffer, MAX_FIELD_STR_LEN);
                ASSERT_STREQ ("This is an iteration test.", buffer);
                break;
            }
            case MAMA_FIELD_TYPE_U8:
            {
                mama_u8_t buffer = 0;
                ASSERT_EQ (102, fid);
                mamaMsgField_getU8 (field, &buffer);
                ASSERT_EQ (8, buffer);
                break;
            }
            case MAMA_FIELD_TYPE_U16:
            {
                mama_u16_t buffer = 0;
                ASSERT_EQ (103, fid);
                mamaMsgField_getU16 (field, &buffer);
                ASSERT_EQ (16, buffer);
                break;
            }
            case MAMA_FIELD_TYPE_U32:
            {
                mama_u32_t buffer = 0;
                ASSERT_EQ (104, fid);
                mamaMsgField_getU32 (field, &buffer);
                ASSERT_EQ (32, buffer);
                break;
            }
            case MAMA_FIELD_TYPE_U64:
            {
                mama_u64_t buffer = 0;
                ASSERT_EQ (105, fid);
                mamaMsgField_getU64 (field, &buffer);
                ASSERT_EQ (64, buffer);
                break;
            }
            default:
                break;
        }
    }

    /* destroy the message. */
    mamaMsg_destroy (msg);
}
Example #14
-1
static void MAMACALLTYPE
dictMsgIterator (const mamaMsg       msg,
                 const mamaMsgField  field,
                 void*               closure)
{
    mamaDictionaryImpl*  impl           = (mamaDictionaryImpl*) closure;
    const char*          fieldName      = NULL;
    mama_fid_t           fid            = 0;
    mamaFieldType        type           = 0;
    const char*          val            = NULL;

    mamaMsgField_getType(field,&type);
    mamaMsgField_getFid(field,&fid);
    mamaMsgField_getName(field,&fieldName);
    
    if (MamaFieldFeedName.mFid == fid)
    {
        if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
        {
            checkFree(&impl->mFeedName);
            impl->mFeedName = copyString(val);
            mama_log ( MAMA_LOG_LEVEL_FINE,
                       "Dictionary source feed name: %s",
                       val);
        }
    }
    else if (MamaFieldFeedHost.mFid == fid)
    {
        if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
        {
            checkFree(&impl->mFeedHost);
            impl->mFeedHost = copyString(val);
            mama_log ( MAMA_LOG_LEVEL_FINE,
                       "Dictionary source hostname: %s",
                       val);
        }
    }
    
    mamaDictionary_createFieldDescriptor (impl,
                                       fid,
                                       fieldName,
                                       type,
                                       NULL);
}