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

17 files changed, 257 insertions, 537 deletions

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