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.



git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/qmf-devel0.7@912022 13f79535-47bb-0310-9956-ffa450edef68

10 files changed, 212 insertions, 440 deletions

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;
-    };
 }
 }