| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include "qmf/engine/ValueImpl.h" |
| #include <qpid/framing/FieldValue.h> |
| #include <qpid/framing/FieldTable.h> |
| #include <qpid/framing/List.h> |
| #include <qpid/log/Statement.h> |
| |
| using namespace std; |
| using namespace qmf::engine; |
| //using qpid::framing::Buffer; |
| //using qpid::framing::FieldTable; |
| //using qpid::framing::FieldValue; |
| using namespace qpid::framing; |
| |
| ValueImpl::ValueImpl(Typecode t, Buffer& buf) : typecode(t) |
| { |
| uint64_t first; |
| uint64_t second; |
| FieldTable ft; |
| List fl; |
| |
| switch (typecode) { |
| case TYPE_UINT8 : value.u32 = (uint32_t) buf.getOctet(); break; |
| case TYPE_UINT16 : value.u32 = (uint32_t) buf.getShort(); break; |
| case TYPE_UINT32 : value.u32 = (uint32_t) buf.getLong(); break; |
| case TYPE_UINT64 : value.u64 = buf.getLongLong(); break; |
| case TYPE_SSTR : buf.getShortString(stringVal); break; |
| case TYPE_LSTR : buf.getMediumString(stringVal); break; |
| case TYPE_ABSTIME : value.s64 = buf.getLongLong(); break; |
| case TYPE_DELTATIME : value.u64 = buf.getLongLong(); break; |
| case TYPE_BOOL : value.boolVal = (buf.getOctet() != 0); break; |
| case TYPE_FLOAT : value.floatVal = buf.getFloat(); break; |
| case TYPE_DOUBLE : value.doubleVal = buf.getDouble(); break; |
| case TYPE_INT8 : value.s32 = (int32_t) ((int8_t) buf.getOctet()); break; |
| case TYPE_INT16 : value.s32 = (int32_t) ((int16_t) buf.getShort()); break; |
| case TYPE_INT32 : value.s32 = (int32_t) buf.getLong(); break; |
| case TYPE_INT64 : value.s64 = buf.getLongLong(); break; |
| case TYPE_UUID : buf.getBin128(value.uuidVal); break; |
| case TYPE_REF: |
| first = buf.getLongLong(); |
| second = buf.getLongLong(); |
| refVal.impl->setValue(first, second); |
| break; |
| |
| case TYPE_MAP: |
| ft.decode(buf); |
| initMap(ft); |
| break; |
| |
| case TYPE_LIST: |
| fl.decode(buf); |
| initList(fl); |
| break; |
| |
| case TYPE_ARRAY: |
| case TYPE_OBJECT: |
| default: |
| break; |
| } |
| } |
| |
| ValueImpl::ValueImpl(Typecode t, Typecode at) : typecode(t), valid(false), arrayTypecode(at) |
| { |
| } |
| |
| ValueImpl::ValueImpl(Typecode t) : typecode(t) |
| { |
| ::memset(&value, 0, sizeof(value)); |
| } |
| |
| Value* ValueImpl::factory(Typecode t, Buffer& b) |
| { |
| ValueImpl* impl(new ValueImpl(t, b)); |
| return new Value(impl); |
| } |
| |
| Value* ValueImpl::factory(Typecode t) |
| { |
| ValueImpl* impl(new ValueImpl(t)); |
| return new Value(impl); |
| } |
| |
| ValueImpl::~ValueImpl() |
| { |
| } |
| |
| void ValueImpl::initMap(const FieldTable& ft) |
| { |
| for (FieldTable::ValueMap::const_iterator iter = ft.begin(); |
| iter != ft.end(); iter++) { |
| const string& name(iter->first); |
| const FieldValue& fvalue(*iter->second); |
| uint8_t amqType = fvalue.getType(); |
| |
| if (amqType == 0x32) { |
| Value* subval(new Value(TYPE_UINT64)); |
| subval->setUint64(fvalue.get<int64_t>()); |
| insert(name.c_str(), subval); |
| } else if ((amqType & 0xCF) == 0x02) { |
| Value* subval(new Value(TYPE_UINT32)); |
| switch (amqType) { |
| case 0x02 : subval->setUint(fvalue.get<int>()); break; |
| case 0x12 : subval->setUint(fvalue.get<int>()); break; |
| case 0x22 : subval->setUint(fvalue.get<int>()); break; |
| } |
| insert(name.c_str(), subval); |
| } else if (amqType == 0x31) { // int64 |
| Value* subval(new Value(TYPE_INT64)); |
| subval->setInt64(fvalue.get<int64_t>()); |
| insert(name.c_str(), subval); |
| } else if ((amqType & 0xCF) == 0x01) { // 0x01:int8, 0x11:int16, 0x21:int21 |
| Value* subval(new Value(TYPE_INT32)); |
| subval->setInt((int32_t)fvalue.get<int>()); |
| insert(name.c_str(), subval); |
| } else if (amqType == 0x85 || amqType == 0x95) { |
| Value* subval(new Value(TYPE_LSTR)); |
| subval->setString(fvalue.get<string>().c_str()); |
| insert(name.c_str(), subval); |
| } else if (amqType == 0x23 || amqType == 0x33) { |
| Value* subval(new Value(TYPE_DOUBLE)); |
| subval->setDouble(fvalue.get<double>()); |
| insert(name.c_str(), subval); |
| } else if (amqType == 0xa8) { |
| FieldTable subFt; |
| bool valid = qpid::framing::getEncodedValue<FieldTable>(iter->second, subFt); |
| if (valid) { |
| Value* subval(new Value(TYPE_MAP)); |
| subval->impl->initMap(subFt); |
| insert(name.c_str(), subval); |
| } |
| } else if (amqType == 0xa9) { |
| List subList; |
| bool valid = qpid::framing::getEncodedValue<List>(iter->second, subList); |
| if (valid) { |
| Value* subval(new Value(TYPE_LIST)); |
| subval->impl->initList(subList); |
| insert(name.c_str(), subval); |
| } |
| } else if (amqType == 0x08) { |
| Value* subval(new Value(TYPE_BOOL)); |
| subval->setBool(fvalue.get<int>() ? true : false); |
| insert(name.c_str(), subval); |
| } else { |
| QPID_LOG(error, "Unable to decode unsupported AMQP typecode=" << amqType << " map index=" << name); |
| } |
| } |
| } |
| |
| void ValueImpl::mapToFieldTable(FieldTable& ft) const |
| { |
| FieldTable subFt; |
| |
| for (map<string, Value>::const_iterator iter = mapVal.begin(); |
| iter != mapVal.end(); iter++) { |
| const string& name(iter->first); |
| const Value& subval(iter->second); |
| |
| switch (subval.getType()) { |
| case TYPE_UINT8: |
| case TYPE_UINT16: |
| case TYPE_UINT32: |
| ft.setUInt64(name, (uint64_t) subval.asUint()); |
| break; |
| case TYPE_UINT64: |
| case TYPE_DELTATIME: |
| ft.setUInt64(name, subval.asUint64()); |
| break; |
| case TYPE_SSTR: |
| case TYPE_LSTR: |
| ft.setString(name, subval.asString()); |
| break; |
| case TYPE_INT64: |
| case TYPE_ABSTIME: |
| ft.setInt64(name, subval.asInt64()); |
| break; |
| case TYPE_BOOL: |
| ft.set(name, FieldTable::ValuePtr(new BoolValue(subval.asBool()))); |
| break; |
| case TYPE_FLOAT: |
| ft.setFloat(name, subval.asFloat()); |
| break; |
| case TYPE_DOUBLE: |
| ft.setDouble(name, subval.asDouble()); |
| break; |
| case TYPE_INT8: |
| case TYPE_INT16: |
| case TYPE_INT32: |
| ft.setInt(name, subval.asInt()); |
| break; |
| case TYPE_MAP: |
| subFt.clear(); |
| subval.impl->mapToFieldTable(subFt); |
| ft.setTable(name, subFt); |
| break; |
| case TYPE_LIST: |
| { |
| List subList; |
| subval.impl->listToFramingList(subList); |
| ft.set(name, |
| ::qpid::framing::FieldTable::ValuePtr( |
| new ListValue( |
| subList))); |
| } break; |
| case TYPE_ARRAY: |
| case TYPE_OBJECT: |
| case TYPE_UUID: |
| case TYPE_REF: |
| default: |
| break; |
| } |
| } |
| } |
| |
| |
| void ValueImpl::initList(const List& fl) |
| { |
| for (List::const_iterator iter = fl.begin(); |
| iter != fl.end(); iter++) { |
| const FieldValue& fvalue(*iter->get()); |
| uint8_t amqType = fvalue.getType(); |
| |
| if (amqType == 0x32) { |
| Value* subval(new Value(TYPE_UINT64)); |
| subval->setUint64(fvalue.get<int64_t>()); |
| appendToList(subval); |
| } else if ((amqType & 0xCF) == 0x02) { |
| Value* subval(new Value(TYPE_UINT32)); |
| switch (amqType) { |
| case 0x02 : subval->setUint(fvalue.get<int>()); break; // uint8 |
| case 0x12 : subval->setUint(fvalue.get<int>()); break; // uint16 |
| case 0x22 : subval->setUint(fvalue.get<int>()); break; // uint32 |
| } |
| appendToList(subval); |
| } else if (amqType == 0x31) { // int64 |
| Value* subval(new Value(TYPE_INT64)); |
| subval->setInt64(fvalue.get<int64_t>()); |
| appendToList(subval); |
| } else if ((amqType & 0xCF) == 0x01) { // 0x01:int8, 0x11:int16, 0x21:int32 |
| Value* subval(new Value(TYPE_INT32)); |
| subval->setInt((int32_t)fvalue.get<int>()); |
| appendToList(subval); |
| } else if (amqType == 0x85 || amqType == 0x95) { |
| Value* subval(new Value(TYPE_LSTR)); |
| subval->setString(fvalue.get<string>().c_str()); |
| appendToList(subval); |
| } else if (amqType == 0x23 || amqType == 0x33) { |
| Value* subval(new Value(TYPE_DOUBLE)); |
| subval->setDouble(fvalue.get<double>()); |
| appendToList(subval); |
| } else if (amqType == 0xa8) { |
| FieldTable subFt; |
| bool valid = qpid::framing::getEncodedValue<FieldTable>(*iter, subFt); |
| if (valid) { |
| Value* subval(new Value(TYPE_MAP)); |
| subval->impl->initMap(subFt); |
| appendToList(subval); |
| } |
| } else if (amqType == 0xa9) { |
| List subList; |
| bool valid = qpid::framing::getEncodedValue<List>(*iter, subList); |
| if (valid) { |
| Value *subVal(new Value(TYPE_LIST)); |
| subVal->impl->initList(subList); |
| appendToList(subVal); |
| } |
| } else if (amqType == 0x08) { |
| Value* subval(new Value(TYPE_BOOL)); |
| subval->setBool(fvalue.get<int>() ? true : false); |
| appendToList(subval); |
| } else { |
| QPID_LOG(error, "Unable to decode unsupported AMQP typecode =" << amqType); |
| } |
| } |
| } |
| |
| void ValueImpl::listToFramingList(List& fl) const |
| { |
| for (vector<Value>::const_iterator iter = vectorVal.begin(); |
| iter != vectorVal.end(); iter++) { |
| const Value& subval(*iter); |
| |
| switch (subval.getType()) { |
| case TYPE_UINT8: |
| case TYPE_UINT16: |
| case TYPE_UINT32: |
| fl.push_back(List::ValuePtr(new Unsigned64Value((uint64_t) subval.asUint()))); |
| break; |
| case TYPE_UINT64: |
| case TYPE_DELTATIME: |
| fl.push_back(List::ValuePtr(new Unsigned64Value(subval.asUint64()))); |
| break; |
| case TYPE_SSTR: |
| case TYPE_LSTR: |
| fl.push_back(List::ValuePtr(new Str16Value(subval.asString()))); |
| break; |
| case TYPE_INT64: |
| case TYPE_ABSTIME: |
| fl.push_back(List::ValuePtr(new Integer64Value(subval.asInt64()))); |
| break; |
| case TYPE_BOOL: |
| fl.push_back(List::ValuePtr(new BoolValue(subval.asBool() ? 1 : 0))); |
| break; |
| case TYPE_FLOAT: |
| fl.push_back(List::ValuePtr(new FloatValue(subval.asFloat()))); |
| break; |
| case TYPE_DOUBLE: |
| fl.push_back(List::ValuePtr(new DoubleValue(subval.asDouble()))); |
| break; |
| case TYPE_INT8: |
| case TYPE_INT16: |
| case TYPE_INT32: |
| fl.push_back(List::ValuePtr(new IntegerValue(subval.asInt()))); |
| break; |
| case TYPE_MAP: |
| { |
| FieldTable subFt; |
| subval.impl->mapToFieldTable(subFt); |
| fl.push_back(List::ValuePtr(new FieldTableValue(subFt))); |
| |
| } break; |
| case TYPE_LIST: |
| { |
| List subList; |
| subval.impl->listToFramingList(subList); |
| fl.push_back(List::ValuePtr(new ListValue(subList))); |
| } break; |
| |
| case TYPE_ARRAY: |
| case TYPE_OBJECT: |
| case TYPE_UUID: |
| case TYPE_REF: |
| default: |
| break; |
| } |
| } |
| } |
| |
| |
| |
| void ValueImpl::encode(Buffer& buf) const |
| { |
| FieldTable ft; |
| List fl; |
| |
| switch (typecode) { |
| case TYPE_UINT8 : buf.putOctet((uint8_t) value.u32); break; |
| case TYPE_UINT16 : buf.putShort((uint16_t) value.u32); break; |
| case TYPE_UINT32 : buf.putLong(value.u32); break; |
| case TYPE_UINT64 : buf.putLongLong(value.u64); break; |
| case TYPE_SSTR : buf.putShortString(stringVal); break; |
| case TYPE_LSTR : buf.putMediumString(stringVal); break; |
| case TYPE_ABSTIME : buf.putLongLong(value.s64); break; |
| case TYPE_DELTATIME : buf.putLongLong(value.u64); break; |
| case TYPE_BOOL : buf.putOctet(value.boolVal ? 1 : 0); break; |
| case TYPE_FLOAT : buf.putFloat(value.floatVal); break; |
| case TYPE_DOUBLE : buf.putDouble(value.doubleVal); break; |
| case TYPE_INT8 : buf.putOctet((uint8_t) value.s32); break; |
| case TYPE_INT16 : buf.putShort((uint16_t) value.s32); break; |
| case TYPE_INT32 : buf.putLong(value.s32); break; |
| case TYPE_INT64 : buf.putLongLong(value.s64); break; |
| case TYPE_UUID : buf.putBin128(value.uuidVal); break; |
| case TYPE_REF : refVal.impl->encode(buf); break; |
| case TYPE_MAP: |
| mapToFieldTable(ft); |
| ft.encode(buf); |
| break; |
| case TYPE_LIST: |
| listToFramingList(fl); |
| fl.encode(buf); |
| break; |
| |
| case TYPE_ARRAY: |
| case TYPE_OBJECT: |
| default: |
| break; |
| } |
| } |
| |
| uint32_t ValueImpl::encodedSize() const |
| { |
| FieldTable ft; |
| List fl; |
| |
| switch (typecode) { |
| case TYPE_UINT8 : |
| case TYPE_BOOL : |
| case TYPE_INT8 : return 1; |
| |
| case TYPE_UINT16 : |
| case TYPE_INT16 : return 2; |
| |
| case TYPE_UINT32 : |
| case TYPE_INT32 : |
| case TYPE_FLOAT : return 4; |
| |
| case TYPE_UINT64 : |
| case TYPE_INT64 : |
| case TYPE_DOUBLE : |
| case TYPE_ABSTIME : |
| case TYPE_DELTATIME : return 8; |
| |
| case TYPE_UUID : |
| case TYPE_REF : return 16; |
| |
| case TYPE_SSTR : return 1 + stringVal.size(); |
| case TYPE_LSTR : return 2 + stringVal.size(); |
| case TYPE_MAP: |
| mapToFieldTable(ft); |
| return ft.encodedSize(); |
| |
| case TYPE_LIST: |
| listToFramingList(fl); |
| return fl.encodedSize(); |
| |
| case TYPE_ARRAY: |
| case TYPE_OBJECT: |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| bool ValueImpl::keyInMap(const char* key) const |
| { |
| return typecode == TYPE_MAP && mapVal.count(key) > 0; |
| } |
| |
| Value* ValueImpl::byKey(const char* key) |
| { |
| if (keyInMap(key)) { |
| map<string, Value>::iterator iter = mapVal.find(key); |
| if (iter != mapVal.end()) |
| return &iter->second; |
| } |
| return 0; |
| } |
| |
| const Value* ValueImpl::byKey(const char* key) const |
| { |
| if (keyInMap(key)) { |
| map<string, Value>::const_iterator iter = mapVal.find(key); |
| if (iter != mapVal.end()) |
| return &iter->second; |
| } |
| return 0; |
| } |
| |
| void ValueImpl::deleteKey(const char* key) |
| { |
| mapVal.erase(key); |
| } |
| |
| void ValueImpl::insert(const char* key, Value* val) |
| { |
| pair<string, Value> entry(key, *val); |
| mapVal.insert(entry); |
| } |
| |
| const char* ValueImpl::key(uint32_t idx) const |
| { |
| map<string, Value>::const_iterator iter = mapVal.begin(); |
| for (uint32_t i = 0; i < idx; i++) { |
| if (iter == mapVal.end()) |
| break; |
| iter++; |
| } |
| |
| if (iter == mapVal.end()) |
| return 0; |
| else |
| return iter->first.c_str(); |
| } |
| |
| Value* ValueImpl::arrayItem(uint32_t) |
| { |
| return 0; |
| } |
| |
| void ValueImpl::appendToArray(Value*) |
| { |
| } |
| |
| void ValueImpl::deleteArrayItem(uint32_t) |
| { |
| } |
| |
| |
| //================================================================== |
| // Wrappers |
| //================================================================== |
| |
| Value::Value(const Value& from) : impl(new ValueImpl(*(from.impl))) {} |
| Value::Value(Typecode t, Typecode at) : impl(new ValueImpl(t, at)) {} |
| Value::Value(ValueImpl* i) : impl(i) {} |
| Value::~Value() { delete impl;} |
| |
| Typecode Value::getType() const { return impl->getType(); } |
| bool Value::isNull() const { return impl->isNull(); } |
| void Value::setNull() { impl->setNull(); } |
| bool Value::isObjectId() const { return impl->isObjectId(); } |
| const ObjectId& Value::asObjectId() const { return impl->asObjectId(); } |
| void Value::setObjectId(const ObjectId& oid) { impl->setObjectId(oid); } |
| bool Value::isUint() const { return impl->isUint(); } |
| uint32_t Value::asUint() const { return impl->asUint(); } |
| void Value::setUint(uint32_t val) { impl->setUint(val); } |
| bool Value::isInt() const { return impl->isInt(); } |
| int32_t Value::asInt() const { return impl->asInt(); } |
| void Value::setInt(int32_t val) { impl->setInt(val); } |
| bool Value::isUint64() const { return impl->isUint64(); } |
| uint64_t Value::asUint64() const { return impl->asUint64(); } |
| void Value::setUint64(uint64_t val) { impl->setUint64(val); } |
| bool Value::isInt64() const { return impl->isInt64(); } |
| int64_t Value::asInt64() const { return impl->asInt64(); } |
| void Value::setInt64(int64_t val) { impl->setInt64(val); } |
| bool Value::isString() const { return impl->isString(); } |
| const char* Value::asString() const { return impl->asString(); } |
| void Value::setString(const char* val) { impl->setString(val); } |
| bool Value::isBool() const { return impl->isBool(); } |
| bool Value::asBool() const { return impl->asBool(); } |
| void Value::setBool(bool val) { impl->setBool(val); } |
| bool Value::isFloat() const { return impl->isFloat(); } |
| float Value::asFloat() const { return impl->asFloat(); } |
| void Value::setFloat(float val) { impl->setFloat(val); } |
| bool Value::isDouble() const { return impl->isDouble(); } |
| double Value::asDouble() const { return impl->asDouble(); } |
| void Value::setDouble(double val) { impl->setDouble(val); } |
| bool Value::isUuid() const { return impl->isUuid(); } |
| const uint8_t* Value::asUuid() const { return impl->asUuid(); } |
| void Value::setUuid(const uint8_t* val) { impl->setUuid(val); } |
| bool Value::isObject() const { return impl->isObject(); } |
| const Object* Value::asObject() const { return impl->asObject(); } |
| void Value::setObject(Object* val) { impl->setObject(val); } |
| bool Value::isMap() const { return impl->isMap(); } |
| bool Value::keyInMap(const char* key) const { return impl->keyInMap(key); } |
| Value* Value::byKey(const char* key) { return impl->byKey(key); } |
| const Value* Value::byKey(const char* key) const { return impl->byKey(key); } |
| void Value::deleteKey(const char* key) { impl->deleteKey(key); } |
| void Value::insert(const char* key, Value* val) { impl->insert(key, val); } |
| uint32_t Value::keyCount() const { return impl->keyCount(); } |
| const char* Value::key(uint32_t idx) const { return impl->key(idx); } |
| bool Value::isList() const { return impl->isList(); } |
| uint32_t Value::listItemCount() const { return impl->listItemCount(); } |
| Value* Value::listItem(uint32_t idx) { return impl->listItem(idx); } |
| void Value::appendToList(Value* val) { impl->appendToList(val); } |
| void Value::deleteListItem(uint32_t idx) { impl->deleteListItem(idx); } |
| bool Value::isArray() const { return impl->isArray(); } |
| Typecode Value::arrayType() const { return impl->arrayType(); } |
| uint32_t Value::arrayItemCount() const { return impl->arrayItemCount(); } |
| Value* Value::arrayItem(uint32_t idx) { return impl->arrayItem(idx); } |
| void Value::appendToArray(Value* val) { impl->appendToArray(val); } |
| void Value::deleteArrayItem(uint32_t idx) { impl->deleteArrayItem(idx); } |
| |
