Example #1
0
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;
}
Example #2
0
mama_status
mamaFieldCacheField_copy(const mamaFieldCacheField field, mamaFieldCacheField copy)
{
    if (!field || !copy)
    {
        return MAMA_STATUS_NULL_ARG;
    }
    if (field == copy)
    {
        return MAMA_STATUS_OK;
    }
    if (field->mFid != copy->mFid || field->mType != copy->mType)
    {
        return MAMA_STATUS_INVALID_ARG;
    }

    copy->mIsModified = field->mIsModified;
    copy->mPublish = field->mPublish;
    copy->mCheckModified = field->mCheckModified;
    copy->mDescriptor = field->mDescriptor;
    if (field->mName)
    {
        if (copy->mName)
        {
            free((void*)copy->mName);
        }
        copy->mName = strdup(field->mName);
    }
    switch (field->mType)
    {
        case MAMA_FIELD_TYPE_BOOL:
        {
            mama_bool_t result;
            mamaFieldCacheField_getBool(field, &result);
            mamaFieldCacheField_setBool(copy, result);
            break;
        }
        case MAMA_FIELD_TYPE_CHAR:
        {
            char value;
            mamaFieldCacheField_getChar(field, &value);
            mamaFieldCacheField_setChar(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_I8:
        {
            mama_i8_t value;
            mamaFieldCacheField_getI8(field, &value);
            mamaFieldCacheField_setI8(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_U8:
        {
            mama_u8_t value;
            mamaFieldCacheField_getU8(field, &value);
            mamaFieldCacheField_setU8(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_I16:
        {
            mama_i16_t value;
            mamaFieldCacheField_getI16(field, &value);
            mamaFieldCacheField_setI16(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_U16:
        {
            mama_u16_t value;
            mamaFieldCacheField_getU16(field, &value);
            mamaFieldCacheField_setU16(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_I32:
        {
            mama_i32_t value;
            mamaFieldCacheField_getI32(field, &value);
            mamaFieldCacheField_setI32(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_U32:
        {
            mama_u32_t value;
            mamaFieldCacheField_getU32(field, &value);
            mamaFieldCacheField_setU32(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_I64:
        {
            mama_i64_t value;
            mamaFieldCacheField_getI64(field, &value);
            mamaFieldCacheField_setI64(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_U64:
        {
            mama_u64_t value;
            mamaFieldCacheField_getU64(field, &value);
            mamaFieldCacheField_setU64(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_F32:
        {
            mama_f32_t value;
            mamaFieldCacheField_getF32(field, &value);
            mamaFieldCacheField_setF32(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_QUANTITY:
        case MAMA_FIELD_TYPE_F64:
        {
            mama_f64_t value;
            mamaFieldCacheField_getF64(field, &value);
            mamaFieldCacheField_setF64(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_STRING:
        {
            const char* value;
            mama_size_t len;
            mamaFieldCacheField_getString(field, &value, &len);
            mamaFieldCacheField_setString(copy, value, len);
            break;
        }
        case MAMA_FIELD_TYPE_PRICE:
        {
            mamaPrice value = NULL;
            const mamaPrice* pvalue = &value;
            mamaFieldCacheField_getPrice(field, pvalue);
            mamaFieldCacheField_setPrice(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_TIME:
        {
            mamaDateTime value = NULL;
            const mamaDateTime* pvalue = &value;
            mamaFieldCacheField_getDateTime(field, pvalue);
            mamaFieldCacheField_setDateTime(copy, value);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_BOOL:
        {
            const mama_bool_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getBoolVector(field, &values, &size);
            mamaFieldCacheField_setBoolVector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_CHAR:
        {
            const char* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getCharVector(field, &values, &size);
            mamaFieldCacheField_setCharVector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I8:
        {
            const mama_i8_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getI8Vector(field, &values, &size);
            mamaFieldCacheField_setI8Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U8:
        {
            const mama_u8_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getU8Vector(field, &values, &size);
            mamaFieldCacheField_setU8Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I16:
        {
            const mama_i16_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getI16Vector(field, &values, &size);
            mamaFieldCacheField_setI16Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U16:
        {
            const mama_u16_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getU16Vector(field, &values, &size);
            mamaFieldCacheField_setU16Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I32:
        {
            const mama_i32_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getI32Vector(field, &values, &size);
            mamaFieldCacheField_setI32Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U32:
        {
            const mama_u32_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getU32Vector(field, &values, &size);
            mamaFieldCacheField_setU32Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_I64:
        {
            const mama_i64_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getI64Vector(field, &values, &size);
            mamaFieldCacheField_setI64Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_U64:
        {
            const mama_u64_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getU64Vector(field, &values, &size);
            mamaFieldCacheField_setU64Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_F32:
        {
            const mama_f32_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getF32Vector(field, &values, &size);
            mamaFieldCacheField_setF32Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_F64:
        {
            const mama_f64_t* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getF64Vector(field, &values, &size);
            mamaFieldCacheField_setF64Vector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_STRING:
        {
            const char** values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getStringVector(field, &values, &size);
            mamaFieldCacheField_setStringVector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_PRICE:
        {
            const mamaPrice* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getPriceVector(field, &values, &size);
            mamaFieldCacheField_setPriceVector(copy, values, size);
            break;
        }
        case MAMA_FIELD_TYPE_VECTOR_TIME:
        {
            const mamaDateTime* values = NULL;
            mama_size_t size;
            mamaFieldCacheField_getDateTimeVector(field, &values, &size);
            mamaFieldCacheField_setDateTimeVector(copy, values, size);
            break;
        }
        default:
            break;
    }
    return MAMA_STATUS_OK;
}