summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--qpid/cpp/bindings/qmf/qmfengine.i6
-rw-r--r--qpid/cpp/include/qmf/Protocol.h5
-rw-r--r--qpid/cpp/include/qmf/engine/Agent.h12
-rw-r--r--qpid/cpp/include/qmf/engine/Console.h3
-rw-r--r--qpid/cpp/include/qmf/engine/Event.h6
-rw-r--r--qpid/cpp/include/qmf/engine/Object.h6
-rw-r--r--qpid/cpp/include/qmf/engine/Schema.h104
-rw-r--r--qpid/cpp/src/qmf/Protocol.cpp8
-rw-r--r--qpid/cpp/src/qmf/engine/Agent.cpp52
-rw-r--r--qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp8
-rw-r--r--qpid/cpp/src/qmf/engine/ConsoleImpl.h13
-rw-r--r--qpid/cpp/src/qmf/engine/EventImpl.cpp18
-rw-r--r--qpid/cpp/src/qmf/engine/EventImpl.h2
-rw-r--r--qpid/cpp/src/qmf/engine/ObjectImpl.cpp8
-rw-r--r--qpid/cpp/src/qmf/engine/ObjectImpl.h10
-rw-r--r--qpid/cpp/src/qmf/engine/SchemaImpl.cpp416
-rw-r--r--qpid/cpp/src/qmf/engine/SchemaImpl.h117
17 files changed, 257 insertions, 537 deletions
diff --git a/qpid/cpp/bindings/qmf/qmfengine.i b/qpid/cpp/bindings/qmf/qmfengine.i
index eb350115a3..152e58d9d9 100644
--- a/qpid/cpp/bindings/qmf/qmfengine.i
+++ b/qpid/cpp/bindings/qmf/qmfengine.i
@@ -21,20 +21,14 @@
#include "qmf/engine/Agent.h"
#include "qmf/engine/Console.h"
-#include "qmf/engine/ResilientConnection.h"
%}
%include <qmf/engine/QmfEngineImportExport.h>
%include <qmf/engine/Query.h>
-%include <qmf/engine/Message.h>
%include <qmf/engine/Agent.h>
%include <qmf/engine/Console.h>
-%include <qmf/engine/ConnectionSettings.h>
-%include <qmf/engine/ResilientConnection.h>
-%include <qmf/engine/Typecode.h>
%include <qmf/engine/Schema.h>
-%include <qmf/engine/Value.h>
%include <qmf/engine/ObjectId.h>
%include <qmf/engine/Object.h>
%include <qmf/engine/Event.h>
diff --git a/qpid/cpp/include/qmf/Protocol.h b/qpid/cpp/include/qmf/Protocol.h
index 07870b0eb5..c45ce13434 100644
--- a/qpid/cpp/include/qmf/Protocol.h
+++ b/qpid/cpp/include/qmf/Protocol.h
@@ -36,7 +36,6 @@ namespace qmf {
//static bool checkHeader(const qpid::messaging::Message& msg, std::string& opcode, uint32_t *seq);
//static void encodeHeader(qpid::messaging::Message& msg, const std::string& opcode, uint32_t seq = 0);
- const static std::string SCHEMA_ELT_NAME;
const static std::string SCHEMA_ELT_TYPE;
const static std::string SCHEMA_ELT_DIR;
const static std::string SCHEMA_ELT_UNIT;
@@ -53,6 +52,10 @@ namespace qmf {
const static std::string AGENT_NAME;
const static std::string OBJECT_NAME;
const static std::string SCHEMA_ID;
+ const static std::string VALUES;
+ const static std::string SUBTYPES;
+ const static std::string SUBTYPE_SCHEMA_PROPERTY;
+ const static std::string SUBTYPE_SCHEMA_METHOD;
/*
const static uint8_t OP_ATTACH_REQUEST = 'A';
diff --git a/qpid/cpp/include/qmf/engine/Agent.h b/qpid/cpp/include/qmf/engine/Agent.h
index c645b3cc01..268e53a9a5 100644
--- a/qpid/cpp/include/qmf/engine/Agent.h
+++ b/qpid/cpp/include/qmf/engine/Agent.h
@@ -55,7 +55,7 @@ namespace engine {
char* objectKey; // Object key for method call (METHOD_CALL)
Query* query; // Query parameters (GET_QUERY, START_SYNC)
qpid::messaging::Variant::Map* arguments; // Method parameters (METHOD_CALL)
- const SchemaObjectClass* objectClass; // (METHOD_CALL)
+ const SchemaClass* objectClass; // (METHOD_CALL)
};
class AgentImpl;
@@ -134,15 +134,9 @@ namespace engine {
/**
* Register a schema class with the Agent.
- *@param cls A SchemaObejctClass object that defines data managed by the agent.
+ *@param cls A SchemaClass object that defines data managed by the agent.
*/
- void registerClass(SchemaObjectClass* cls);
-
- /**
- * Register a schema class with the Agent.
- *@param cls A SchemaEventClass object that defines events sent by the agent.
- */
- void registerClass(SchemaEventClass* cls);
+ void registerClass(SchemaClass* cls);
/**
* Give an object to the Agent for storage and management. Once added, the agent takes
diff --git a/qpid/cpp/include/qmf/engine/Console.h b/qpid/cpp/include/qmf/engine/Console.h
index b99d63b9a6..853d0362f3 100644
--- a/qpid/cpp/include/qmf/engine/Console.h
+++ b/qpid/cpp/include/qmf/engine/Console.h
@@ -204,8 +204,7 @@ namespace engine {
const SchemaClassKey* getClass(const char* packageName, uint32_t idx) const;
ClassKind getClassKind(const SchemaClassKey* key) const;
- const SchemaObjectClass* getObjectClass(const SchemaClassKey* key) const;
- const SchemaEventClass* getEventClass(const SchemaClassKey* key) const;
+ const SchemaClass* getClass(const SchemaClassKey* key) const;
void bindPackage(const char* packageName);
void bindClass(const SchemaClassKey* key);
diff --git a/qpid/cpp/include/qmf/engine/Event.h b/qpid/cpp/include/qmf/engine/Event.h
index 647b88dbf8..5096e3e064 100644
--- a/qpid/cpp/include/qmf/engine/Event.h
+++ b/qpid/cpp/include/qmf/engine/Event.h
@@ -23,17 +23,17 @@
namespace qmf {
namespace engine {
- class SchemaEventClass;
+ class SchemaClass;
class Value;
struct EventImpl;
class Event {
public:
- Event(const SchemaEventClass* type);
+ Event(const SchemaClass* type);
Event(const Event& from);
~Event();
- const SchemaEventClass* getClass() const;
+ const SchemaClass* getClass() const;
Value* getValue(const char* key) const;
private:
diff --git a/qpid/cpp/include/qmf/engine/Object.h b/qpid/cpp/include/qmf/engine/Object.h
index 81dbf45521..61d4f3d75c 100644
--- a/qpid/cpp/include/qmf/engine/Object.h
+++ b/qpid/cpp/include/qmf/engine/Object.h
@@ -31,15 +31,15 @@ namespace engine {
class Object {
public:
Object();
- Object(SchemaObjectClass* type);
+ Object(SchemaClass* type);
Object(const Object& from);
virtual ~Object();
const qpid::messaging::Variant::Map& getValues() const;
qpid::messaging::Variant::Map& getValues();
- const SchemaObjectClass* getSchema() const;
- void setSchema(SchemaObjectClass* schema);
+ const SchemaClass* getSchema() const;
+ void setSchema(SchemaClass* schema);
const char* getKey() const;
void setKey(const char* key);
diff --git a/qpid/cpp/include/qmf/engine/Schema.h b/qpid/cpp/include/qmf/engine/Schema.h
index 18a4cef8de..3ab0a9e35d 100644
--- a/qpid/cpp/include/qmf/engine/Schema.h
+++ b/qpid/cpp/include/qmf/engine/Schema.h
@@ -28,37 +28,41 @@ namespace engine {
enum Access { ACCESS_READ_CREATE = 1, ACCESS_READ_WRITE = 2, ACCESS_READ_ONLY = 3 };
enum Direction { DIR_IN = 1, DIR_OUT = 2, DIR_IN_OUT = 3 };
- enum ClassKind { CLASS_OBJECT = 1, CLASS_EVENT = 2 };
+ enum ClassKind { CLASS_DATA = 1, CLASS_EVENT = 2 };
- struct SchemaArgumentImpl;
struct SchemaMethodImpl;
struct SchemaPropertyImpl;
- struct SchemaObjectClassImpl;
- struct SchemaEventClassImpl;
+ struct SchemaClassImpl;
struct SchemaClassKeyImpl;
/**
*/
- class SchemaArgument {
+ class SchemaProperty {
public:
- SchemaArgument(const char* name, qpid::messaging::VariantType typecode);
- SchemaArgument(const SchemaArgument& from);
- ~SchemaArgument();
+ SchemaProperty(const char* name, qpid::messaging::VariantType typecode);
+ SchemaProperty(const SchemaProperty& from);
+ ~SchemaProperty();
+ void setAccess(Access access);
+ void setIndex(bool val);
+ void setOptional(bool val);
void setDirection(Direction dir);
void setUnit(const char* val);
void setDesc(const char* desc);
const char* getName() const;
qpid::messaging::VariantType getType() const;
+ Access getAccess() const;
+ bool isIndex() const;
+ bool isOptional() const;
Direction getDirection() const;
const char* getUnit() const;
const char* getDesc() const;
private:
- friend struct SchemaArgumentImpl;
+ friend struct SchemaPropertyImpl;
+ friend struct SchemaClassImpl;
friend struct SchemaMethodImpl;
- friend struct SchemaEventClassImpl;
- SchemaArgument(SchemaArgumentImpl* impl);
- SchemaArgumentImpl* impl;
+ SchemaProperty(SchemaPropertyImpl* impl);
+ SchemaPropertyImpl* impl;
};
/**
@@ -68,16 +72,16 @@ namespace engine {
SchemaMethod(const char* name);
SchemaMethod(const SchemaMethod& from);
~SchemaMethod();
- void addArgument(const SchemaArgument* argument);
+ void addProperty(const SchemaProperty* property);
void setDesc(const char* desc);
const char* getName() const;
const char* getDesc() const;
- int getArgumentCount() const;
- const SchemaArgument* getArgument(int idx) const;
+ int getPropertyCount() const;
+ const SchemaProperty* getProperty(int idx) const;
private:
friend struct SchemaMethodImpl;
- friend struct SchemaObjectClassImpl;
+ friend struct SchemaClassImpl;
friend class AgentImpl;
SchemaMethod(SchemaMethodImpl* impl);
SchemaMethodImpl* impl;
@@ -85,41 +89,15 @@ namespace engine {
/**
*/
- class SchemaProperty {
- public:
- SchemaProperty(const char* name, qpid::messaging::VariantType typecode);
- SchemaProperty(const SchemaProperty& from);
- ~SchemaProperty();
- void setAccess(Access access);
- void setIndex(bool val);
- void setOptional(bool val);
- void setUnit(const char* val);
- void setDesc(const char* desc);
- const char* getName() const;
- qpid::messaging::VariantType getType() const;
- Access getAccess() const;
- bool isIndex() const;
- bool isOptional() const;
- const char* getUnit() const;
- const char* getDesc() const;
-
- private:
- friend struct SchemaPropertyImpl;
- friend struct SchemaObjectClassImpl;
- SchemaProperty(SchemaPropertyImpl* impl);
- SchemaPropertyImpl* impl;
- };
-
- /**
- */
class SchemaClassKey {
public:
SchemaClassKey(const SchemaClassKey& from);
~SchemaClassKey();
+ ClassKind getKind() const;
const char* getPackageName() const;
const char* getClassName() const;
- const uint8_t* getHash() const;
+ const uint8_t* getHashData() const;
const char* asString() const;
bool operator==(const SchemaClassKey& other) const;
@@ -127,6 +105,7 @@ namespace engine {
private:
friend struct SchemaClassKeyImpl;
+ friend struct SchemaClassImpl;
friend class BrokerProxyImpl;
friend class ConsoleImpl;
SchemaClassKey(SchemaClassKeyImpl* impl);
@@ -135,14 +114,15 @@ namespace engine {
/**
*/
- class SchemaObjectClass {
+ class SchemaClass {
public:
- SchemaObjectClass(const char* package, const char* name);
- SchemaObjectClass(const SchemaObjectClass& from);
- ~SchemaObjectClass();
+ SchemaClass(ClassKind kind, const char* package, const char* name);
+ SchemaClass(const SchemaClass& from);
+ ~SchemaClass();
void addProperty(const SchemaProperty* property);
void addMethod(const SchemaMethod* method);
+ ClassKind getKind() const;
const SchemaClassKey* getClassKey() const;
int getPropertyCount() const;
int getMethodCount() const;
@@ -150,33 +130,11 @@ namespace engine {
const SchemaMethod* getMethod(int idx) const;
private:
- friend struct SchemaObjectClassImpl;
- friend class BrokerProxyImpl;
- friend class AgentImpl;
- SchemaObjectClass(SchemaObjectClassImpl* impl);
- SchemaObjectClassImpl* impl;
- };
-
- /**
- */
- class SchemaEventClass {
- public:
- SchemaEventClass(const char* package, const char* name);
- SchemaEventClass(const SchemaEventClass& from);
- ~SchemaEventClass();
- void addArgument(const SchemaArgument* argument);
- void setDesc(const char* desc);
-
- const SchemaClassKey* getClassKey() const;
- int getArgumentCount() const;
- const SchemaArgument* getArgument(int idx) const;
-
- private:
- friend struct SchemaEventClassImpl;
+ friend struct SchemaClassImpl;
friend class BrokerProxyImpl;
friend class AgentImpl;
- SchemaEventClass(SchemaEventClassImpl* impl);
- SchemaEventClassImpl* impl;
+ SchemaClass(SchemaClassImpl* impl);
+ SchemaClassImpl* impl;
};
}
}
diff --git a/qpid/cpp/src/qmf/Protocol.cpp b/qpid/cpp/src/qmf/Protocol.cpp
index 154081c9d4..faaa4c567d 100644
--- a/qpid/cpp/src/qmf/Protocol.cpp
+++ b/qpid/cpp/src/qmf/Protocol.cpp
@@ -22,14 +22,13 @@
using namespace std;
using namespace qmf;
-const string Protocol::SCHEMA_ELT_NAME("name");
const string Protocol::SCHEMA_ELT_TYPE("type");
const string Protocol::SCHEMA_ELT_DIR("dir");
const string Protocol::SCHEMA_ELT_UNIT("unit");
const string Protocol::SCHEMA_ELT_DESC("desc");
const string Protocol::SCHEMA_ELT_ACCESS("access");
const string Protocol::SCHEMA_ELT_OPTIONAL("optional");
-const string Protocol::SCHEMA_ARGS("args");
+const string Protocol::SCHEMA_ARGS("_arguments");
const string Protocol::SCHEMA_PACKAGE("_package_name");
const string Protocol::SCHEMA_CLASS_KIND("_type");
const string Protocol::SCHEMA_CLASS_KIND_DATA("_data");
@@ -39,6 +38,11 @@ const string Protocol::SCHEMA_HASH("_hash_str");
const string Protocol::AGENT_NAME("_agent_name");
const string Protocol::OBJECT_NAME("_object_name");
const string Protocol::SCHEMA_ID("_schema_id");
+const string Protocol::VALUES("_values");
+const string Protocol::SUBTYPES("_subtypes");
+const string Protocol::SUBTYPE_SCHEMA_PROPERTY("qmfProperty");
+const string Protocol::SUBTYPE_SCHEMA_METHOD("qmfMethod");
+
#if 0
bool Protocol::checkHeader(const Message& /*msg*/, string& /*opcode*/, uint32_t* /*seq*/)
diff --git a/qpid/cpp/src/qmf/engine/Agent.cpp b/qpid/cpp/src/qmf/engine/Agent.cpp
index ec84b4381d..22d53e93b7 100644
--- a/qpid/cpp/src/qmf/engine/Agent.cpp
+++ b/qpid/cpp/src/qmf/engine/Agent.cpp
@@ -58,7 +58,7 @@ namespace engine {
string objectKey;
boost::shared_ptr<Query> query;
boost::shared_ptr<Variant::Map> arguments;
- const SchemaObjectClass* objectClass;
+ const SchemaClass* objectClass;
AgentEventImpl(AgentEvent::EventKind k) :
kind(k), sequence(0), object(0), objectClass(0) {}
@@ -92,8 +92,7 @@ namespace engine {
void methodResponse(uint32_t sequence, uint32_t status, char* text, const Variant::Map& arguments);
void queryResponse(uint32_t sequence, Object& object);
void queryComplete(uint32_t sequence);
- void registerClass(SchemaObjectClass* cls);
- void registerClass(SchemaEventClass* cls);
+ void registerClass(SchemaClass* cls);
const char* addObject(Object& obj, const char* key);
void raiseEvent(Event& event);
@@ -149,21 +148,14 @@ namespace engine {
}
};
- typedef map<AgentClassKey, SchemaObjectClass*, AgentClassKeyComp> ObjectClassMap;
- typedef map<AgentClassKey, SchemaEventClass*, AgentClassKeyComp> EventClassMap;
-
- struct ClassMaps {
- ObjectClassMap objectClasses;
- EventClassMap eventClasses;
- };
-
- map<string, ClassMaps> packages;
+ typedef map<AgentClassKey, SchemaClass*, AgentClassKeyComp> ClassMap;
+ map<string, ClassMap> packages;
AgentEventImpl::Ptr eventQuery(uint32_t num, const string& userId, const string& package, const string& cls,
const string& key);
AgentEventImpl::Ptr eventMethod(uint32_t num, const string& userId, const string& method,
const string& key, boost::shared_ptr<Variant::Map> argMap,
- const SchemaObjectClass* objectClass);
+ const SchemaClass* cls);
void handleRcvMessageLH(qpid::messaging::Message& message);
void sendPackageIndicationLH(const string& packageName);
@@ -331,36 +323,19 @@ void AgentImpl::queryComplete(uint32_t sequence)
//sendCommandCompleteLH(context->exchange, context->key, context->sequence, 0, "OK");
}
-void AgentImpl::registerClass(SchemaObjectClass* cls)
-{
- Mutex::ScopedLock _lock(lock);
-
- map<string, ClassMaps>::iterator iter = packages.find(cls->getClassKey()->getPackageName());
- if (iter == packages.end()) {
- packages[cls->getClassKey()->getPackageName()] = ClassMaps();
- iter = packages.find(cls->getClassKey()->getPackageName());
- // TODO: Indicate this package if connected
- }
-
- AgentClassKey key(cls->getClassKey()->getClassName(), cls->getClassKey()->getHash());
- iter->second.objectClasses[key] = cls;
-
- // TODO: Indicate this schema if connected.
-}
-
-void AgentImpl::registerClass(SchemaEventClass* cls)
+void AgentImpl::registerClass(SchemaClass* cls)
{
Mutex::ScopedLock _lock(lock);
- map<string, ClassMaps>::iterator iter = packages.find(cls->getClassKey()->getPackageName());
+ map<string, ClassMap>::iterator iter = packages.find(cls->getClassKey()->getPackageName());
if (iter == packages.end()) {
- packages[cls->getClassKey()->getPackageName()] = ClassMaps();
+ packages[cls->getClassKey()->getPackageName()] = ClassMap();
iter = packages.find(cls->getClassKey()->getPackageName());
// TODO: Indicate this package if connected
}
- AgentClassKey key(cls->getClassKey()->getClassName(), cls->getClassKey()->getHash());
- iter->second.eventClasses[key] = cls;
+ AgentClassKey key(cls->getClassKey()->getClassName(), cls->getClassKey()->getHashData());
+ iter->second[key] = cls;
// TODO: Indicate this schema if connected.
}
@@ -420,7 +395,7 @@ AgentEventImpl::Ptr AgentImpl::eventQuery(uint32_t num, const string& userId, co
AgentEventImpl::Ptr AgentImpl::eventMethod(uint32_t num, const string& userId, const string& method,
const string& key, boost::shared_ptr<Variant::Map> argMap,
- const SchemaObjectClass* objectClass)
+ const SchemaClass* cls)
{
AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::METHOD_CALL));
event->sequence = num;
@@ -428,7 +403,7 @@ AgentEventImpl::Ptr AgentImpl::eventMethod(uint32_t num, const string& userId, c
event->name = method;
event->objectKey = key;
event->arguments = argMap;
- event->objectClass = objectClass;
+ event->objectClass = cls;
return event;
}
@@ -505,8 +480,7 @@ void Agent::setConnection(Connection& conn) { impl->setConnection(conn); }
void Agent::methodResponse(uint32_t sequence, uint32_t status, char* text, const Variant::Map& arguments) { impl->methodResponse(sequence, status, text, arguments); }
void Agent::queryResponse(uint32_t sequence, Object& object) { impl->queryResponse(sequence, object); }
void Agent::queryComplete(uint32_t sequence) { impl->queryComplete(sequence); }
-void Agent::registerClass(SchemaObjectClass* cls) { impl->registerClass(cls); }
-void Agent::registerClass(SchemaEventClass* cls) { impl->registerClass(cls); }
+void Agent::registerClass(SchemaClass* cls) { impl->registerClass(cls); }
const char* Agent::addObject(Object& obj, const char* key) { return impl->addObject(obj, key); }
void Agent::raiseEvent(Event& event) { impl->raiseEvent(event); }
diff --git a/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp b/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp
index 2d955b0c26..46ed653576 100644
--- a/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp
+++ b/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp
@@ -246,13 +246,13 @@ bool BrokerProxyImpl::sendGetRequestLH(SequenceContext::Ptr queryContext, const
string BrokerProxyImpl::encodeMethodArguments(const SchemaMethod* schema, const Value* argmap, Buffer& buffer)
{
- int argCount = schema->getArgumentCount();
+ int argCount = schema->getPropertyCount();
if (argmap == 0 || !argmap->isMap())
return string("Arguments must be in a map value");
for (int aIdx = 0; aIdx < argCount; aIdx++) {
- const SchemaArgument* arg(schema->getArgument(aIdx));
+ const SchemaProperty* arg(schema->getProperty(aIdx));
if (arg->getDirection() == DIR_IN || arg->getDirection() == DIR_IN_OUT) {
if (argmap->keyInMap(arg->getName())) {
const Value* argVal(argmap->byKey(arg->getName()));
@@ -592,9 +592,9 @@ MethodResponseImpl::MethodResponseImpl(Buffer& buf, const SchemaMethod* s) : sch
return;
arguments.reset(new Value(TYPE_MAP));
- int argCount(schema->getArgumentCount());
+ int argCount(schema->getPropertyCount());
for (int idx = 0; idx < argCount; idx++) {
- const SchemaArgument* arg = schema->getArgument(idx);
+ const SchemaProperty* arg = schema->getProperty(idx);
if (arg->getDirection() == DIR_OUT || arg->getDirection() == DIR_IN_OUT) {
Value* value(ValueImpl::factory(arg->getType(), buf));
arguments->insert(arg->getName(), value);
diff --git a/qpid/cpp/src/qmf/engine/ConsoleImpl.h b/qpid/cpp/src/qmf/engine/ConsoleImpl.h
index 5e9783b8a0..d459e128f9 100644
--- a/qpid/cpp/src/qmf/engine/ConsoleImpl.h
+++ b/qpid/cpp/src/qmf/engine/ConsoleImpl.h
@@ -83,8 +83,7 @@ namespace engine {
const SchemaClassKey* getClass(const char* packageName, uint32_t idx) const;
ClassKind getClassKind(const SchemaClassKey* key) const;
- const SchemaObjectClass* getObjectClass(const SchemaClassKey* key) const;
- const SchemaEventClass* getEventClass(const SchemaClassKey* key) const;
+ const SchemaClass* getClass(const SchemaClassKey* key) const;
void bindPackage(const char* packageName);
void bindClass(const SchemaClassKey* key);
@@ -114,17 +113,15 @@ namespace engine {
}
};
- typedef std::map<const SchemaClassKey*, SchemaObjectClass*, KeyCompare> ObjectClassList;
- typedef std::map<const SchemaClassKey*, SchemaEventClass*, KeyCompare> EventClassList;
- typedef std::map<std::string, std::pair<ObjectClassList, EventClassList> > PackageList;
+ typedef std::map<const SchemaClassKey*, SchemaClass*, KeyCompare> ClassList;
+ typedef std::map<std::string, ClassList> PackageList;
PackageList packages;
void learnPackage(const std::string& packageName);
- void learnClass(SchemaObjectClass* cls);
- void learnClass(SchemaEventClass* cls);
+ void learnClass(SchemaClass* cls);
bool haveClass(const SchemaClassKey* key) const;
- SchemaObjectClass* getSchema(const SchemaClassKey* key) const;
+ SchemaClass* getSchema(const SchemaClassKey* key) const;
void eventAgentAdded(boost::shared_ptr<AgentProxy> agent);
void eventAgentDeleted(boost::shared_ptr<AgentProxy> agent);
diff --git a/qpid/cpp/src/qmf/engine/EventImpl.cpp b/qpid/cpp/src/qmf/engine/EventImpl.cpp
index 6bdda9321e..79d5a491fc 100644
--- a/qpid/cpp/src/qmf/engine/EventImpl.cpp
+++ b/qpid/cpp/src/qmf/engine/EventImpl.cpp
@@ -26,12 +26,12 @@ using qpid::framing::Buffer;
EventImpl::EventImpl(const SchemaEventClass* type) : eventClass(type)
{
- int argCount = eventClass->getArgumentCount();
+ int argCount = eventClass->getPropertyCount();
int idx;
for (idx = 0; idx < argCount; idx++) {
- const SchemaArgument* arg = eventClass->getArgument(idx);
- arguments[arg->getName()] = ValuePtr(new Value(arg->getType()));
+ const SchemaProperty* arg = eventClass->getProperty(idx);
+ properties[arg->getName()] = ValuePtr(new Value(arg->getType()));
}
}
@@ -53,8 +53,8 @@ Value* EventImpl::getValue(const char* key) const
{
map<string, ValuePtr>::const_iterator iter;
- iter = arguments.find(key);
- if (iter != arguments.end())
+ iter = properties.find(key);
+ if (iter != properties.end())
return iter->second.get();
return 0;
@@ -65,7 +65,7 @@ void EventImpl::encodeSchemaKey(Buffer& buffer) const
{
buffer.putShortString(eventClass->getClassKey()->getPackageName());
buffer.putShortString(eventClass->getClassKey()->getClassName());
- buffer.putBin128(const_cast<uint8_t*>(eventClass->getClassKey()->getHash()));
+ buffer.putBin128(const_cast<uint8_t*>(eventClass->getClassKey()->getHashData()));
}
@@ -73,10 +73,10 @@ void EventImpl::encode(Buffer& buffer) const
{
buffer.putOctet((uint8_t) eventClass->getSeverity());
- int argCount = eventClass->getArgumentCount();
+ int argCount = eventClass->getPropertyCount();
for (int idx = 0; idx < argCount; idx++) {
- const SchemaArgument* arg = eventClass->getArgument(idx);
- ValuePtr value = arguments[arg->getName()];
+ const SchemaProperty* arg = eventClass->getProperty(idx);
+ ValuePtr value = properties[arg->getName()];
value->impl->encode(buffer);
}
}
diff --git a/qpid/cpp/src/qmf/engine/EventImpl.h b/qpid/cpp/src/qmf/engine/EventImpl.h
index dfdf64e848..ab790f08fa 100644
--- a/qpid/cpp/src/qmf/engine/EventImpl.h
+++ b/qpid/cpp/src/qmf/engine/EventImpl.h
@@ -32,7 +32,7 @@ namespace engine {
struct EventImpl {
typedef boost::shared_ptr<Value> ValuePtr;
const SchemaEventClass* eventClass;
- mutable std::map<std::string, ValuePtr> arguments;
+ mutable std::map<std::string, ValuePtr> properties;
EventImpl(const SchemaEventClass* type);
EventImpl(const SchemaEventClass* type, qpid::framing::Buffer& buffer);
diff --git a/qpid/cpp/src/qmf/engine/ObjectImpl.cpp b/qpid/cpp/src/qmf/engine/ObjectImpl.cpp
index 4256b9119e..353b16ee37 100644
--- a/qpid/cpp/src/qmf/engine/ObjectImpl.cpp
+++ b/qpid/cpp/src/qmf/engine/ObjectImpl.cpp
@@ -31,7 +31,7 @@ ObjectImpl::ObjectImpl() :
}
-ObjectImpl::ObjectImpl(SchemaObjectClass* type) :
+ObjectImpl::ObjectImpl(SchemaClass* type) :
objectClass(type), createTime(uint64_t(Duration(now()))), destroyTime(0), lastUpdatedTime(createTime)
{
}
@@ -54,13 +54,13 @@ void ObjectImpl::destroy()
//==================================================================
Object::Object() : impl(new ObjectImpl()) {}
-Object::Object(SchemaObjectClass* type) : impl(new ObjectImpl(type)) {}
+Object::Object(SchemaClass* type) : impl(new ObjectImpl(type)) {}
Object::Object(const Object& from) : impl(new ObjectImpl(*(from.impl))) {}
Object::~Object() { delete impl; }
const Variant::Map& Object::getValues() const { return impl->getValues(); }
Variant::Map& Object::getValues() { return impl->getValues(); }
-const SchemaObjectClass* Object::getSchema() const { return impl->getSchema(); }
-void Object::setSchema(SchemaObjectClass* schema) { impl->setSchema(schema); }
+const SchemaClass* Object::getSchema() const { return impl->getSchema(); }
+void Object::setSchema(SchemaClass* schema) { impl->setSchema(schema); }
const char* Object::getKey() const { return impl->getKey(); }
void Object::setKey(const char* key) { impl->setKey(key); }
void Object::touch() { impl->touch(); }
diff --git a/qpid/cpp/src/qmf/engine/ObjectImpl.h b/qpid/cpp/src/qmf/engine/ObjectImpl.h
index f1d588271a..8be4ef655f 100644
--- a/qpid/cpp/src/qmf/engine/ObjectImpl.h
+++ b/qpid/cpp/src/qmf/engine/ObjectImpl.h
@@ -31,7 +31,7 @@
namespace qmf {
namespace engine {
- class SchemaObjectClass;
+ class SchemaClass;
typedef boost::shared_ptr<Object> ObjectPtr;
@@ -44,7 +44,7 @@ namespace engine {
/**
* Schema reference if this object is "described"
*/
- SchemaObjectClass* objectClass;
+ SchemaClass* objectClass;
/**
* Address and lifecycle information if this object is "managed"
@@ -56,14 +56,14 @@ namespace engine {
uint64_t lastUpdatedTime;
ObjectImpl();
- ObjectImpl(SchemaObjectClass* type);
+ ObjectImpl(SchemaClass* type);
~ObjectImpl() {}
const qpid::messaging::Variant::Map& getValues() const { return values; }
qpid::messaging::Variant::Map& getValues() { return values; }
- const SchemaObjectClass* getSchema() const { return objectClass; }
- void setSchema(SchemaObjectClass* schema) { objectClass = schema; }
+ const SchemaClass* getSchema() const { return objectClass; }
+ void setSchema(SchemaClass* schema) { objectClass = schema; }
const char* getKey() const { return key.c_str(); }
void setKey(const char* _key) { key = _key; }
diff --git a/qpid/cpp/src/qmf/engine/SchemaImpl.cpp b/qpid/cpp/src/qmf/engine/SchemaImpl.cpp
index dcfc0db8e5..a4f56464a7 100644
--- a/qpid/cpp/src/qmf/engine/SchemaImpl.cpp
+++ b/qpid/cpp/src/qmf/engine/SchemaImpl.cpp
@@ -22,6 +22,7 @@
#include <string.h>
#include <string>
#include <vector>
+#include <assert.h>
using namespace std;
using namespace qmf::engine;
@@ -68,105 +69,29 @@ bool SchemaHash::operator>(const SchemaHash& other) const
}
-SchemaArgumentImpl::SchemaArgumentImpl(const Variant::Map& map)
+SchemaMethodImpl::SchemaMethodImpl(const string& _name, const Variant::Map& map)
{
Variant::Map::const_iterator iter;
-
- 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;
- 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(Variant::Map& map)
-{
- SchemaArgumentImpl* impl(new SchemaArgumentImpl(map));
- return new SchemaArgument(impl);
-}
-
-Variant::Map SchemaArgumentImpl::asMap() const
-{
- Variant::Map map;
-
- map[Protocol::SCHEMA_ELT_NAME] = Variant(name);
- map[Protocol::SCHEMA_ELT_TYPE] = Variant((uint8_t) typecode);
-
- string dirStr;
- if (dir == DIR_IN)
- dirStr = "I";
- else if (dir == DIR_OUT)
- dirStr = "O";
- else
- dirStr = "IO";
- map[Protocol::SCHEMA_ELT_DIR] = Variant(dirStr);
-
- if (!unit.empty())
- map[Protocol::SCHEMA_ELT_UNIT] = Variant(unit);
- if (!description.empty())
- map[Protocol::SCHEMA_ELT_DESC] = Variant(description);
-
- return map;
-}
-
-void SchemaArgumentImpl::updateHash(SchemaHash& hash) const
-{
- hash.update(name);
- hash.update(typecode);
- hash.update(dir);
- hash.update(unit);
- hash.update(description);
-}
-
-SchemaMethodImpl::SchemaMethodImpl(const Variant::Map& map)
-{
- Variant::Map::const_iterator iter;
-
- iter = map.find(Protocol::SCHEMA_ELT_NAME);
- if (iter == map.end())
- throw SchemaException("SchemaMethod", Protocol::SCHEMA_ELT_NAME);
- name = iter->second.asString();
+ name = _name;
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);
+ if (iter != map.end() || iter->second.getType() != VAR_MAP) {
+ Variant::Map argMap(iter->second.asMap());
+ for (Variant::Map::const_iterator aiter = argMap.begin(); aiter != argMap.end(); aiter++) {
+ const string& name(aiter->first);
+ SchemaProperty* arg = SchemaPropertyImpl::factory(name, aiter->second.asMap());
+ addProperty(arg);
}
}
}
-SchemaMethod* SchemaMethodImpl::factory(Variant::Map& map)
+SchemaMethod* SchemaMethodImpl::factory(const string& name, const Variant::Map& map)
{
- SchemaMethodImpl* impl(new SchemaMethodImpl(map));
+ SchemaMethodImpl* impl(new SchemaMethodImpl(name, map));
return new SchemaMethod(impl);
}
@@ -174,29 +99,28 @@ Variant::Map SchemaMethodImpl::asMap() const
{
Variant::Map map;
- map[Protocol::SCHEMA_ELT_NAME] = Variant(name);
if (!description.empty())
map[Protocol::SCHEMA_ELT_DESC] = Variant(description);
Variant::List list;
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++)
+ for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
+ iter != properties.end(); iter++)
list.push_back((*iter)->impl->asMap());
map[Protocol::SCHEMA_ARGS] = list;
return map;
}
-void SchemaMethodImpl::addArgument(const SchemaArgument* argument)
+void SchemaMethodImpl::addProperty(const SchemaProperty* property)
{
- arguments.push_back(argument);
+ properties.push_back(property);
}
-const SchemaArgument* SchemaMethodImpl::getArgument(int idx) const
+const SchemaProperty* SchemaMethodImpl::getProperty(int idx) const
{
int count = 0;
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++, count++)
+ for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
+ iter != properties.end(); iter++, count++)
if (idx == count)
return (*iter);
return 0;
@@ -206,19 +130,15 @@ void SchemaMethodImpl::updateHash(SchemaHash& hash) const
{
hash.update(name);
hash.update(description);
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++)
+ for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
+ iter != properties.end(); iter++)
(*iter)->impl->updateHash(hash);
}
-SchemaPropertyImpl::SchemaPropertyImpl(const Variant::Map& map)
+SchemaPropertyImpl::SchemaPropertyImpl(const string& _name, const Variant::Map& map)
{
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 = _name;
iter = map.find(Protocol::SCHEMA_ELT_TYPE);
if (iter == map.end())
@@ -242,9 +162,9 @@ SchemaPropertyImpl::SchemaPropertyImpl(const Variant::Map& map)
optional = true;
}
-SchemaProperty* SchemaPropertyImpl::factory(Variant::Map& map)
+SchemaProperty* SchemaPropertyImpl::factory(const string& name, const Variant::Map& map)
{
- SchemaPropertyImpl* impl(new SchemaPropertyImpl(map));
+ SchemaPropertyImpl* impl(new SchemaPropertyImpl(name, map));
return new SchemaProperty(impl);
}
@@ -252,7 +172,6 @@ Variant::Map SchemaPropertyImpl::asMap() const
{
Variant::Map map;
- 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)
@@ -272,41 +191,52 @@ void SchemaPropertyImpl::updateHash(SchemaHash& hash) const
hash.update(access);
hash.update(index);
hash.update(optional);
+ hash.update(dir);
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(ClassKind k, const string& p, const string& n) :
+ kind(k), package(p), name(n) {}
-SchemaClassKeyImpl::SchemaClassKeyImpl(const Variant::Map& map) :
- package(packageContainer), name(nameContainer), hash(hashContainer)
+SchemaClassKeyImpl::SchemaClassKeyImpl(const Variant::Map& map)
{
Variant::Map::const_iterator iter;
+ iter = map.find(Protocol::SCHEMA_CLASS_KIND);
+ if (iter == map.end())
+ throw SchemaException("SchemaClassKey", Protocol::SCHEMA_CLASS_KIND);
+ string kindName = iter->second.asString();
+ if (kindName == CLASS_DATA)
+ kind = CLASS_DATA;
+ else if (kindName == CLASS_EVENT)
+ kind = CLASS_EVENT;
+ else
+ throw SchemaException("SchemaClassKey", Protocol::SCHEMA_CLASS_KIND);
+
iter = map.find(Protocol::SCHEMA_PACKAGE);
if (iter == map.end())
throw SchemaException("SchemaClassKey", Protocol::SCHEMA_PACKAGE);
- packageContainer = iter->second.asString();
+ package = iter->second.asString();
iter = map.find(Protocol::SCHEMA_CLASS);
if (iter == map.end())
throw SchemaException("SchemaClassKey", Protocol::SCHEMA_CLASS);
- nameContainer = iter->second.asString();
+ name = 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());
+ hash.set(iter->second.asUuid().data());
}
-SchemaClassKey* SchemaClassKeyImpl::factory(const string& package, const string& name, const SchemaHash& hash)
+SchemaClassKey* SchemaClassKeyImpl::factory(ClassKind k, const string& p, const string& n)
{
- SchemaClassKeyImpl* impl(new SchemaClassKeyImpl(package, name, hash));
+ SchemaClassKeyImpl* impl(new SchemaClassKeyImpl(k, p, n));
return new SchemaClassKey(impl);
}
-SchemaClassKey* SchemaClassKeyImpl::factory(Variant::Map& map)
+SchemaClassKey* SchemaClassKeyImpl::factory(const Variant::Map& map)
{
SchemaClassKeyImpl* impl(new SchemaClassKeyImpl(map));
return new SchemaClassKey(impl);
@@ -316,9 +246,16 @@ Variant::Map SchemaClassKeyImpl::asMap() const
{
Variant::Map map;
+ if (kind == CLASS_DATA)
+ map[Protocol::SCHEMA_CLASS_KIND] = Protocol::SCHEMA_CLASS_KIND_DATA;
+ else if (kind == CLASS_EVENT)
+ map[Protocol::SCHEMA_CLASS_KIND] = Protocol::SCHEMA_CLASS_KIND_EVENT;
+ else
+ assert(0);
+
map[Protocol::SCHEMA_PACKAGE] = Variant(package);
map[Protocol::SCHEMA_CLASS] = Variant(name);
- map[Protocol::SCHEMA_HASH] = Variant(); // TODO: use UUID type when available
+ map[Protocol::SCHEMA_HASH] = Uuid(hash.get());
return map;
}
@@ -348,78 +285,82 @@ const string& SchemaClassKeyImpl::str() const
return repr;
}
-SchemaObjectClassImpl::SchemaObjectClassImpl(const Variant::Map& map) :
- hasHash(true), classKey(SchemaClassKeyImpl::factory(package, name, hash))
+SchemaClassImpl::SchemaClassImpl(const Variant::Map& map) : hasHash(true)
{
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();
- uint16_t statCount = buffer.getShort();
- uint16_t methodCount = buffer.getShort();
-
- for (uint16_t idx = 0; idx < propCount; idx++) {
- const SchemaProperty* property = SchemaPropertyImpl::factory(buffer);
- addProperty(property);
- }
-
- for (uint16_t idx = 0; idx < methodCount; idx++) {
- SchemaMethod* method = SchemaMethodImpl::factory(buffer);
- addMethod(method);
+ iter = map.find(Protocol::SCHEMA_ID);
+ if (iter == map.end() || iter->second.getType() != VAR_MAP)
+ throw SchemaException("SchemaClass", Protocol::SCHEMA_ID);
+ classKey.reset(SchemaClassKeyImpl::factory(iter->second.asMap()));
+
+ iter = map.find(Protocol::VALUES);
+ if (iter == map.end() || iter->second.getType() != VAR_MAP)
+ throw SchemaException("SchemaClass", Protocol::VALUES);
+ Variant::Map valMap(iter->second.asMap());
+
+ iter = map.find(Protocol::SUBTYPES);
+ if (iter == map.end() || iter->second.getType() != VAR_MAP)
+ throw SchemaException("SchemaClass", Protocol::SUBTYPES);
+ Variant::Map subtypeMap(iter->second.asMap());
+
+ for (iter = valMap.begin(); iter != valMap.end(); iter++) {
+ const string& name(iter->first);
+ bool isMethod = false;
+ Variant::Map::const_iterator subtypeIter = subtypeMap.find(name);
+ if (subtypeIter != subtypeMap.end() &&
+ subtypeIter->second.asString() == Protocol::SUBTYPE_SCHEMA_METHOD)
+ isMethod = true;
+
+ if (isMethod)
+ addMethod(SchemaMethodImpl::factory(name, iter->second.asMap()));
+ else
+ addProperty(SchemaPropertyImpl::factory(name, iter->second.asMap()));
}
}
-SchemaObjectClass* SchemaObjectClassImpl::factory(Variant::Map& map)
+SchemaClass* SchemaClassImpl::factory(const Variant::Map& map)
{
- SchemaObjectClassImpl* impl(new SchemaObjectClassImpl(buffer));
- return new SchemaObjectClass(impl);
+ SchemaClassImpl* impl(new SchemaClassImpl(map));
+ return new SchemaClass(impl);
}
-void SchemaObjectClassImpl::encode(Variant::Map& map) const
+Variant::Map SchemaClassImpl::asMap() const
{
- buffer.putOctet((uint8_t) CLASS_OBJECT);
- buffer.putShortString(package);
- buffer.putShortString(name);
- hash.encode(buffer);
- //buffer.putOctet(0); // No parent class
- buffer.putShort((uint16_t) properties.size());
- buffer.putShort((uint16_t) statistics.size());
- buffer.putShort((uint16_t) methods.size());
+ Variant::Map map;
+ Variant::Map values;
+ Variant::Map subtypes;
+
+ map[Protocol::SCHEMA_ID] = classKey->impl->asMap();
for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
- iter != properties.end(); iter++)
- (*iter)->impl->encode(buffer);
- for (vector<const SchemaStatistic*>::const_iterator iter = statistics.begin();
- iter != statistics.end(); iter++)
- (*iter)->impl->encode(buffer);
+ iter != properties.end(); iter++) {
+ values[(*iter)->getName()] = (*iter)->impl->asMap();
+ subtypes[(*iter)->getName()] = Protocol::SUBTYPE_SCHEMA_PROPERTY;
+ }
+
for (vector<const SchemaMethod*>::const_iterator iter = methods.begin();
- iter != methods.end(); iter++)
- (*iter)->impl->encode(buffer);
+ iter != methods.end(); iter++) {
+ values[(*iter)->getName()] = (*iter)->impl->asMap();
+ subtypes[(*iter)->getName()] = Protocol::SUBTYPE_SCHEMA_METHOD;
+ }
+
+ map[Protocol::VALUES] = values;
+ map[Protocol::SUBTYPES] = subtypes;
+
+ return map;
}
-const SchemaClassKey* SchemaObjectClassImpl::getClassKey() const
+const SchemaClassKey* SchemaClassImpl::getClassKey() const
{
if (!hasHash) {
hasHash = true;
- hash.update(package);
- hash.update(name);
+ SchemaHash& hash(classKey->impl->getHash());
+ hash.update(classKey->getPackageName());
+ hash.update(classKey->getClassName());
for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
iter != properties.end(); iter++)
(*iter)->impl->updateHash(hash);
- for (vector<const SchemaStatistic*>::const_iterator iter = statistics.begin();
- iter != statistics.end(); iter++)
- (*iter)->impl->updateHash(hash);
for (vector<const SchemaMethod*>::const_iterator iter = methods.begin();
iter != methods.end(); iter++)
(*iter)->impl->updateHash(hash);
@@ -428,22 +369,17 @@ const SchemaClassKey* SchemaObjectClassImpl::getClassKey() const
return classKey.get();
}
-void SchemaObjectClassImpl::addProperty(const SchemaProperty* property)
+void SchemaClassImpl::addProperty(const SchemaProperty* property)
{
properties.push_back(property);
}
-void SchemaObjectClassImpl::addStatistic(const SchemaStatistic* statistic)
-{
- statistics.push_back(statistic);
-}
-
-void SchemaObjectClassImpl::addMethod(const SchemaMethod* method)
+void SchemaClassImpl::addMethod(const SchemaMethod* method)
{
methods.push_back(method);
}
-const SchemaProperty* SchemaObjectClassImpl::getProperty(int idx) const
+const SchemaProperty* SchemaClassImpl::getProperty(int idx) const
{
int count = 0;
for (vector<const SchemaProperty*>::const_iterator iter = properties.begin();
@@ -453,17 +389,7 @@ const SchemaProperty* SchemaObjectClassImpl::getProperty(int idx) const
return 0;
}
-const SchemaStatistic* SchemaObjectClassImpl::getStatistic(int idx) const
-{
- int count = 0;
- for (vector<const SchemaStatistic*>::const_iterator iter = statistics.begin();
- iter != statistics.end(); iter++, count++)
- if (idx == count)
- return *iter;
- return 0;
-}
-
-const SchemaMethod* SchemaObjectClassImpl::getMethod(int idx) const
+const SchemaMethod* SchemaClassImpl::getMethod(int idx) const
{
int count = 0;
for (vector<const SchemaMethod*>::const_iterator iter = methods.begin();
@@ -473,96 +399,21 @@ const SchemaMethod* SchemaObjectClassImpl::getMethod(int idx) const
return 0;
}
-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();
-
- for (uint16_t idx = 0; idx < argCount; idx++) {
- SchemaArgument* argument = SchemaArgumentImpl::factory(buffer);
- addArgument(argument);
- }
-}
-
-SchemaEventClass* SchemaEventClassImpl::factory(Variant::Map& map)
-{
- SchemaEventClassImpl* impl(new SchemaEventClassImpl(buffer));
- return new SchemaEventClass(impl);
-}
-
-void SchemaEventClassImpl::encode(Variant::Map& map) const
-{
- buffer.putOctet((uint8_t) CLASS_EVENT);
- buffer.putShortString(package);
- buffer.putShortString(name);
- hash.encode(buffer);
- buffer.putShort((uint16_t) arguments.size());
-
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++)
- (*iter)->impl->encode(buffer);
-}
-
-const SchemaClassKey* SchemaEventClassImpl::getClassKey() const
-{
- if (!hasHash) {
- hasHash = true;
- hash.update(package);
- hash.update(name);
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++)
- (*iter)->impl->updateHash(hash);
- }
- return classKey.get();
-}
-
-void SchemaEventClassImpl::addArgument(const SchemaArgument* argument)
-{
- arguments.push_back(argument);
-}
-
-const SchemaArgument* SchemaEventClassImpl::getArgument(int idx) const
-{
- int count = 0;
- for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
- iter != arguments.end(); iter++, count++)
- if (idx == count)
- return (*iter);
- return 0;
-}
-
//==================================================================
// Wrappers
//==================================================================
-SchemaArgument::SchemaArgument(const char* name, Typecode typecode) { impl = new SchemaArgumentImpl(name, typecode); }
-SchemaArgument::SchemaArgument(SchemaArgumentImpl* i) : impl(i) {}
-SchemaArgument::SchemaArgument(const SchemaArgument& from) : impl(new SchemaArgumentImpl(*(from.impl))) {}
-SchemaArgument::~SchemaArgument() { delete impl; }
-void SchemaArgument::setDirection(Direction dir) { impl->setDirection(dir); }
-void SchemaArgument::setUnit(const char* val) { impl->setUnit(val); }
-void SchemaArgument::setDesc(const char* desc) { impl->setDesc(desc); }
-const char* SchemaArgument::getName() const { return impl->getName().c_str(); }
-Typecode SchemaArgument::getType() const { return impl->getType(); }
-Direction SchemaArgument::getDirection() const { return impl->getDirection(); }
-const char* SchemaArgument::getUnit() const { return impl->getUnit().c_str(); }
-const char* SchemaArgument::getDesc() const { return impl->getDesc().c_str(); }
-
SchemaMethod::SchemaMethod(const char* name) : impl(new SchemaMethodImpl(name)) {}
SchemaMethod::SchemaMethod(SchemaMethodImpl* i) : impl(i) {}
SchemaMethod::SchemaMethod(const SchemaMethod& from) : impl(new SchemaMethodImpl(*(from.impl))) {}
SchemaMethod::~SchemaMethod() { delete impl; }
-void SchemaMethod::addArgument(const SchemaArgument* argument) { impl->addArgument(argument); }
+void SchemaMethod::addProperty(const SchemaProperty* property) { impl->addProperty(property); }
void SchemaMethod::setDesc(const char* desc) { impl->setDesc(desc); }
const char* SchemaMethod::getName() const { return impl->getName().c_str(); }
const char* SchemaMethod::getDesc() const { return impl->getDesc().c_str(); }
-int SchemaMethod::getArgumentCount() const { return impl->getArgumentCount(); }
-const SchemaArgument* SchemaMethod::getArgument(int idx) const { return impl->getArgument(idx); }
+int SchemaMethod::getPropertyCount() const { return impl->getPropertyCount(); }
+const SchemaProperty* SchemaMethod::getProperty(int idx) const { return impl->getProperty(idx); }
SchemaProperty::SchemaProperty(const char* name, Typecode typecode) : impl(new SchemaPropertyImpl(name, typecode)) {}
SchemaProperty::SchemaProperty(SchemaPropertyImpl* i) : impl(i) {}
@@ -571,6 +422,7 @@ SchemaProperty::~SchemaProperty() { delete impl; }
void SchemaProperty::setAccess(Access access) { impl->setAccess(access); }
void SchemaProperty::setIndex(bool val) { impl->setIndex(val); }
void SchemaProperty::setOptional(bool val) { impl->setOptional(val); }
+void SchemaProperty::setDirection(Direction dir) { impl->setDirection(dir); }
void SchemaProperty::setUnit(const char* val) { impl->setUnit(val); }
void SchemaProperty::setDesc(const char* desc) { impl->setDesc(desc); }
const char* SchemaProperty::getName() const { return impl->getName().c_str(); }
@@ -578,38 +430,30 @@ Typecode SchemaProperty::getType() const { return impl->getType(); }
Access SchemaProperty::getAccess() const { return impl->getAccess(); }
bool SchemaProperty::isIndex() const { return impl->isIndex(); }
bool SchemaProperty::isOptional() const { return impl->isOptional(); }
+Direction SchemaProperty::getDirection() const { return impl->getDirection(); }
const char* SchemaProperty::getUnit() const { return impl->getUnit().c_str(); }
const char* SchemaProperty::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; }
+ClassKind SchemaClassKey::getKind() const { return impl->getKind(); }
const char* SchemaClassKey::getPackageName() const { return impl->getPackageName().c_str(); }
const char* SchemaClassKey::getClassName() const { return impl->getClassName().c_str(); }
-const uint8_t* SchemaClassKey::getHash() const { return impl->getHash(); }
+const uint8_t* SchemaClassKey::getHashData() const { return impl->getHashData(); }
const char* SchemaClassKey::asString() const { return impl->str().c_str(); }
bool SchemaClassKey::operator==(const SchemaClassKey& other) const { return *impl == *(other.impl); }
bool SchemaClassKey::operator<(const SchemaClassKey& other) const { return *impl < *(other.impl); }
-SchemaObjectClass::SchemaObjectClass(const char* package, const char* name) : impl(new SchemaObjectClassImpl(package, name)) {}
-SchemaObjectClass::SchemaObjectClass(SchemaObjectClassImpl* i) : impl(i) {}
-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::addMethod(const SchemaMethod* method) { impl->addMethod(method); }
-const SchemaClassKey* SchemaObjectClass::getClassKey() const { return impl->getClassKey(); }
-int SchemaObjectClass::getPropertyCount() const { return impl->getPropertyCount(); }
-int SchemaObjectClass::getMethodCount() const { return impl->getMethodCount(); }
-const SchemaProperty* SchemaObjectClass::getProperty(int idx) const { return impl->getProperty(idx); }
-const SchemaMethod* SchemaObjectClass::getMethod(int idx) const { return impl->getMethod(idx); }
-
-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(); }
-int SchemaEventClass::getArgumentCount() const { return impl->getArgumentCount(); }
-const SchemaArgument* SchemaEventClass::getArgument(int idx) const { return impl->getArgument(idx); }
+SchemaClass::SchemaClass(ClassKind kind, const char* package, const char* name) : impl(new SchemaClassImpl(kind, package, name)) {}
+SchemaClass::SchemaClass(SchemaClassImpl* i) : impl(i) {}
+SchemaClass::SchemaClass(const SchemaClass& from) : impl(new SchemaClassImpl(*(from.impl))) {}
+SchemaClass::~SchemaClass() { delete impl; }
+void SchemaClass::addProperty(const SchemaProperty* property) { impl->addProperty(property); }
+void SchemaClass::addMethod(const SchemaMethod* method) { impl->addMethod(method); }
+const SchemaClassKey* SchemaClass::getClassKey() const { return impl->getClassKey(); }
+int SchemaClass::getPropertyCount() const { return impl->getPropertyCount(); }
+int SchemaClass::getMethodCount() const { return impl->getMethodCount(); }
+const SchemaProperty* SchemaClass::getProperty(int idx) const { return impl->getProperty(idx); }
+const SchemaMethod* SchemaClass::getMethod(int idx) const { return impl->getMethod(idx); }
diff --git a/qpid/cpp/src/qmf/engine/SchemaImpl.h b/qpid/cpp/src/qmf/engine/SchemaImpl.h
index a26bc07f6d..d78c921c67 100644
--- a/qpid/cpp/src/qmf/engine/SchemaImpl.h
+++ b/qpid/cpp/src/qmf/engine/SchemaImpl.h
@@ -65,22 +65,32 @@ namespace engine {
bool operator>(const SchemaHash& other) const;
};
- struct SchemaArgumentImpl {
+ struct SchemaPropertyImpl {
std::string name;
Typecode typecode;
+ Access access;
+ bool index;
+ bool optional;
Direction dir;
std::string unit;
std::string description;
- SchemaArgumentImpl(const char* n, Typecode t) : name(n), typecode(t), dir(DIR_IN) {}
- SchemaArgumentImpl(const qpid::messaging::Variant::Map& map);
- static SchemaArgument* factory(qpid::messaging::Variant::Map& map);
+ SchemaPropertyImpl(const char* n, Typecode t) :
+ name(n), typecode(t), access(ACCESS_READ_ONLY), index(false), optional(false), dir(DIR_IN) {}
+ SchemaPropertyImpl(const std::string& name, const qpid::messaging::Variant::Map& map);
+ static SchemaProperty* factory(const std::string& name, const 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; }
void setDirection(Direction d) { dir = d; }
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; }
+ Access getAccess() const { return access; }
+ bool isIndex() const { return index; }
+ bool isOptional() const { return optional; }
Direction getDirection() const { return dir; }
const std::string& getUnit() const { return unit; }
const std::string& getDesc() const { return description; }
@@ -90,69 +100,38 @@ namespace engine {
struct SchemaMethodImpl {
std::string name;
std::string description;
- std::vector<const SchemaArgument*> arguments;
+ std::vector<const SchemaProperty*> properties;
SchemaMethodImpl(const char* n) : name(n) {}
- SchemaMethodImpl(const qpid::messaging::Variant::Map& map);
- static SchemaMethod* factory(qpid::messaging::Variant::Map& map);
+ SchemaMethodImpl(const std::string& name, const qpid::messaging::Variant::Map& map);
+ static SchemaMethod* factory(const std::string& name, const 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; }
- const std::string& getDesc() const { return description; }
- int getArgumentCount() const { return arguments.size(); }
- const SchemaArgument* getArgument(int idx) const;
- void updateHash(SchemaHash& hash) const;
- };
-
- struct SchemaPropertyImpl {
- std::string name;
- Typecode typecode;
- Access access;
- bool index;
- bool optional;
- std::string unit;
- std::string description;
-
- SchemaPropertyImpl(const char* n, Typecode t) : name(n), typecode(t), access(ACCESS_READ_ONLY), index(false), optional(false) {}
- 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; }
- void setUnit(const char* val) { unit = val; }
+ void addProperty(const SchemaProperty* property);
void setDesc(const char* desc) { description = desc; }
const std::string& getName() const { return name; }
- Typecode getType() const { return typecode; }
- Access getAccess() const { return access; }
- bool isIndex() const { return index; }
- bool isOptional() const { return optional; }
- const std::string& getUnit() const { return unit; }
const std::string& getDesc() const { return description; }
+ int getPropertyCount() const { return properties.size(); }
+ const SchemaProperty* getProperty(int idx) const;
void updateHash(SchemaHash& hash) const;
};
struct SchemaClassKeyImpl {
- const std::string& package;
- const std::string& name;
- const SchemaHash& hash;
+ ClassKind kind;
+ std::string package;
+ std::string name;
+ SchemaHash hash;
mutable std::string repr;
- // The *Container elements are only used if there isn't an external place to
- // store these values.
- std::string packageContainer;
- std::string nameContainer;
- SchemaHash hashContainer;
-
- SchemaClassKeyImpl(const std::string& package, const std::string& name, const SchemaHash& hash);
+ SchemaClassKeyImpl(ClassKind kind, const std::string& package, const std::string& name);
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::messaging::Variant::Map& map);
+ static SchemaClassKey* factory(ClassKind kind, const std::string& package, const std::string& name);
+ static SchemaClassKey* factory(const qpid::messaging::Variant::Map& map);
+ ClassKind getKind() const { return kind; }
const std::string& getPackageName() const { return package; }
const std::string& getClassName() const { return name; }
- const uint8_t* getHash() const { return hash.get(); }
+ const uint8_t* getHashData() const { return hash.get(); }
+ SchemaHash& getHash() { return hash; }
qpid::messaging::Variant::Map asMap() const;
bool operator==(const SchemaClassKeyImpl& other) const;
@@ -160,19 +139,16 @@ namespace engine {
const std::string& str() const;
};
- struct SchemaObjectClassImpl {
- std::string package;
- std::string name;
- mutable SchemaHash hash;
+ struct SchemaClassImpl {
mutable bool hasHash;
std::auto_ptr<SchemaClassKey> classKey;
std::vector<const SchemaProperty*> properties;
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(const qpid::messaging::Variant::Map& map);
- static SchemaObjectClass* factory(qpid::messaging::Variant::Map& map);
+ SchemaClassImpl(ClassKind kind, const char* package, const char* name) :
+ hasHash(false), classKey(SchemaClassKeyImpl::factory(kind, package, name)) {}
+ SchemaClassImpl(const qpid::messaging::Variant::Map& map);
+ static SchemaClass* factory(const qpid::messaging::Variant::Map& map);
qpid::messaging::Variant::Map asMap() const;
void addProperty(const SchemaProperty* property);
@@ -184,29 +160,6 @@ namespace engine {
const SchemaProperty* getProperty(int idx) const;
const SchemaMethod* getMethod(int idx) const;
};
-
- struct SchemaEventClassImpl {
- std::string package;
- std::string name;
- mutable SchemaHash hash;
- mutable bool hasHash;
- std::auto_ptr<SchemaClassKey> classKey;
- std::string description;
- std::vector<const SchemaArgument*> arguments;
-
- 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);
-
- qpid::messaging::Variant::Map asMap() const;
- void addArgument(const SchemaArgument* argument);
- void setDesc(const char* desc) { description = desc; }
-
- const SchemaClassKey* getClassKey() const;
- int getArgumentCount() const { return arguments.size(); }
- const SchemaArgument* getArgument(int idx) const;
- };
}
}
View Lorry Controller Status