Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/QueryImpl.h URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/QueryImpl.h?rev=911854&r1=911853&r2=911854&view=diff ============================================================================== --- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/QueryImpl.h (original) +++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/QueryImpl.h Fri Feb 19 16:06:22 2010 @@ -21,79 +21,41 @@ */ #include "qmf/engine/Query.h" -#include "qmf/engine/Schema.h" +#include <qpid/messaging/Variant.h> #include <string> #include <boost/shared_ptr.hpp> -namespace qpid { - namespace framing { - class Buffer; - } -} - namespace qmf { namespace engine { - struct QueryElementImpl { - QueryElementImpl(const std::string& a, const Value* v, ValueOper o) : attrName(a), value(v), oper(o) {} - ~QueryElementImpl() {} - bool evaluate(const Object* object) const; - - std::string attrName; - const Value* value; - ValueOper oper; - }; - - struct QueryExpressionImpl { - QueryExpressionImpl(ExprOper o, const QueryOperand* operand1, const QueryOperand* operand2) : oper(o), left(operand1), right(operand2) {} - ~QueryExpressionImpl() {} - bool evaluate(const Object* object) const; - - ExprOper oper; - const QueryOperand* left; - const QueryOperand* right; - }; - struct QueryImpl { - // Constructors mapped to public - QueryImpl(const std::string& c, const std::string& p) : packageName(p), className(c), select(0), resultLimit(0) {} - QueryImpl(const SchemaClassKey* key) : packageName(key->getPackageName()), className(key->getClassName()), select(0), resultLimit(0) {} - QueryImpl(const ObjectId* oid) : oid(new ObjectId(*oid)), select(0), resultLimit(0) {} - - // Factory constructors - QueryImpl(qpid::framing::Buffer& buffer); - - ~QueryImpl() {}; - static Query* factory(qpid::framing::Buffer& buffer); - - void setSelect(const QueryOperand* criterion) { select = criterion; } - void setLimit(uint32_t maxResults) { resultLimit = maxResults; } - void setOrderBy(const std::string& attrName, bool decreasing) { - orderBy = attrName; orderDecreasing = decreasing; - } - - const std::string& getPackage() const { return packageName; } - const std::string& getClass() const { return className; } - const ObjectId* getObjectId() const { return oid.get(); } - - bool haveSelect() const { return select != 0; } - bool haveLimit() const { return resultLimit > 0; } - bool haveOrderBy() const { return !orderBy.empty(); } - const QueryOperand* getSelect() const { return select; } + QueryImpl(const char* _target) : target(_target), resultLimit(0) {} + QueryImpl(const char* _target, const qpid::messaging::Variant::List& _predicate) : + target(_target), predicate(_predicate), resultLimit(0) {} + QueryImpl(const char* _target, const char* expression) : + target(_target), resultLimit(0) { parsePredicate(expression); } + ~QueryImpl() {} + + void where(const qpid::messaging::Variant::List& _predicate) { predicate = _predicate; } + void where(const char* expression) { parsePredicate(expression); } + void limit(uint32_t maxResults) { resultLimit = maxResults; } + void orderBy(const char* attrName, bool decreasing) { sortAttr = attrName; orderDecreasing = decreasing; } + + bool havePredicate() const { return !predicate.empty(); } + bool haveLimit() const { return resultLimit != 0; } + bool haveOrderBy() const { return !sortAttr.empty(); } + const qpid::messaging::Variant::List& getPredicate() const { return predicate; } uint32_t getLimit() const { return resultLimit; } - const std::string& getOrderBy() const { return orderBy; } + const char* getOrderBy() const { return sortAttr.c_str(); } bool getDecreasing() const { return orderDecreasing; } + bool matches(const Object& object) const; + + void parsePredicate(const std::string& expression); - void encode(qpid::framing::Buffer& buffer) const; - bool singleAgent() const { return oid.get() != 0; } - uint32_t agentBank() const { return singleAgent() ? oid->getAgentBank() : 0; } - - std::string packageName; - std::string className; - boost::shared_ptr<ObjectId> oid; - const QueryOperand* select; + const std::string target; + qpid::messaging::Variant::List predicate; uint32_t resultLimit; - std::string orderBy; + std::string sortAttr; bool orderDecreasing; }; }
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.cpp URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.cpp?rev=911854&r1=911853&r2=911854&view=diff ============================================================================== --- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.cpp (original) +++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.cpp Fri Feb 19 16:06:22 2010 @@ -18,18 +18,14 @@ */ #include "qmf/engine/SchemaImpl.h" -#include <qpid/framing/Buffer.h> -#include <qpid/framing/FieldTable.h> -#include <qpid/framing/Uuid.h> +#include "qmf/Protocol.h" #include <string.h> #include <string> #include <vector> using namespace std; using namespace qmf::engine; -using qpid::framing::Buffer; -using qpid::framing::FieldTable; -using qpid::framing::Uuid; +using namespace qpid::messaging; SchemaHash::SchemaHash() { @@ -37,16 +33,6 @@ hash[idx] = 0x5A; } -void SchemaHash::encode(Buffer& buffer) const -{ - buffer.putBin128(hash); -} - -void SchemaHash::decode(Buffer& buffer) -{ - buffer.getBin128(hash); -} - void SchemaHash::update(uint8_t data) { update((char*) &data, 1); @@ -81,48 +67,68 @@ return ::memcmp(&hash, &other.hash, 16) > 0; } -SchemaArgumentImpl::SchemaArgumentImpl(Buffer& buffer) + +SchemaArgumentImpl::SchemaArgumentImpl(const Variant::Map& map) { - FieldTable map; - map.decode(buffer); + Variant::Map::const_iterator iter; - name = map.getAsString("name"); - typecode = (Typecode) map.getAsInt("type"); - unit = map.getAsString("unit"); - description = map.getAsString("desc"); + iter = map.find(Protocol::SCHEMA_ELT_NAME); + if (iter == map.end()) + throw SchemaException("SchemaArgument", Protocol::SCHEMA_ELT_NAME); + name = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ELT_TYPE); + if (iter == map.end()) + throw SchemaException("SchemaArgument", Protocol::SCHEMA_ELT_TYPE); + typecode = (Typecode) iter->second.asUint8(); + + iter = map.find(Protocol::SCHEMA_ELT_UNIT); + if (iter != map.end()) + unit = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ELT_DESC); + if (iter != map.end()) + description = iter->second.asString(); dir = DIR_IN; - string dstr(map.getAsString("dir")); - if (dstr == "O") - dir = DIR_OUT; - else if (dstr == "IO") - dir = DIR_IN_OUT; + iter = map.find(Protocol::SCHEMA_ELT_DIR); + if (iter != map.end()) { + string dstr(iter->second.asString()); + if (dstr == "O") + dir = DIR_OUT; + else if (dstr == "IO") + dir = DIR_IN_OUT; + } } -SchemaArgument* SchemaArgumentImpl::factory(Buffer& buffer) +SchemaArgument* SchemaArgumentImpl::factory(Variant::Map& map) { - SchemaArgumentImpl* impl(new SchemaArgumentImpl(buffer)); + SchemaArgumentImpl* impl(new SchemaArgumentImpl(map)); return new SchemaArgument(impl); } -void SchemaArgumentImpl::encode(Buffer& buffer) const +Variant::Map SchemaArgumentImpl::asMap() const { - FieldTable map; + Variant::Map map; + + map[Protocol::SCHEMA_ELT_NAME] = Variant(name); + map[Protocol::SCHEMA_ELT_TYPE] = Variant((uint8_t) typecode); - map.setString("name", name); - map.setInt("type", (int) typecode); + string dirStr; if (dir == DIR_IN) - map.setString("dir", "I"); + dirStr = "I"; else if (dir == DIR_OUT) - map.setString("dir", "O"); + dirStr = "O"; else - map.setString("dir", "IO"); + dirStr = "IO"; + map[Protocol::SCHEMA_ELT_DIR] = Variant(dirStr); + if (!unit.empty()) - map.setString("unit", unit); + map[Protocol::SCHEMA_ELT_UNIT] = Variant(unit); if (!description.empty()) - map.setString("desc", description); + map[Protocol::SCHEMA_ELT_DESC] = Variant(description); - map.encode(buffer); + return map; } void SchemaArgumentImpl::updateHash(SchemaHash& hash) const @@ -134,41 +140,51 @@ hash.update(description); } -SchemaMethodImpl::SchemaMethodImpl(Buffer& buffer) +SchemaMethodImpl::SchemaMethodImpl(const Variant::Map& map) { - FieldTable map; - int argCount; + Variant::Map::const_iterator iter; - map.decode(buffer); - name = map.getAsString("name"); - argCount = map.getAsInt("argCount"); - description = map.getAsString("desc"); - - for (int idx = 0; idx < argCount; idx++) { - SchemaArgument* arg = SchemaArgumentImpl::factory(buffer); - addArgument(arg); + iter = map.find(Protocol::SCHEMA_ELT_NAME); + if (iter == map.end()) + throw SchemaException("SchemaMethod", Protocol::SCHEMA_ELT_NAME); + name = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ELT_DESC); + if (iter != map.end()) + description = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ARGS); + if (iter != map.end()) { + Variant::List list(iter->second.asList()); + for (Variant::List::const_iterator aiter = list.begin(); aiter != list.end(); aiter++) { + Variant::Map argMap(aiter->asMap()); + SchemaArgument* arg = SchemaArgumentImpl::factory(argMap); + addArgument(arg); + } } } -SchemaMethod* SchemaMethodImpl::factory(Buffer& buffer) +SchemaMethod* SchemaMethodImpl::factory(Variant::Map& map) { - SchemaMethodImpl* impl(new SchemaMethodImpl(buffer)); + SchemaMethodImpl* impl(new SchemaMethodImpl(map)); return new SchemaMethod(impl); } -void SchemaMethodImpl::encode(Buffer& buffer) const +Variant::Map SchemaMethodImpl::asMap() const { - FieldTable map; + Variant::Map map; - map.setString("name", name); - map.setInt("argCount", arguments.size()); + map[Protocol::SCHEMA_ELT_NAME] = Variant(name); if (!description.empty()) - map.setString("desc", description); - map.encode(buffer); + map[Protocol::SCHEMA_ELT_DESC] = Variant(description); + Variant::List list; for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin(); iter != arguments.end(); iter++) - (*iter)->impl->encode(buffer); + list.push_back((*iter)->impl->asMap()); + map[Protocol::SCHEMA_ARGS] = list; + + return map; } void SchemaMethodImpl::addArgument(const SchemaArgument* argument) @@ -195,41 +211,58 @@ (*iter)->impl->updateHash(hash); } -SchemaPropertyImpl::SchemaPropertyImpl(Buffer& buffer) +SchemaPropertyImpl::SchemaPropertyImpl(const Variant::Map& map) { - FieldTable map; - map.decode(buffer); + Variant::Map::const_iterator iter; + + iter = map.find(Protocol::SCHEMA_ELT_NAME); + if (iter == map.end()) + throw SchemaException("SchemaProperty", Protocol::SCHEMA_ELT_NAME); + name = iter->second.asString(); - name = map.getAsString("name"); - typecode = (Typecode) map.getAsInt("type"); - access = (Access) map.getAsInt("access"); - index = map.getAsInt("index") != 0; - optional = map.getAsInt("optional") != 0; - unit = map.getAsString("unit"); - description = map.getAsString("desc"); + iter = map.find(Protocol::SCHEMA_ELT_TYPE); + if (iter == map.end()) + throw SchemaException("SchemaProperty", Protocol::SCHEMA_ELT_TYPE); + typecode = (Typecode) iter->second.asUint8(); + + iter = map.find(Protocol::SCHEMA_ELT_ACCESS); + if (iter != map.end()) + access = (Access) iter->second.asUint8(); + + iter = map.find(Protocol::SCHEMA_ELT_UNIT); + if (iter != map.end()) + unit = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ELT_DESC); + if (iter != map.end()) + description = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_ELT_OPTIONAL); + if (iter != map.end()) + optional = true; } -SchemaProperty* SchemaPropertyImpl::factory(Buffer& buffer) +SchemaProperty* SchemaPropertyImpl::factory(Variant::Map& map) { - SchemaPropertyImpl* impl(new SchemaPropertyImpl(buffer)); + SchemaPropertyImpl* impl(new SchemaPropertyImpl(map)); return new SchemaProperty(impl); } -void SchemaPropertyImpl::encode(Buffer& buffer) const +Variant::Map SchemaPropertyImpl::asMap() const { - FieldTable map; + Variant::Map map; - map.setString("name", name); - map.setInt("type", (int) typecode); - map.setInt("access", (int) access); - map.setInt("index", index ? 1 : 0); - map.setInt("optional", optional ? 1 : 0); + map[Protocol::SCHEMA_ELT_NAME] = Variant(name); + map[Protocol::SCHEMA_ELT_TYPE] = Variant((uint8_t) typecode); + map[Protocol::SCHEMA_ELT_ACCESS] = Variant((uint8_t) access); + if (optional) + map[Protocol::SCHEMA_ELT_OPTIONAL] = Variant(); if (!unit.empty()) - map.setString("unit", unit); + map[Protocol::SCHEMA_ELT_UNIT] = Variant(unit); if (!description.empty()) - map.setString("desc", description); + map[Protocol::SCHEMA_ELT_DESC] = Variant(description); - map.encode(buffer); + return map; } void SchemaPropertyImpl::updateHash(SchemaHash& hash) const @@ -243,52 +276,28 @@ hash.update(description); } -SchemaStatisticImpl::SchemaStatisticImpl(Buffer& buffer) -{ - FieldTable map; - map.decode(buffer); - - name = map.getAsString("name"); - typecode = (Typecode) map.getAsInt("type"); - unit = map.getAsString("unit"); - description = map.getAsString("desc"); -} - -SchemaStatistic* SchemaStatisticImpl::factory(Buffer& buffer) -{ - SchemaStatisticImpl* impl(new SchemaStatisticImpl(buffer)); - return new SchemaStatistic(impl); -} +SchemaClassKeyImpl::SchemaClassKeyImpl(const string& p, const string& n, const SchemaHash& h) : + package(p), name(n), hash(h) {} -void SchemaStatisticImpl::encode(Buffer& buffer) const +SchemaClassKeyImpl::SchemaClassKeyImpl(const Variant::Map& map) : + package(packageContainer), name(nameContainer), hash(hashContainer) { - FieldTable map; + Variant::Map::const_iterator iter; - map.setString("name", name); - map.setInt("type", (int) typecode); - if (!unit.empty()) - map.setString("unit", unit); - if (!description.empty()) - map.setString("desc", description); - - map.encode(buffer); -} - -void SchemaStatisticImpl::updateHash(SchemaHash& hash) const -{ - hash.update(name); - hash.update(typecode); - hash.update(unit); - hash.update(description); -} - -SchemaClassKeyImpl::SchemaClassKeyImpl(const string& p, const string& n, const SchemaHash& h) : package(p), name(n), hash(h) {} - -SchemaClassKeyImpl::SchemaClassKeyImpl(Buffer& buffer) : package(packageContainer), name(nameContainer), hash(hashContainer) -{ - buffer.getShortString(packageContainer); - buffer.getShortString(nameContainer); - hashContainer.decode(buffer); + iter = map.find(Protocol::SCHEMA_PACKAGE); + if (iter == map.end()) + throw SchemaException("SchemaClassKey", Protocol::SCHEMA_PACKAGE); + packageContainer = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_CLASS); + if (iter == map.end()) + throw SchemaException("SchemaClassKey", Protocol::SCHEMA_CLASS); + nameContainer = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_HASH); + if (iter == map.end()) + throw SchemaException("SchemaClassKey", Protocol::SCHEMA_HASH); + hashContainer.set(iter->second.asUuid().data()); } SchemaClassKey* SchemaClassKeyImpl::factory(const string& package, const string& name, const SchemaHash& hash) @@ -297,17 +306,21 @@ return new SchemaClassKey(impl); } -SchemaClassKey* SchemaClassKeyImpl::factory(Buffer& buffer) +SchemaClassKey* SchemaClassKeyImpl::factory(Variant::Map& map) { - SchemaClassKeyImpl* impl(new SchemaClassKeyImpl(buffer)); + SchemaClassKeyImpl* impl(new SchemaClassKeyImpl(map)); return new SchemaClassKey(impl); } -void SchemaClassKeyImpl::encode(Buffer& buffer) const +Variant::Map SchemaClassKeyImpl::asMap() const { - buffer.putShortString(package); - buffer.putShortString(name); - hash.encode(buffer); + Variant::Map map; + + map[Protocol::SCHEMA_PACKAGE] = Variant(package); + map[Protocol::SCHEMA_CLASS] = Variant(name); + map[Protocol::SCHEMA_HASH] = Variant(); // TODO: use UUID type when available + + return map; } bool SchemaClassKeyImpl::operator==(const SchemaClassKeyImpl& other) const @@ -335,10 +348,21 @@ return repr; } -SchemaObjectClassImpl::SchemaObjectClassImpl(Buffer& buffer) : hasHash(true), classKey(SchemaClassKeyImpl::factory(package, name, hash)) +SchemaObjectClassImpl::SchemaObjectClassImpl(const Variant::Map& map) : + hasHash(true), classKey(SchemaClassKeyImpl::factory(package, name, hash)) { - buffer.getShortString(package); - buffer.getShortString(name); + Variant::Map::const_iterator iter; + + iter = map.find(Protocol::SCHEMA_PACKAGE); + if (iter == map.end()) + throw SchemaException("SchemaObjectClass", Protocol::SCHEMA_PACKAGE); + package = iter->second.asString(); + + iter = map.find(Protocol::SCHEMA_CLASS); + if (iter == map.end()) + throw SchemaException("SchemaObjectClass", Protocol::SCHEMA_CLASS); + name = iter->second.asString(); + hash.decode(buffer); uint16_t propCount = buffer.getShort(); @@ -350,24 +374,19 @@ addProperty(property); } - for (uint16_t idx = 0; idx < statCount; idx++) { - const SchemaStatistic* statistic = SchemaStatisticImpl::factory(buffer); - addStatistic(statistic); - } - for (uint16_t idx = 0; idx < methodCount; idx++) { SchemaMethod* method = SchemaMethodImpl::factory(buffer); addMethod(method); } } -SchemaObjectClass* SchemaObjectClassImpl::factory(Buffer& buffer) +SchemaObjectClass* SchemaObjectClassImpl::factory(Variant::Map& map) { SchemaObjectClassImpl* impl(new SchemaObjectClassImpl(buffer)); return new SchemaObjectClass(impl); } -void SchemaObjectClassImpl::encode(Buffer& buffer) const +void SchemaObjectClassImpl::encode(Variant::Map& map) const { buffer.putOctet((uint8_t) CLASS_OBJECT); buffer.putShortString(package); @@ -454,11 +473,12 @@ return 0; } -SchemaEventClassImpl::SchemaEventClassImpl(Buffer& buffer) : hasHash(true), classKey(SchemaClassKeyImpl::factory(package, name, hash)) +SchemaEventClassImpl::SchemaEventClassImpl(Variant::Map& map) : hasHash(true), classKey(SchemaClassKeyImpl::factory(package, name, hash)) { buffer.getShortString(package); buffer.getShortString(name); hash.decode(buffer); + buffer.putOctet(0); // No parent class uint16_t argCount = buffer.getShort(); @@ -468,13 +488,13 @@ } } -SchemaEventClass* SchemaEventClassImpl::factory(Buffer& buffer) +SchemaEventClass* SchemaEventClassImpl::factory(Variant::Map& map) { SchemaEventClassImpl* impl(new SchemaEventClassImpl(buffer)); return new SchemaEventClass(impl); } -void SchemaEventClassImpl::encode(Buffer& buffer) const +void SchemaEventClassImpl::encode(Variant::Map& map) const { buffer.putOctet((uint8_t) CLASS_EVENT); buffer.putShortString(package); @@ -561,17 +581,6 @@ const char* SchemaProperty::getUnit() const { return impl->getUnit().c_str(); } const char* SchemaProperty::getDesc() const { return impl->getDesc().c_str(); } -SchemaStatistic::SchemaStatistic(const char* name, Typecode typecode) : impl(new SchemaStatisticImpl(name, typecode)) {} -SchemaStatistic::SchemaStatistic(SchemaStatisticImpl* i) : impl(i) {} -SchemaStatistic::SchemaStatistic(const SchemaStatistic& from) : impl(new SchemaStatisticImpl(*(from.impl))) {} -SchemaStatistic::~SchemaStatistic() { delete impl; } -void SchemaStatistic::setUnit(const char* val) { impl->setUnit(val); } -void SchemaStatistic::setDesc(const char* desc) { impl->setDesc(desc); } -const char* SchemaStatistic::getName() const { return impl->getName().c_str(); } -Typecode SchemaStatistic::getType() const { return impl->getType(); } -const char* SchemaStatistic::getUnit() const { return impl->getUnit().c_str(); } -const char* SchemaStatistic::getDesc() const { return impl->getDesc().c_str(); } - SchemaClassKey::SchemaClassKey(SchemaClassKeyImpl* i) : impl(i) {} SchemaClassKey::SchemaClassKey(const SchemaClassKey& from) : impl(new SchemaClassKeyImpl(*(from.impl))) {} SchemaClassKey::~SchemaClassKey() { delete impl; } @@ -587,24 +596,20 @@ SchemaObjectClass::SchemaObjectClass(const SchemaObjectClass& from) : impl(new SchemaObjectClassImpl(*(from.impl))) {} SchemaObjectClass::~SchemaObjectClass() { delete impl; } void SchemaObjectClass::addProperty(const SchemaProperty* property) { impl->addProperty(property); } -void SchemaObjectClass::addStatistic(const SchemaStatistic* statistic) { impl->addStatistic(statistic); } void SchemaObjectClass::addMethod(const SchemaMethod* method) { impl->addMethod(method); } const SchemaClassKey* SchemaObjectClass::getClassKey() const { return impl->getClassKey(); } int SchemaObjectClass::getPropertyCount() const { return impl->getPropertyCount(); } -int SchemaObjectClass::getStatisticCount() const { return impl->getStatisticCount(); } int SchemaObjectClass::getMethodCount() const { return impl->getMethodCount(); } const SchemaProperty* SchemaObjectClass::getProperty(int idx) const { return impl->getProperty(idx); } -const SchemaStatistic* SchemaObjectClass::getStatistic(int idx) const { return impl->getStatistic(idx); } const SchemaMethod* SchemaObjectClass::getMethod(int idx) const { return impl->getMethod(idx); } -SchemaEventClass::SchemaEventClass(const char* package, const char* name, Severity s) : impl(new SchemaEventClassImpl(package, name, s)) {} +SchemaEventClass::SchemaEventClass(const char* package, const char* name) : impl(new SchemaEventClassImpl(package, name)) {} SchemaEventClass::SchemaEventClass(SchemaEventClassImpl* i) : impl(i) {} SchemaEventClass::SchemaEventClass(const SchemaEventClass& from) : impl(new SchemaEventClassImpl(*(from.impl))) {} SchemaEventClass::~SchemaEventClass() { delete impl; } void SchemaEventClass::addArgument(const SchemaArgument* argument) { impl->addArgument(argument); } void SchemaEventClass::setDesc(const char* desc) { impl->setDesc(desc); } const SchemaClassKey* SchemaEventClass::getClassKey() const { return impl->getClassKey(); } -Severity SchemaEventClass::getSeverity() const { return impl->getSeverity(); } int SchemaEventClass::getArgumentCount() const { return impl->getArgumentCount(); } const SchemaArgument* SchemaEventClass::getArgument(int idx) const { return impl->getArgument(idx); } Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.h URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.h?rev=911854&r1=911853&r2=911854&view=diff ============================================================================== --- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.h (original) +++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.h Fri Feb 19 16:06:22 2010 @@ -21,9 +21,10 @@ */ #include "qmf/engine/Schema.h" +#include <string.h> #include <string> #include <vector> -#include <qpid/framing/Buffer.h> +#include <exception> namespace qmf { namespace engine { @@ -32,20 +33,33 @@ // TODO: Add "frozen" attribute for schema classes so they can't be modified after // they've been registered. + typedef qpid::messaging::VariantType Typecode; + + class SchemaException : public std::exception { + public: + SchemaException(const std::string& context, const std::string& expected) { + text = context + ": Expected item with key " + expected; + } + virtual ~SchemaException() throw(); + virtual const char* what() const throw() { return text.c_str(); } + + private: + std::string text; + }; + class SchemaHash { uint8_t hash[16]; public: SchemaHash(); - void encode(qpid::framing::Buffer& buffer) const; - void decode(qpid::framing::Buffer& buffer); void update(const char* data, uint32_t len); void update(uint8_t data); void update(const std::string& data) { update(data.c_str(), data.size()); } - void update(Typecode t) { update((uint8_t) t); } void update(Direction d) { update((uint8_t) d); } void update(Access a) { update((uint8_t) a); } + void update(Typecode a) { update((uint8_t) a); } void update(bool b) { update((uint8_t) (b ? 1 : 0)); } const uint8_t* get() const { return hash; } + void set(const uint8_t* val) { ::memcpy(hash, val, 16); } bool operator==(const SchemaHash& other) const; bool operator<(const SchemaHash& other) const; bool operator>(const SchemaHash& other) const; @@ -59,9 +73,9 @@ std::string description; SchemaArgumentImpl(const char* n, Typecode t) : name(n), typecode(t), dir(DIR_IN) {} - SchemaArgumentImpl(qpid::framing::Buffer& buffer); - static SchemaArgument* factory(qpid::framing::Buffer& buffer); - void encode(qpid::framing::Buffer& buffer) const; + SchemaArgumentImpl(const qpid::messaging::Variant::Map& map); + static SchemaArgument* factory(qpid::messaging::Variant::Map& map); + qpid::messaging::Variant::Map asMap() const; void setDirection(Direction d) { dir = d; } void setUnit(const char* val) { unit = val; } void setDesc(const char* desc) { description = desc; } @@ -79,9 +93,9 @@ std::vector<const SchemaArgument*> arguments; SchemaMethodImpl(const char* n) : name(n) {} - SchemaMethodImpl(qpid::framing::Buffer& buffer); - static SchemaMethod* factory(qpid::framing::Buffer& buffer); - void encode(qpid::framing::Buffer& buffer) const; + SchemaMethodImpl(const qpid::messaging::Variant::Map& map); + static SchemaMethod* factory(qpid::messaging::Variant::Map& map); + qpid::messaging::Variant::Map asMap() const; void addArgument(const SchemaArgument* argument); void setDesc(const char* desc) { description = desc; } const std::string& getName() const { return name; } @@ -101,9 +115,9 @@ std::string description; SchemaPropertyImpl(const char* n, Typecode t) : name(n), typecode(t), access(ACCESS_READ_ONLY), index(false), optional(false) {} - SchemaPropertyImpl(qpid::framing::Buffer& buffer); - static SchemaProperty* factory(qpid::framing::Buffer& buffer); - void encode(qpid::framing::Buffer& buffer) const; + SchemaPropertyImpl(const qpid::messaging::Variant::Map& map); + static SchemaProperty* factory(qpid::messaging::Variant::Map& map); + qpid::messaging::Variant::Map asMap() const; void setAccess(Access a) { access = a; } void setIndex(bool val) { index = val; } void setOptional(bool val) { optional = val; } @@ -119,25 +133,6 @@ void updateHash(SchemaHash& hash) const; }; - struct SchemaStatisticImpl { - std::string name; - Typecode typecode; - std::string unit; - std::string description; - - SchemaStatisticImpl(const char* n, Typecode t) : name(n), typecode(t) {} - SchemaStatisticImpl(qpid::framing::Buffer& buffer); - static SchemaStatistic* factory(qpid::framing::Buffer& buffer); - void encode(qpid::framing::Buffer& buffer) const; - void setUnit(const char* val) { unit = val; } - void setDesc(const char* desc) { description = desc; } - const std::string& getName() const { return name; } - Typecode getType() const { return typecode; } - const std::string& getUnit() const { return unit; } - const std::string& getDesc() const { return description; } - void updateHash(SchemaHash& hash) const; - }; - struct SchemaClassKeyImpl { const std::string& package; const std::string& name; @@ -151,15 +146,15 @@ SchemaHash hashContainer; SchemaClassKeyImpl(const std::string& package, const std::string& name, const SchemaHash& hash); - SchemaClassKeyImpl(qpid::framing::Buffer& buffer); + SchemaClassKeyImpl(const qpid::messaging::Variant::Map& map); static SchemaClassKey* factory(const std::string& package, const std::string& name, const SchemaHash& hash); - static SchemaClassKey* factory(qpid::framing::Buffer& buffer); + static SchemaClassKey* factory(qpid::messaging::Variant::Map& map); const std::string& getPackageName() const { return package; } const std::string& getClassName() const { return name; } const uint8_t* getHash() const { return hash.get(); } - void encode(qpid::framing::Buffer& buffer) const; + qpid::messaging::Variant::Map asMap() const; bool operator==(const SchemaClassKeyImpl& other) const; bool operator<(const SchemaClassKeyImpl& other) const; const std::string& str() const; @@ -172,25 +167,21 @@ mutable bool hasHash; std::auto_ptr<SchemaClassKey> classKey; std::vector<const SchemaProperty*> properties; - std::vector<const SchemaStatistic*> statistics; std::vector<const SchemaMethod*> methods; SchemaObjectClassImpl(const char* p, const char* n) : package(p), name(n), hasHash(false), classKey(SchemaClassKeyImpl::factory(package, name, hash)) {} - SchemaObjectClassImpl(qpid::framing::Buffer& buffer); - static SchemaObjectClass* factory(qpid::framing::Buffer& buffer); + SchemaObjectClassImpl(const qpid::messaging::Variant::Map& map); + static SchemaObjectClass* factory(qpid::messaging::Variant::Map& map); - void encode(qpid::framing::Buffer& buffer) const; + qpid::messaging::Variant::Map asMap() const; void addProperty(const SchemaProperty* property); - void addStatistic(const SchemaStatistic* statistic); void addMethod(const SchemaMethod* method); const SchemaClassKey* getClassKey() const; int getPropertyCount() const { return properties.size(); } - int getStatisticCount() const { return statistics.size(); } int getMethodCount() const { return methods.size(); } const SchemaProperty* getProperty(int idx) const; - const SchemaStatistic* getStatistic(int idx) const; const SchemaMethod* getMethod(int idx) const; }; @@ -201,20 +192,18 @@ mutable bool hasHash; std::auto_ptr<SchemaClassKey> classKey; std::string description; - Severity severity; std::vector<const SchemaArgument*> arguments; - SchemaEventClassImpl(const char* p, const char* n, Severity sev) : - package(p), name(n), hasHash(false), classKey(SchemaClassKeyImpl::factory(package, name, hash)), severity(sev) {} - SchemaEventClassImpl(qpid::framing::Buffer& buffer); - static SchemaEventClass* factory(qpid::framing::Buffer& buffer); + SchemaEventClassImpl(const char* p, const char* n) : + package(p), name(n), hasHash(false), classKey(SchemaClassKeyImpl::factory(package, name, hash)) {} + SchemaEventClassImpl(const qpid::messaging::Variant::Map& map); + static SchemaEventClass* factory(qpid::messaging::Variant::Map& map); - void encode(qpid::framing::Buffer& buffer) const; + qpid::messaging::Variant::Map asMap() const; void addArgument(const SchemaArgument* argument); void setDesc(const char* desc) { description = desc; } const SchemaClassKey* getClassKey() const; - Severity getSeverity() const { return severity; } int getArgumentCount() const { return arguments.size(); } const SchemaArgument* getArgument(int idx) const; }; --------------------------------------------------------------------- Apache Qpid - AMQP Messaging Implementation Project: http://qpid.apache.org Use/Interact: mailto:[email protected]
