diff options
Diffstat (limited to 'qpid/cpp/src/qmf/SchemaProperty.cpp')
| -rw-r--r-- | qpid/cpp/src/qmf/SchemaProperty.cpp | 434 |
1 files changed, 434 insertions, 0 deletions
diff --git a/qpid/cpp/src/qmf/SchemaProperty.cpp b/qpid/cpp/src/qmf/SchemaProperty.cpp new file mode 100644 index 0000000000..106127261b --- /dev/null +++ b/qpid/cpp/src/qmf/SchemaProperty.cpp @@ -0,0 +1,434 @@ +/* + * + * 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/SchemaPropertyImpl.h" +#include "qmf/PrivateImplRef.h" +#include "qmf/exceptions.h" +#include "qmf/SchemaTypes.h" +#include "qmf/SchemaProperty.h" +#include "qmf/Hash.h" +#include "qpid/messaging/AddressParser.h" +#include <list> +#include <iostream> + +using namespace std; +using qpid::types::Variant; +using namespace qmf; + +typedef PrivateImplRef<SchemaProperty> PI; + +SchemaProperty::SchemaProperty(SchemaPropertyImpl* impl) { PI::ctor(*this, impl); } +SchemaProperty::SchemaProperty(const SchemaProperty& s) : qmf::Handle<SchemaPropertyImpl>() { PI::copy(*this, s); } +SchemaProperty::~SchemaProperty() { PI::dtor(*this); } +SchemaProperty& SchemaProperty::operator=(const SchemaProperty& s) { return PI::assign(*this, s); } + +SchemaProperty::SchemaProperty(const string& n, int t, const string& o) { PI::ctor(*this, new SchemaPropertyImpl(n, t, o)); } + +void SchemaProperty::setAccess(int a) { impl->setAccess(a); } +void SchemaProperty::setIndex(bool i) { impl->setIndex(i); } +void SchemaProperty::setOptional(bool o) { impl->setOptional(o); } +void SchemaProperty::setUnit(const string& u) { impl->setUnit(u); } +void SchemaProperty::setDesc(const string& d) { impl->setDesc(d); } +void SchemaProperty::setSubtype(const string& s) { impl->setSubtype(s); } +void SchemaProperty::setDirection(int d) { impl->setDirection(d); } + +const string& SchemaProperty::getName() const { return impl->getName(); } +int SchemaProperty::getType() const { return impl->getType(); } +int SchemaProperty::getAccess() const { return impl->getAccess(); } +bool SchemaProperty::isIndex() const { return impl->isIndex(); } +bool SchemaProperty::isOptional() const { return impl->isOptional(); } +const string& SchemaProperty::getUnit() const { return impl->getUnit(); } +const string& SchemaProperty::getDesc() const { return impl->getDesc(); } +const string& SchemaProperty::getSubtype() const { return impl->getSubtype(); } +int SchemaProperty::getDirection() const { return impl->getDirection(); } + +//======================================================================================== +// Impl Method Bodies +//======================================================================================== + +SchemaPropertyImpl::SchemaPropertyImpl(const string& n, int t, const string options) : + name(n), dataType(t), access(ACCESS_READ_ONLY), index(false), + optional(false), direction(DIR_IN) +{ + if (!options.empty()) { + qpid::messaging::AddressParser parser = qpid::messaging::AddressParser(options); + Variant::Map optMap; + Variant::Map::iterator iter; + + parser.parseMap(optMap); + + iter = optMap.find("access"); + if (iter != optMap.end()) { + const string& v(iter->second.asString()); + if (v == "RC") access = ACCESS_READ_CREATE; + else if (v == "RO") access = ACCESS_READ_ONLY; + else if (v == "RW") access = ACCESS_READ_WRITE; + else + throw QmfException("Invalid value for 'access' option. Expected RC, RO, or RW"); + optMap.erase(iter); + } + + iter = optMap.find("index"); + if (iter != optMap.end()) { + index = iter->second.asBool(); + optMap.erase(iter); + } + + iter = optMap.find("optional"); + if (iter != optMap.end()) { + optional = iter->second.asBool(); + optMap.erase(iter); + } + + iter = optMap.find("unit"); + if (iter != optMap.end()) { + unit = iter->second.asString(); + optMap.erase(iter); + } + + iter = optMap.find("desc"); + if (iter != optMap.end()) { + desc = iter->second.asString(); + optMap.erase(iter); + } + + iter = optMap.find("subtype"); + if (iter != optMap.end()) { + subtype = iter->second.asString(); + optMap.erase(iter); + } + + iter = optMap.find("dir"); + if (iter != optMap.end()) { + const string& v(iter->second.asString()); + if (v == "IN") direction = DIR_IN; + else if (v == "OUT") direction = DIR_OUT; + else if (v == "INOUT") direction = DIR_IN_OUT; + else + throw QmfException("Invalid value for 'dir' option. Expected IN, OUT, or INOUT"); + optMap.erase(iter); + } + + if (!optMap.empty()) + throw QmfException("Unexpected option: " + optMap.begin()->first); + } +} + + +SchemaPropertyImpl::SchemaPropertyImpl(const Variant::Map& map) : + access(ACCESS_READ_ONLY), index(false), optional(false), direction(DIR_IN) +{ + Variant::Map::const_iterator iter; + + iter = map.find("_name"); + if (iter == map.end()) + throw QmfException("SchemaProperty without a _name element"); + name = iter->second.asString(); + + iter = map.find("_type"); + if (iter == map.end()) + throw QmfException("SchemaProperty without a _type element"); + const string& ts(iter->second.asString()); + if (ts == "TYPE_VOID") dataType = SCHEMA_DATA_VOID; + else if (ts == "TYPE_BOOL") dataType = SCHEMA_DATA_BOOL; + else if (ts == "TYPE_INT") dataType = SCHEMA_DATA_INT; + else if (ts == "TYPE_FLOAT") dataType = SCHEMA_DATA_FLOAT; + else if (ts == "TYPE_STRING") dataType = SCHEMA_DATA_STRING; + else if (ts == "TYPE_MAP") dataType = SCHEMA_DATA_MAP; + else if (ts == "TYPE_LIST") dataType = SCHEMA_DATA_LIST; + else if (ts == "TYPE_UUID") dataType = SCHEMA_DATA_UUID; + else + throw QmfException("SchemaProperty with an invalid type code: " + ts); + + iter = map.find("_access"); + if (iter != map.end()) { + const string& as(iter->second.asString()); + if (as == "RO") access = ACCESS_READ_ONLY; + else if (as == "RC") access = ACCESS_READ_CREATE; + else if (as == "RW") access = ACCESS_READ_WRITE; + else + throw QmfException("SchemaProperty with an invalid access code: " + as); + } + + iter = map.find("_unit"); + if (iter != map.end()) + unit = iter->second.asString(); + + iter = map.find("_dir"); + if (iter != map.end()) { + const string& ds(iter->second.asString()); + if (ds == "I") direction = DIR_IN; + else if (ds == "O") direction = DIR_OUT; + else if (ds == "IO") direction = DIR_IN_OUT; + else + throw QmfException("SchemaProperty with an invalid direction code: " + ds); + } + + iter = map.find("_desc"); + if (iter != map.end()) + desc = iter->second.asString(); + + iter = map.find("_index"); + if (iter != map.end()) + index = iter->second.asBool(); + + iter = map.find("_subtype"); + if (iter != map.end()) + subtype = iter->second.asString(); +} + + +Variant::Map SchemaPropertyImpl::asMap() const +{ + Variant::Map map; + string ts; + + map["_name"] = name; + + switch (dataType) { + case SCHEMA_DATA_VOID: ts = "TYPE_VOID"; break; + case SCHEMA_DATA_BOOL: ts = "TYPE_BOOL"; break; + case SCHEMA_DATA_INT: ts = "TYPE_INT"; break; + case SCHEMA_DATA_FLOAT: ts = "TYPE_FLOAT"; break; + case SCHEMA_DATA_STRING: ts = "TYPE_STRING"; break; + case SCHEMA_DATA_MAP: ts = "TYPE_MAP"; break; + case SCHEMA_DATA_LIST: ts = "TYPE_LIST"; break; + case SCHEMA_DATA_UUID: ts = "TYPE_UUID"; break; + } + map["_type"] = ts; + + switch (access) { + case ACCESS_READ_ONLY: ts = "RO"; break; + case ACCESS_READ_CREATE: ts = "RC"; break; + case ACCESS_READ_WRITE: ts = "RW"; break; + } + map["_access"] = ts; + + if (!unit.empty()) + map["_unit"] = unit; + + switch (direction) { + case DIR_IN: ts = "I"; break; + case DIR_OUT: ts = "O"; break; + case DIR_IN_OUT: ts = "IO"; break; + } + map["_dir"] = ts; + + if (!desc.empty()) + map["_desc"] = desc; + + if (index) + map["_index"] = true; + + if (!subtype.empty()) + map["_subtype"] = subtype; + + return map; +} + + +SchemaPropertyImpl::SchemaPropertyImpl(qpid::management::Buffer& buffer) : + access(ACCESS_READ_ONLY), index(false), optional(false), direction(DIR_IN) +{ + Variant::Map::const_iterator iter; + Variant::Map pmap; + + buffer.getMap(pmap); + iter = pmap.find("name"); + if (iter == pmap.end()) + throw QmfException("Received V1 Schema property without a name"); + name = iter->second.asString(); + + iter = pmap.find("type"); + if (iter == pmap.end()) + throw QmfException("Received V1 Schema property without a type"); + fromV1TypeCode(iter->second.asInt8()); + + iter = pmap.find("unit"); + if (iter != pmap.end()) + unit = iter->second.asString(); + + iter = pmap.find("desc"); + if (iter != pmap.end()) + desc = iter->second.asString(); + + iter = pmap.find("access"); + if (iter != pmap.end()) { + int8_t val = iter->second.asInt8(); + if (val < 1 || val > 3) + throw QmfException("Received V1 Schema property with invalid 'access' code"); + access = val; + } + + iter = pmap.find("index"); + if (iter != pmap.end()) + index = iter->second.asInt64() != 0; + + iter = pmap.find("optional"); + if (iter != pmap.end()) + optional = iter->second.asInt64() != 0; + + iter = pmap.find("dir"); + if (iter != pmap.end()) { + string dirStr(iter->second.asString()); + if (dirStr == "I") direction = DIR_IN; + else if (dirStr == "O") direction = DIR_OUT; + else if (dirStr == "IO") direction = DIR_IN_OUT; + else + throw QmfException("Received V1 Schema property with invalid 'dir' code"); + } +} + + +void SchemaPropertyImpl::updateHash(Hash& hash) const +{ + hash.update(name); + hash.update((uint8_t) dataType); + hash.update(subtype); + hash.update((uint8_t) access); + hash.update(index); + hash.update(optional); + hash.update(unit); + hash.update(desc); + hash.update((uint8_t) direction); +} + + +void SchemaPropertyImpl::encodeV1(qpid::management::Buffer& buffer, bool isArg, bool isMethodArg) const +{ + Variant::Map pmap; + + pmap["name"] = name; + pmap["type"] = v1TypeCode(); + if (!unit.empty()) + pmap["unit"] = unit; + if (!desc.empty()) + pmap["desc"] = desc; + if (!isArg) { + pmap["access"] = access; + pmap["index"] = index ? 1 : 0; + pmap["optional"] = optional ? 1 : 0; + } else { + if (isMethodArg) { + string dirStr; + switch (direction) { + case DIR_IN : dirStr = "I"; break; + case DIR_OUT : dirStr = "O"; break; + case DIR_IN_OUT : dirStr = "IO"; break; + } + pmap["dir"] = dirStr; + } + } + + buffer.putMap(pmap); +} + + +uint8_t SchemaPropertyImpl::v1TypeCode() const +{ + switch (dataType) { + case SCHEMA_DATA_VOID: return 1; + case SCHEMA_DATA_BOOL: return 11; + case SCHEMA_DATA_INT: + if (subtype == "timestamp") return 8; + if (subtype == "duration") return 9; + return 19; + case SCHEMA_DATA_FLOAT: return 13; + case SCHEMA_DATA_STRING: return 7; + case SCHEMA_DATA_LIST: return 21; + case SCHEMA_DATA_UUID: return 14; + case SCHEMA_DATA_MAP: + if (subtype == "reference") return 10; + if (subtype == "data") return 20; + return 15; + } + + return 1; +} + +void SchemaPropertyImpl::fromV1TypeCode(int8_t code) +{ + switch (code) { + case 1: // U8 + case 2: // U16 + case 3: // U32 + case 4: // U64 + dataType = SCHEMA_DATA_INT; + break; + case 6: // SSTR + case 7: // LSTR + dataType = SCHEMA_DATA_STRING; + break; + case 8: // ABSTIME + dataType = SCHEMA_DATA_INT; + subtype = "timestamp"; + break; + case 9: // DELTATIME + dataType = SCHEMA_DATA_INT; + subtype = "duration"; + break; + case 10: // REF + dataType = SCHEMA_DATA_MAP; + subtype = "reference"; + break; + case 11: // BOOL + dataType = SCHEMA_DATA_BOOL; + break; + case 12: // FLOAT + case 13: // DOUBLE + dataType = SCHEMA_DATA_FLOAT; + break; + case 14: // UUID + dataType = SCHEMA_DATA_UUID; + break; + case 15: // FTABLE + dataType = SCHEMA_DATA_MAP; + break; + case 16: // S8 + case 17: // S16 + case 18: // S32 + case 19: // S64 + dataType = SCHEMA_DATA_INT; + break; + case 20: // OBJECT + dataType = SCHEMA_DATA_MAP; + subtype = "data"; + break; + case 21: // LIST + case 22: // ARRAY + dataType = SCHEMA_DATA_LIST; + break; + default: + throw QmfException("Received V1 schema with an unknown data type"); + } +} + + +SchemaPropertyImpl& SchemaPropertyImplAccess::get(SchemaProperty& item) +{ + return *item.impl; +} + + +const SchemaPropertyImpl& SchemaPropertyImplAccess::get(const SchemaProperty& item) +{ + return *item.impl; +} |