You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by tr...@apache.org on 2010/02/19 17:06:23 UTC
svn commit: r911854 [2/2] - in /qpid/branches/qmf-devel0.7/qpid/cpp:
include/qmf/ include/qmf/engine/ src/ src/qmf/ src/qmf/engine/
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:commits-subscribe@qpid.apache.org