mama_status mamaDQPublisherManager_sendSyncRequest (
mamaDQPublisherManager manager,
mama_u16_t nummsg,
mama_f64_t delay,
mama_f64_t duration)
{
mamaDQPublisherManagerImpl* impl = (mamaDQPublisherManagerImpl*) manager;
if (!impl->mSyncRequestMsg)
{
mamaInbox_create (&impl->mInbox,
impl->mTransport,
impl->mQueue,
inboxMsgCb,
inboxErrorCb,
impl);
mamaMsg_create(&impl->mSyncRequestMsg );
mamaMsg_addU16(impl->mSyncRequestMsg, NULL, MAMA_CM_COMMAND_ID, 1);
mamaMsg_addU16(impl->mSyncRequestMsg, NULL, MAMA_SYNC_TOPICS_PER_MSG_ID, nummsg);
mamaMsg_addF64(impl->mSyncRequestMsg, NULL, MAMA_SYNC_RESPONSE_DELAY_ID, delay);
mamaMsg_addF64(impl->mSyncRequestMsg, NULL, MAMA_SYNC_RESPONSE_DURATION_ID, duration);
mamaMsg_addString(impl->mSyncRequestMsg, NULL, MAMA_SYNC_SOURCE_ID, impl->mNameSpace);
}
return mamaPublisher_sendFromInbox (impl->mPublisher,
impl->mInbox,
impl->mSyncRequestMsg);
}
/* Description: Create a mamaMsg, add strings to fields in the message,
* and iterate through the fields printing values via
* callback method.
*
* Expected Result: MAMA_STATUS_OK
*/
TEST_F (MsgIterateTestC, IteratorCallback)
{
/* 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);
/* iterate through the msg's fields */
ASSERT_EQ (MAMA_STATUS_OK,
mamaMsg_iterateFields (msg, msgOnField, NULL, (void*) 2));
/* destroy the message. */
mamaMsg_destroy (msg);
}
void MsgNewIteratorTestC::SetUp(void)
{
mama_loadBridge (&mBridge, getMiddleware());
mama_open();
/* add a fields to the message. */
mamaMsg_create (&msg);
mamaMsg_addU8 (msg, "u8", 101, 8);
mamaMsg_addString (msg, "string", 102, "This is an iteration test.");
mamaMsg_addU16 (msg, "u16", 103, 16);
mamaMsg_addU32 (msg, "u32", 104, 32);
mamaMsg_addU64 (msg, "u64", 105, 64);
/* Build the MAMA Dictionary from our test message. */
mamaDictionary_create (&dict);
mamaDictionary_buildDictionaryFromMessage (dict, msg);
/* Create the message iterator */
mamaMsgIterator_create (&iterator, dict);
mamaMsgIterator_associate (iterator, msg);
}
mama_status mamaFieldCache_updateMsgField(mamaFieldCache fieldCache,
mamaFieldCacheField field,
mamaMsg message,
mama_bool_t useUpdate)
{
mama_status status = MAMA_STATUS_OK;
mama_fid_t fid;
mamaFieldType type;
const char* name = NULL;
mamaFieldCacheField_getFid(field, &fid);
mamaFieldCacheField_getType(field, &type);
if (fieldCache->mUseFieldNames)
{
mamaFieldCacheField_getName(field, &name);
}
switch (type)
{
case MAMA_FIELD_TYPE_BOOL:
{
mama_bool_t value;
mamaFieldCacheField_getBool(field, &value);
status = useUpdate ? mamaMsg_updateBool(message, name, fid, value)
: mamaMsg_addBool(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_CHAR:
{
char value;
mamaFieldCacheField_getChar(field, &value);
status = useUpdate ? mamaMsg_updateChar(message, name, fid, value)
: mamaMsg_addChar(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_I8:
{
mama_i8_t value;
mamaFieldCacheField_getI8(field, &value);
status = useUpdate ? mamaMsg_updateI8(message, name, fid, value)
: mamaMsg_addI8(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_U8:
{
mama_u8_t value;
mamaFieldCacheField_getU8(field, &value);
status = useUpdate ? mamaMsg_updateU8(message, name, fid, value)
: mamaMsg_addU8(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_I16:
{
mama_i16_t value;
mamaFieldCacheField_getI16(field, &value);
status = useUpdate ? mamaMsg_updateI16(message, name, fid, value)
: mamaMsg_addI16(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_U16:
{
mama_u16_t value;
mamaFieldCacheField_getU16(field, &value);
status = useUpdate ? mamaMsg_updateU16(message, name, fid, value)
: mamaMsg_addU16(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_I32:
{
mama_i32_t value;
mamaFieldCacheField_getI32(field, &value);
status = useUpdate ? mamaMsg_updateI32(message, name, fid, value)
: mamaMsg_addI32(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_U32:
{
mama_u32_t value;
mamaFieldCacheField_getU32(field, &value);
status = useUpdate ? mamaMsg_updateU32(message, name, fid, value)
: mamaMsg_addU32(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_I64:
{
mama_i64_t value;
mamaFieldCacheField_getI64(field, &value);
status = useUpdate ? mamaMsg_updateI64(message, name, fid, value)
: mamaMsg_addI64(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_U64:
{
mama_u64_t value;
mamaFieldCacheField_getU64(field, &value);
status = useUpdate ? mamaMsg_updateU64(message, name, fid, value)
: mamaMsg_addU64(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_F32:
{
mama_f32_t value;
mamaFieldCacheField_getF32(field, &value);
status = useUpdate ? mamaMsg_updateF32(message, name, fid, value)
: mamaMsg_addF32(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_QUANTITY:
case MAMA_FIELD_TYPE_F64:
{
mama_f64_t value;
mamaFieldCacheField_getF64(field, &value);
status = useUpdate ? mamaMsg_updateF64(message, name, fid, value)
: mamaMsg_addF64(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_STRING:
{
const char* value = NULL;
mama_size_t len;
mamaFieldCacheField_getString(field, &value, &len);
if (!value)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateString(message, name, fid, value)
: mamaMsg_addString(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_PRICE:
{
const mamaPrice value = NULL;
mamaFieldCacheField_getPrice(field, &value);
if (!value)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updatePrice(message, name, fid, value)
: mamaMsg_addPrice(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_TIME:
{
const mamaDateTime value = NULL;
mamaFieldCacheField_getDateTime(field, &value);
if (!value)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateDateTime(message, name, fid, value)
: mamaMsg_addDateTime(message, name, fid, value);
break;
}
case MAMA_FIELD_TYPE_VECTOR_I8:
{
const mama_i8_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getI8Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorI8(message, name, fid, values, size)
: mamaMsg_addVectorI8(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_U8:
{
const mama_u8_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getU8Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorU8(message, name, fid, values, size)
: mamaMsg_addVectorU8(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_I16:
{
const mama_i16_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getI16Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorI16(message, name, fid, values, size)
: mamaMsg_addVectorI16(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_U16:
{
const mama_u16_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getU16Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorU16(message, name, fid, values, size)
: mamaMsg_addVectorU16(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_I32:
{
const mama_i32_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getI32Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorI32(message, name, fid, values, size)
: mamaMsg_addVectorI32(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_U32:
{
const mama_u32_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getU32Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorU32(message, name, fid, values, size)
: mamaMsg_addVectorU32(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_I64:
{
const mama_i64_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getI64Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorI64(message, name, fid, values, size)
: mamaMsg_addVectorI64(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_U64:
{
const mama_u64_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getU64Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorU64(message, name, fid, values, size)
: mamaMsg_addVectorU64(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_F32:
{
const mama_f32_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getF32Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorF32(message, name, fid, values, size)
: mamaMsg_addVectorF32(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_F64:
{
const mama_f64_t* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getF64Vector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorF64(message, name, fid, values, size)
: mamaMsg_addVectorF64(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_STRING:
{
const char** values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getStringVector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = useUpdate ? mamaMsg_updateVectorString(message, name, fid, values, size)
: mamaMsg_addVectorString(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_PRICE:
{
const mamaPrice* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getPriceVector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = /*useUpdate ? mamaMsg_updateVectorPrice(message, name, fid, values, size)
: */mamaMsg_addVectorPrice(message, name, fid, values, size);
break;
}
case MAMA_FIELD_TYPE_VECTOR_TIME:
{
const mamaDateTime* values = NULL;
mama_size_t size = 0;
mamaFieldCacheField_getDateTimeVector(field, &values, &size);
if (!values)
{
return MAMA_STATUS_INVALID_ARG;
}
status = /*useUpdate ? mamaMsg_updateVectorTime(message, name, fid, values, size)
: */mamaMsg_addVectorDateTime(message, name, fid, values, size);
break;
}
default:
status = MAMA_STATUS_NOT_FOUND;
break;
}
return status;
}
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);
}
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);
}