TEST_F(MamaFieldCacheTestC, applyMsgUsingNames)
{
mamaFieldCache fieldCache = NULL;
mama_size_t size = 0;
const char* name = "";
mama_status ret = mamaFieldCache_create(&fieldCache);
mamaFieldCache_setUseFieldNames(fieldCache, 1);
mamaMsg message;
mamaMsg_create(&message);
mamaMsg_addBool(message, "test_bool", 10, 1);
mamaMsg_addF64(message, "test_f64", 25, 12.3);
mamaMsg_addI32(message, "test_i32", 66, -101);
mamaMsg_addString(message, "test_string", 90, "hello world");
ret = mamaFieldCache_applyMessage(fieldCache, message, NULL);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ret = mamaFieldCache_getSize(fieldCache, &size);
ASSERT_EQ(4, size);
mamaFieldCacheField field = NULL;
ret = mamaFieldCache_find(fieldCache, 10, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(10, field->mFid);
mamaFieldCacheField_getName(field, &name);
ASSERT_STREQ("test_bool", name);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 25, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(25, field->mFid);
mamaFieldCacheField_getName(field, &name);
ASSERT_STREQ("test_f64", name);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 66, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(66, field->mFid);
mamaFieldCacheField_getName(field, &name);
ASSERT_STREQ("test_i32", name);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 90, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(90, field->mFid);
mamaFieldCacheField_getName(field, &name);
ASSERT_STREQ("test_string", name);
mamaMsg_destroy (message);
ret = mamaFieldCache_destroy(fieldCache);
}
mama_status mamaFieldCache_updateCacheFromField(mamaFieldCache fieldCache,
const mamaFieldCacheField field)
{
mama_status ret;
mama_fid_t fid;
mamaFieldType type;
mama_bool_t alreadyModified = 0;
const char* name = NULL;
mamaFieldCacheField cachedField = NULL;
ret = mamaFieldCacheField_getFid(field, &fid);
if (ret != MAMA_STATUS_OK)
{
return ret;
}
ret = mamaFieldCacheField_getType(field, &type);
if (ret != MAMA_STATUS_OK)
{
return ret;
}
mamaFieldCacheField_getName(field, &name);
if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &cachedField))
{
ret = mamaFieldCacheField_create(&cachedField, fid, type, NULL);
if (ret != MAMA_STATUS_OK)
{
return ret;
}
ret = mamaFieldCacheMap_add(fieldCache->mMap, cachedField);
if (ret != MAMA_STATUS_OK)
{
return ret;
}
fieldCache->mSize++;
if (field->mPublish && !field->mCheckModified)
{ /* Always publish */
mamaFieldCacheList_add(fieldCache->mAlwaysPublishFields, (void*)cachedField);
}
alreadyModified = 0;
}
else
{
alreadyModified = cachedField->mIsModified;
}
mamaFieldCacheField_copy(field, cachedField);
if (cachedField->mPublish && cachedField->mCheckModified
&& !alreadyModified
&& fieldCache->mTrackModified)
{
cachedField->mIsModified = 1;
mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)cachedField);
}
return ret;
}
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;
}
TEST_F(MamaFieldCacheTestC, applyMsgNew)
{
mamaFieldCache fieldCache = NULL;
mama_size_t size = 0;
mama_bool_t modified = 0;
const char* name = "";
mama_size_t len = 0;
mama_status ret = mamaFieldCache_create(&fieldCache);
mamaMsg message = NULL;
mamaMsg_create(&message);
mamaMsg_addBool(message, "test_bool", 10, 1);
mamaMsg_addF64(message, "test_f64", 25, 12.3);
mamaMsg_addI32(message, "test_i32", 66, -101);
mamaMsg_addString(message, "test_string", 90, "hello world");
ret = mamaFieldCache_applyMessage(fieldCache, message, NULL);
// mamaMsg_clear(message);
mamaMsg_destroy (message);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ret = mamaFieldCache_getSize(fieldCache, &size);
ASSERT_EQ(4, size);
mamaFieldCacheField field = NULL;
ret = mamaFieldCache_find(fieldCache, 10, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(10, field->mFid);
ASSERT_EQ(MAMA_FIELD_TYPE_BOOL, field->mType);
mama_bool_t resultBool = 0;
mamaFieldCacheField_getBool(field, &resultBool);
ASSERT_EQ(1, resultBool);
mamaFieldCacheField_isModified(field, &modified);
ASSERT_TRUE(modified);
mamaFieldCacheField_getName(field, &name);
ASSERT_TRUE(name == NULL);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 25, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(25, field->mFid);
mama_f64_t resultF64 = 0;
mamaFieldCacheField_getF64(field, &resultF64);
ASSERT_DOUBLE_EQ(12.3, resultF64);
mamaFieldCacheField_isModified(field, &modified);
ASSERT_TRUE(modified);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 66, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(66, field->mFid);
mama_i32_t resultI32 = 0;
mamaFieldCacheField_getI32(field, &resultI32);
ASSERT_DOUBLE_EQ(-101, resultI32);
mamaFieldCacheField_isModified(field, &modified);
ASSERT_TRUE(modified);
field = NULL;
ret = mamaFieldCache_find(fieldCache, 90, NULL, &field);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(90, field->mFid);
const char* resultString = NULL;
mamaFieldCacheField_getString(field, &resultString, &len);
ASSERT_STREQ("hello world", resultString);
mamaFieldCacheField_isModified(field, &modified);
ASSERT_TRUE(modified);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(4, size);
ret = mamaFieldCache_destroy(fieldCache);
ret = mamaFieldCache_applyMessage(NULL, message, NULL);
ASSERT_EQ(MAMA_STATUS_NULL_ARG, ret);
ret = mamaFieldCache_applyMessage(fieldCache, NULL, NULL);
ASSERT_EQ(MAMA_STATUS_NULL_ARG, ret);
}
TEST_F(MamaFieldCacheTestC, applyFieldNew)
{
mama_status ret = MAMA_STATUS_OK;
mamaFieldCache fieldCache = NULL;
mamaFieldCacheField cachedField = NULL;
mama_size_t size = 0;
mama_bool_t boolValue = 0;
mamaFieldCache_create(&fieldCache);
mamaFieldCacheField field1 = NULL;
mamaFieldCacheField_create(&field1, 2, MAMA_FIELD_TYPE_F32, NULL);
mamaFieldCacheField_setF32(field1, 13.13);
mamaFieldCacheField_setPublish(field1, 1);
mamaFieldCacheField_setCheckModified(field1, 1);
mamaFieldCache_getSize(fieldCache, &size);
ASSERT_EQ(0, size);
mamaFieldCache_applyField(fieldCache, field1);
mamaFieldCache_getSize(fieldCache, &size);
ASSERT_EQ(1, size);
ret = mamaFieldCache_find(fieldCache, 2, NULL, &cachedField);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_TRUE(cachedField != NULL);
mamaFieldCacheField_getPublish(cachedField, &boolValue);
ASSERT_EQ(1, boolValue);
boolValue = 0;
mamaFieldCacheField_getCheckModified(cachedField, &boolValue);
ASSERT_EQ(1, boolValue);
boolValue = 0;
mamaFieldCacheField_isModified(cachedField, &boolValue);
ASSERT_EQ(1, boolValue);
mamaFieldCacheField field2 = NULL;
mamaFieldCacheField_create(&field2, 4, MAMA_FIELD_TYPE_I32, "name4");
mamaFieldCacheField_setI32(field2, 321);
mamaFieldCacheField_setPublish(field2, 0);
mamaFieldCacheField_setCheckModified(field2, 0);
mamaFieldCache_applyField(fieldCache, field2);
mamaFieldCache_getSize(fieldCache, &size);
ASSERT_EQ(2, size);
cachedField = NULL;
ret = mamaFieldCache_find(fieldCache, 4, "", &cachedField);
ASSERT_TRUE(cachedField != NULL);
ASSERT_EQ(MAMA_STATUS_OK, ret);
boolValue = 0;
mamaFieldCacheField_getPublish(cachedField, &boolValue);
ASSERT_EQ(0, boolValue);
boolValue = 0;
mamaFieldCacheField_getCheckModified(cachedField, &boolValue);
ASSERT_EQ(0, boolValue);
boolValue = 0;
mamaFieldCacheField_isModified(cachedField, &boolValue);
ASSERT_EQ(0, boolValue);
const char* cachedName = NULL;
ret = mamaFieldCacheField_getName(cachedField, &cachedName);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_TRUE(cachedName != NULL);
ASSERT_STREQ("name4", cachedName);
mamaFieldCacheField_destroy(field1);
mamaFieldCacheField_destroy(field2);
mamaFieldCache_destroy(fieldCache);
}