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 23:52:43 UTC
svn commit: r912022 - in /qpid/branches/qmf-devel0.7/qpid/cpp: bindings/qmf/
include/qmf/ include/qmf/engine/ src/qmf/ src/qmf/engine/
Author: tross
Date: Fri Feb 19 22:52:43 2010
New Revision: 912022
URL: http://svn.apache.org/viewvc?rev=912022&view=rev
Log:
The tree now builds up to the point of running swig.
Changes:
1) Cleaned up the Schema definitions to match the wiki documentation for QMFv2
a) Combined "argument" into "property" and eliminated "argument"
b) Removed the distinction between ObjectClass and EventClass
Event classes are now represented as Object classes without methods
2) Removed old buffer-codec encode/decode for schema types and replaced them with
map-based equivalents.
Modified:
qpid/branches/qmf-devel0.7/qpid/cpp/bindings/qmf/qmfengine.i
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/Protocol.h
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Agent.h
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Console.h
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Event.h
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Object.h
qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Schema.h
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/Protocol.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/Agent.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ConsoleImpl.h
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.h
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.h
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.cpp
qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/SchemaImpl.h
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/bindings/qmf/qmfengine.i
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/bindings/qmf/qmfengine.i?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/bindings/qmf/qmfengine.i (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/bindings/qmf/qmfengine.i Fri Feb 19 22:52:43 2010
@@ -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>
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/Protocol.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/Protocol.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/Protocol.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/Protocol.h Fri Feb 19 22:52:43 2010
@@ -36,7 +36,6 @@
//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 @@
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';
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Agent.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Agent.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Agent.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Agent.h Fri Feb 19 22:52:43 2010
@@ -55,7 +55,7 @@
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 @@
/**
* 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
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Console.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Console.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Console.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Console.h Fri Feb 19 22:52:43 2010
@@ -204,8 +204,7 @@
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);
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Event.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Event.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Event.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Event.h Fri Feb 19 22:52:43 2010
@@ -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:
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Object.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Object.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Object.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Object.h Fri Feb 19 22:52:43 2010
@@ -31,15 +31,15 @@
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);
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Schema.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Schema.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Schema.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/include/qmf/engine/Schema.h Fri Feb 19 22:52:43 2010
@@ -28,37 +28,41 @@
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 @@
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 @@
/**
*/
- 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 @@
private:
friend struct SchemaClassKeyImpl;
+ friend struct SchemaClassImpl;
friend class BrokerProxyImpl;
friend class ConsoleImpl;
SchemaClassKey(SchemaClassKeyImpl* impl);
@@ -135,14 +114,15 @@
/**
*/
- 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 @@
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;
};
}
}
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/Protocol.cpp
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/Protocol.cpp?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/Protocol.cpp (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/Protocol.cpp Fri Feb 19 22:52:43 2010
@@ -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::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*/)
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/Agent.cpp
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/Agent.cpp?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/Agent.cpp (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/Agent.cpp Fri Feb 19 22:52:43 2010
@@ -58,7 +58,7 @@
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 @@
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 @@
}
};
- 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 @@
//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::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 @@
event->name = method;
event->objectKey = key;
event->arguments = argMap;
- event->objectClass = objectClass;
+ event->objectClass = cls;
return event;
}
@@ -505,8 +480,7 @@
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); }
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/BrokerProxyImpl.cpp Fri Feb 19 22:52:43 2010
@@ -246,13 +246,13 @@
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 @@
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);
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ConsoleImpl.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ConsoleImpl.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ConsoleImpl.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ConsoleImpl.h Fri Feb 19 22:52:43 2010
@@ -83,8 +83,7 @@
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 @@
}
};
- 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);
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.cpp?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.cpp (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.cpp Fri Feb 19 22:52:43 2010
@@ -26,12 +26,12 @@
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 @@
{
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 @@
{
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 @@
{
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);
}
}
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/EventImpl.h Fri Feb 19 22:52:43 2010
@@ -32,7 +32,7 @@
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);
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.cpp?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.cpp (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.cpp Fri Feb 19 22:52:43 2010
@@ -31,7 +31,7 @@
}
-ObjectImpl::ObjectImpl(SchemaObjectClass* type) :
+ObjectImpl::ObjectImpl(SchemaClass* type) :
objectClass(type), createTime(uint64_t(Duration(now()))), destroyTime(0), lastUpdatedTime(createTime)
{
}
@@ -54,13 +54,13 @@
//==================================================================
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(); }
Modified: qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.h
URL: http://svn.apache.org/viewvc/qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.h?rev=912022&r1=912021&r2=912022&view=diff
==============================================================================
--- qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.h (original)
+++ qpid/branches/qmf-devel0.7/qpid/cpp/src/qmf/engine/ObjectImpl.h Fri Feb 19 22:52:43 2010
@@ -31,7 +31,7 @@
namespace qmf {
namespace engine {
- class SchemaObjectClass;
+ class SchemaClass;
typedef boost::shared_ptr<Object> ObjectPtr;
@@ -44,7 +44,7 @@
/**
* Schema reference if this object is "described"
*/
- SchemaObjectClass* objectClass;
+ SchemaClass* objectClass;
/**
* Address and lifecycle information if this object is "managed"
@@ -56,14 +56,14 @@
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; }
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=912022&r1=912021&r2=912022&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 22:52:43 2010
@@ -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 @@
}
-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 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 @@
{
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 @@
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 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 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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); }
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=912022&r1=912021&r2=912022&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 22:52:43 2010
@@ -65,22 +65,32 @@
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 @@
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 @@
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 @@
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;
- };
}
}
---------------------------------------------------------------------
Apache Qpid - AMQP Messaging Implementation
Project: http://qpid.apache.org
Use/Interact: mailto:commits-subscribe@qpid.apache.org