You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by tr...@apache.org on 2009/09/02 14:32:56 UTC

svn commit: r810482 - in /qpid/trunk/qpid/cpp: bindings/qmf/ruby/qmf.rb bindings/qmf/tests/ruby_console.rb src/qmf/ConsoleEngine.cpp src/qmf/ConsoleEngine.h src/qmf/ResilientConnection.cpp src/qmf/SchemaImpl.cpp src/qmf/SchemaImpl.h

Author: tross
Date: Wed Sep  2 12:32:56 2009
New Revision: 810482

URL: http://svn.apache.org/viewvc?rev=810482&view=rev
Log:
More QMF implementation:
  - Added schema handling and exchange to the console
  - Improved the connection performance by switching to pre-acquired mode

Modified:
    qpid/trunk/qpid/cpp/bindings/qmf/ruby/qmf.rb
    qpid/trunk/qpid/cpp/bindings/qmf/tests/ruby_console.rb
    qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.cpp
    qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.h
    qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp
    qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h

Modified: qpid/trunk/qpid/cpp/bindings/qmf/ruby/qmf.rb
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/bindings/qmf/ruby/qmf.rb?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/bindings/qmf/ruby/qmf.rb (original)
+++ qpid/trunk/qpid/cpp/bindings/qmf/ruby/qmf.rb Wed Sep  2 12:32:56 2009
@@ -26,7 +26,7 @@
 
   # Pull all the TYPE_* constants into Qmf namespace.  Maybe there's an easier way?
   Qmfengine.constants.each do |c|
-    if c.index('TYPE_') == 0 or c.index('ACCESS_') == 0 or c.index('DIR_') == 0
+    if c.index('TYPE_') == 0 or c.index('ACCESS_') == 0 or c.index('DIR_') == 0 or c.index('CLASS_') == 0
       const_set(c, Qmfengine.const_get(c))
     end
   end
@@ -81,8 +81,8 @@
       @impl = Qmfengine::ResilientConnection.new(settings.impl)
       @sockEngine, @sock = Socket::socketpair(Socket::PF_UNIX, Socket::SOCK_STREAM, 0)
       @impl.setNotifyFd(@sockEngine.fileno)
-      @new_conn_handlers = Array.new
-      @conn_handlers = Array.new
+      @new_conn_handlers = []
+      @conn_handlers = []
 
       @thread = Thread.new do
         run
@@ -91,7 +91,7 @@
 
     def add_conn_handler(handler)
       synchronize do
-        @new_conn_handlers.push(handler)
+        @new_conn_handlers << handler
       end
       @sockEngine.write("x")
     end
@@ -107,11 +107,11 @@
 
         synchronize do
           new_handlers = @new_conn_handlers
-          @new_conn_handlers = Array.new
+          @new_conn_handlers = []
         end
 
         new_handlers.each do |nh|
-          @conn_handlers.push(nh)
+          @conn_handlers << nh
           nh.conn_event_connected() if connected
         end
         new_handlers = nil
@@ -466,11 +466,15 @@
 
   class SchemaObjectClass
     attr_reader :impl
-    def initialize(package, name, kwargs={})
-      @impl = Qmfengine::SchemaObjectClass.new(package, name)
+    def initialize(package='', name='', kwargs={})
       @properties = []
       @statistics = []
       @methods = []
+      if kwargs.include?(:impl)
+        @impl = kwargs[:impl]
+      else
+        @impl = Qmfengine::SchemaObjectClass.new(package, name)
+      end
     end
 
     def add_property(prop)
@@ -489,7 +493,7 @@
     end
 
     def name
-      @impl.getName
+      @impl.getClassKey.getClassName
     end
 
     def properties
@@ -505,16 +509,24 @@
 
   class SchemaEventClass
     attr_reader :impl
-    def initialize(package, name, kwargs={})
-      @impl = Qmfengine::SchemaEventClass.new(package, name)
-      @impl.setDesc(kwargs[:desc]) if kwargs.include?(:desc)
+    def initialize(package='', name='', kwargs={})
       @arguments = []
+      if kwargs.include?(:impl)
+        @impl = kwargs[:impl]
+      else
+        @impl = Qmfengine::SchemaEventClass.new(package, name)
+        @impl.setDesc(kwargs[:desc]) if kwargs.include?(:desc)
+      end
     end
 
     def add_argument(arg)
       @arguments << arg
       @impl.addArgument(arg.impl)
     end
+
+    def name
+      @impl.getClassKey.getClassName
+    end
   end
 
   ##==============================================================================
@@ -540,12 +552,12 @@
       @handler = handler
       @impl = Qmfengine::ConsoleEngine.new
       @event = Qmfengine::ConsoleEvent.new
-      @broker_list = Array.new
+      @broker_list = []
     end
 
     def add_connection(conn)
       broker = Broker.new(self, conn)
-      @broker_list.push(broker)
+      @broker_list << broker
       return broker
     end
 
@@ -553,9 +565,30 @@
     end
 
     def get_packages()
-    end
+      plist = []
+      count = @impl.packageCount
+      for i in 0...count
+        plist << @impl.getPackageName(i)
+      end
+      return plist
+    end
+
+    def get_classes(package, kind=CLASS_OBJECT)
+      clist = []
+      count = @impl.classCount(package)
+      for i in 0...count
+        key = @impl.getClass(package, i)
+        class_kind = @impl.getClassKind(key)
+        if class_kind == kind
+          if kind == CLASS_OBJECT
+            clist << SchemaObjectClass.new('', '', :impl => @impl.getObjectClass(key))
+          elsif kind == CLASS_EVENT
+            clist << SchemaEventClass.new('', '', :impl => @impl.getEventClass(key))
+          end
+        end
+      end
 
-    def get_classes(package)
+      return clist
     end
 
     def get_schema(class_key)
@@ -606,12 +639,16 @@
   end
 
   class Broker < ConnectionHandler
+    include MonitorMixin
     attr_reader :impl
 
     def initialize(console, conn)
+      super()
       @console = console
       @conn = conn
       @session = nil
+      @cv = new_cond
+      @stable = nil
       @event = Qmfengine::BrokerEvent.new
       @xmtMessage = Qmfengine::Message.new
       @impl = Qmfengine::BrokerProxy.new(@console.impl)
@@ -619,6 +656,21 @@
       @conn.add_conn_handler(self)
     end
 
+    def waitForStable(timeout = nil)
+      synchronize do
+        return if @stable
+        if timeout
+          unless @cv.wait(timeout) { @stable }
+            raise "Timed out waiting for broker connection to become stable"
+          end
+        else
+          while not @stable
+            @cv.wait
+          end
+        end
+      end
+    end
+
     def do_broker_events()
       count = 0
       valid = @impl.getEvent(@event)
@@ -637,6 +689,11 @@
           @conn.impl.unbind(@session.handle, @event.exchange, @event.name, @event.bindingKey)
         when Qmfengine::BrokerEvent::SETUP_COMPLETE
           @impl.startProtocol
+        when Qmfengine::BrokerEvent::STABLE
+          synchronize do
+            @stable = :true
+            @cv.signal
+          end
         end
         @impl.popEvent
         valid = @impl.getEvent(@event)

Modified: qpid/trunk/qpid/cpp/bindings/qmf/tests/ruby_console.rb
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/bindings/qmf/tests/ruby_console.rb?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/bindings/qmf/tests/ruby_console.rb (original)
+++ qpid/trunk/qpid/cpp/bindings/qmf/tests/ruby_console.rb Wed Sep  2 12:32:56 2009
@@ -31,7 +31,25 @@
     @connection = Qmf::Connection.new(@settings)
     @qmf = Qmf::Console.new
 
-    @qmf.add_connection(@connection)
+    @broker = @qmf.add_connection(@connection)
+    @broker.waitForStable
+
+    packages = @qmf.get_packages
+    puts "----- Packages -----"
+    packages.each do |p|
+      puts p
+      puts "    ----- Object Classes -----"
+      classes = @qmf.get_classes(p)
+      classes.each do |c|
+        puts "    #{c.name}"
+      end
+      puts "    ----- Event Classes -----"
+      classes = @qmf.get_classes(p, Qmf::CLASS_EVENT)
+      classes.each do |c|
+        puts "    #{c.name}"
+      end
+    end
+    puts "-----"
 
     sleep
   end

Modified: qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.cpp?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.cpp (original)
+++ qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.cpp Wed Sep  2 12:32:56 2009
@@ -137,6 +137,7 @@
         BrokerEventImpl::Ptr eventDeclareQueue(const string& queueName);
         BrokerEventImpl::Ptr eventBind(const string& exchange, const string& queue, const string& key);
         BrokerEventImpl::Ptr eventSetupComplete();
+        BrokerEventImpl::Ptr eventStable();
 
         void handleBrokerResponse(Buffer& inBuffer, uint32_t seq);
         void handlePackageIndication(Buffer& inBuffer, uint32_t seq);
@@ -147,7 +148,7 @@
         void handleEventIndication(Buffer& inBuffer, uint32_t seq);
         void handleSchemaResponse(Buffer& inBuffer, uint32_t seq);
         void handleObjectIndication(Buffer& inBuffer, uint32_t seq, bool prop, bool stat);
-        void incOutstanding();
+        void incOutstandingLH();
         void decOutstanding();
     };
 
@@ -178,12 +179,12 @@
         uint32_t classCount(const char* packageName) const;
         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;
+        ClassKind getClassKind(const SchemaClassKey* key) const;
+        const SchemaObjectClass* getObjectClass(const SchemaClassKey* key) const;
+        const SchemaEventClass* getEventClass(const SchemaClassKey* key) const;
 
         void bindPackage(const char* packageName);
-        void bindClass(const SchemaClassKey& key);
+        void bindClass(const SchemaClassKey* key);
         void bindClass(const char* packageName, const char* className);
 
         uint32_t agentCount() const;
@@ -203,8 +204,28 @@
         const ConsoleSettings& settings;
         mutable Mutex lock;
         deque<ConsoleEventImpl::Ptr> eventQueue;
-        vector<BrokerProxyImpl::Ptr> brokerList;
+        vector<BrokerProxyImpl*> brokerList;
         vector<pair<string, string> > bindingList; // exchange/key (empty exchange => QMF_EXCHANGE)
+
+        // Declare a compare class for the class maps that compares the dereferenced
+        // class key pointers.  The default behavior would be to compare the pointer
+        // addresses themselves.
+        struct KeyCompare {
+            bool operator()(const SchemaClassKeyImpl* left, const SchemaClassKeyImpl* right) const {
+                return *left < *right;
+            }
+        };
+
+        typedef map<const SchemaClassKeyImpl*, SchemaObjectClassImpl::Ptr, KeyCompare> ObjectClassList;
+        typedef map<const SchemaClassKeyImpl*, SchemaEventClassImpl::Ptr, KeyCompare> EventClassList;
+        typedef map<string, pair<ObjectClassList, EventClassList> > PackageList;
+
+        PackageList packages;
+
+        void learnPackage(const string& packageName);
+        void learnClass(SchemaObjectClassImpl::Ptr cls);
+        void learnClass(SchemaEventClassImpl::Ptr cls);
+        bool haveClass(const SchemaClassKeyImpl& key) const;
     };
 }
 
@@ -393,6 +414,12 @@
     return event;
 }
 
+BrokerEventImpl::Ptr BrokerProxyImpl::eventStable()
+{
+    BrokerEventImpl::Ptr event(new BrokerEventImpl(BrokerEvent::STABLE));
+    return event;
+}
+
 void BrokerProxyImpl::handleBrokerResponse(Buffer& inBuffer, uint32_t seq)
 {
     // Note that this function doesn't touch requestsOutstanding.  This is because
@@ -415,6 +442,16 @@
 
     inBuffer.getShortString(package);
     QPID_LOG(trace, "RCVD PackageIndication seq=" << seq << " package=" << package);
+    console->learnPackage(package);
+
+    Mutex::ScopedLock _lock(lock);
+    Buffer outBuffer(outputBuffer, MA_BUFFER_SIZE);
+    uint32_t sequence(seqMgr.reserve(this));
+    incOutstandingLH();
+    Protocol::encodeHeader(outBuffer, Protocol::OP_CLASS_QUERY, sequence);
+    outBuffer.putShortString(package);
+    sendBufferLH(outBuffer, QMF_EXCHANGE, BROKER_KEY);
+    QPID_LOG(trace, "SENT ClassQuery seq=" << sequence << " package=" << package);
 }
 
 void BrokerProxyImpl::handleCommandComplete(Buffer& inBuffer, uint32_t seq)
@@ -426,9 +463,30 @@
     seqMgr.release(seq);
 }
 
-void BrokerProxyImpl::handleClassIndication(Buffer& /*inBuffer*/, uint32_t /*seq*/)
+void BrokerProxyImpl::handleClassIndication(Buffer& inBuffer, uint32_t seq)
 {
-    // TODO
+    string package;
+    string clsName;
+    SchemaHash hash;
+    uint8_t kind = inBuffer.getOctet();
+    inBuffer.getShortString(package);
+    inBuffer.getShortString(clsName);
+    hash.decode(inBuffer);
+    Uuid printableHash(hash.get());
+    SchemaClassKeyImpl classKey(package, clsName, hash);
+
+    QPID_LOG(trace, "RCVD ClassIndication seq=" << seq << " kind=" << (int) kind << " key=" << classKey.str());
+
+    if (!console->haveClass(classKey)) {
+        Mutex::ScopedLock _lock(lock);
+        incOutstandingLH();
+        Buffer outBuffer(outputBuffer, MA_BUFFER_SIZE);
+        uint32_t sequence(seqMgr.reserve(this));
+        Protocol::encodeHeader(outBuffer, Protocol::OP_SCHEMA_REQUEST, sequence);
+        classKey.encode(outBuffer);
+        sendBufferLH(outBuffer, QMF_EXCHANGE, BROKER_KEY);
+        QPID_LOG(trace, "SENT SchemaRequest seq=" << sequence <<" key=" << classKey.str());
+    }
 }
 
 void BrokerProxyImpl::handleMethodResponse(Buffer& /*inBuffer*/, uint32_t /*seq*/)
@@ -446,9 +504,28 @@
     // TODO
 }
 
-void BrokerProxyImpl::handleSchemaResponse(Buffer& /*inBuffer*/, uint32_t /*seq*/)
+void BrokerProxyImpl::handleSchemaResponse(Buffer& inBuffer, uint32_t seq)
 {
-    // TODO
+    SchemaObjectClassImpl::Ptr oClassPtr;
+    SchemaEventClassImpl::Ptr eClassPtr;
+    uint8_t kind = inBuffer.getOctet();
+    const SchemaClassKeyImpl* key;
+    if (kind == CLASS_OBJECT) {
+        oClassPtr.reset(new SchemaObjectClassImpl(inBuffer));
+        console->learnClass(oClassPtr);
+        key = oClassPtr->getClassKey()->impl;
+        QPID_LOG(trace, "RCVD SchemaResponse seq=" << seq << " kind=object key=" << key->str());
+    } else if (kind == CLASS_EVENT) {
+        eClassPtr.reset(new SchemaEventClassImpl(inBuffer));
+        console->learnClass(eClassPtr);
+        key = eClassPtr->getClassKey()->impl;
+        QPID_LOG(trace, "RCVD SchemaResponse seq=" << seq << " kind=event key=" << key->str());
+    }
+    else {
+        QPID_LOG(error, "BrokerProxyImpl::handleSchemaResponse received unknown class kind: " << (int) kind);
+    }
+
+    decOutstanding();
 }
 
 void BrokerProxyImpl::handleObjectIndication(Buffer& /*inBuffer*/, uint32_t /*seq*/, bool /*prop*/, bool /*stat*/)
@@ -456,9 +533,8 @@
     // TODO
 }
 
-void BrokerProxyImpl::incOutstanding()
+void BrokerProxyImpl::incOutstandingLH()
 {
-    Mutex::ScopedLock _lock(lock);
     requestsOutstanding++;
 }
 
@@ -467,12 +543,14 @@
     Mutex::ScopedLock _lock(lock);
     requestsOutstanding--;
     if (requestsOutstanding == 0 && !topicBound) {
+        topicBound = true;
         for (vector<pair<string, string> >::const_iterator iter = console->bindingList.begin();
              iter != console->bindingList.end(); iter++) {
             string exchange(iter->first.empty() ? QMF_EXCHANGE : iter->first);
             string key(iter->second);
             eventQueue.push_back(eventBind(exchange, queueName, key));
         }
+        eventQueue.push_back(eventStable());
     }
 }
 
@@ -528,57 +606,122 @@
         eventQueue.pop_front();
 }
 
-void ConsoleEngineImpl::addConnection(BrokerProxy& /*broker*/, void* /*context*/)
+void ConsoleEngineImpl::addConnection(BrokerProxy& broker, void* /*context*/)
 {
-    // TODO
+    Mutex::ScopedLock _lock(lock);
+    brokerList.push_back(broker.impl);
 }
 
-void ConsoleEngineImpl::delConnection(BrokerProxy& /*broker*/)
+void ConsoleEngineImpl::delConnection(BrokerProxy& broker)
 {
-    // TODO
+    Mutex::ScopedLock _lock(lock);
+    for (vector<BrokerProxyImpl*>::iterator iter = brokerList.begin();
+         iter != brokerList.end(); iter++)
+        if (*iter == broker.impl) {
+            brokerList.erase(iter);
+            break;
+        }
 }
 
 uint32_t ConsoleEngineImpl::packageCount() const
 {
-    // TODO
-    return 0;
+    Mutex::ScopedLock _lock(lock);
+    return packages.size();
 }
 
-const string& ConsoleEngineImpl::getPackageName(uint32_t /*idx*/) const
+const string& ConsoleEngineImpl::getPackageName(uint32_t idx) const
 {
-    // TODO
-    static string temp;
-    return temp;
+    const static string empty;
+
+    Mutex::ScopedLock _lock(lock);
+    if (idx >= packages.size())
+        return empty;
+
+    PackageList::const_iterator iter = packages.begin();
+    for (uint32_t i = 0; i < idx; i++) iter++;
+    return iter->first;
 }
 
-uint32_t ConsoleEngineImpl::classCount(const char* /*packageName*/) const
+uint32_t ConsoleEngineImpl::classCount(const char* packageName) const
 {
-    // TODO
-    return 0;
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(packageName);
+    if (pIter == packages.end())
+        return 0;
+
+    const ObjectClassList& oList = pIter->second.first;
+    const EventClassList& eList = pIter->second.second;
+
+    return oList.size() + eList.size();
 }
 
-const SchemaClassKey* ConsoleEngineImpl::getClass(const char* /*packageName*/, uint32_t /*idx*/) const
+const SchemaClassKey* ConsoleEngineImpl::getClass(const char* packageName, uint32_t idx) const
 {
-    // TODO
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(packageName);
+    if (pIter == packages.end())
+        return 0;
+
+    const ObjectClassList& oList = pIter->second.first;
+    const EventClassList& eList = pIter->second.second;
+    uint32_t count = 0;
+    
+    for (ObjectClassList::const_iterator oIter = oList.begin();
+         oIter != oList.end(); oIter++) {
+        if (count == idx)
+            return oIter->second->getClassKey();
+        count++;
+    }
+
+    for (EventClassList::const_iterator eIter = eList.begin();
+         eIter != eList.end(); eIter++) {
+        if (count == idx)
+            return eIter->second->getClassKey();
+        count++;
+    }
+
     return 0;
 }
 
-ClassKind ConsoleEngineImpl::getClassKind(const SchemaClassKey& /*key*/) const
+ClassKind ConsoleEngineImpl::getClassKind(const SchemaClassKey* key) const
 {
-    // TODO
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(key->getPackageName());
+    if (pIter == packages.end())
+        return CLASS_OBJECT;
+
+    const EventClassList& eList = pIter->second.second;
+    if (eList.find(key->impl) != eList.end())
+        return CLASS_EVENT;
     return CLASS_OBJECT;
 }
 
-const SchemaObjectClass* ConsoleEngineImpl::getObjectClass(const SchemaClassKey& /*key*/) const
+const SchemaObjectClass* ConsoleEngineImpl::getObjectClass(const SchemaClassKey* key) const
 {
-    // TODO
-    return 0;
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(key->getPackageName());
+    if (pIter == packages.end())
+        return 0;
+
+    const ObjectClassList& oList = pIter->second.first;
+    ObjectClassList::const_iterator iter = oList.find(key->impl);
+    if (iter == oList.end())
+        return 0;
+    return iter->second->envelope;
 }
 
-const SchemaEventClass* ConsoleEngineImpl::getEventClass(const SchemaClassKey& /*key*/) const
+const SchemaEventClass* ConsoleEngineImpl::getEventClass(const SchemaClassKey* key) const
 {
-    // TODO
-    return 0;
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(key->getPackageName());
+    if (pIter == packages.end())
+        return 0;
+
+    const EventClassList& eList = pIter->second.second;
+    EventClassList::const_iterator iter = eList.find(key->impl);
+    if (iter == eList.end())
+        return 0;
+    return iter->second->envelope;
 }
 
 void ConsoleEngineImpl::bindPackage(const char* packageName)
@@ -587,18 +730,18 @@
     key << "console.obj.*.*." << packageName << ".#";
     Mutex::ScopedLock _lock(lock);
     bindingList.push_back(pair<string, string>(string(), key.str()));
-    for (vector<BrokerProxyImpl::Ptr>::iterator iter = brokerList.begin();
+    for (vector<BrokerProxyImpl*>::iterator iter = brokerList.begin();
          iter != brokerList.end(); iter++)
         (*iter)->addBinding(QMF_EXCHANGE, key.str());
 }
 
-void ConsoleEngineImpl::bindClass(const SchemaClassKey& classKey)
+void ConsoleEngineImpl::bindClass(const SchemaClassKey* classKey)
 {
     stringstream key;
-    key << "console.obj.*.*." << classKey.getPackageName() << "." << classKey.getClassName() << ".#";
+    key << "console.obj.*.*." << classKey->getPackageName() << "." << classKey->getClassName() << ".#";
     Mutex::ScopedLock _lock(lock);
     bindingList.push_back(pair<string, string>(string(), key.str()));
-    for (vector<BrokerProxyImpl::Ptr>::iterator iter = brokerList.begin();
+    for (vector<BrokerProxyImpl*>::iterator iter = brokerList.begin();
          iter != brokerList.end(); iter++)
         (*iter)->addBinding(QMF_EXCHANGE, key.str());
 }
@@ -609,7 +752,7 @@
     key << "console.obj.*.*." << packageName << "." << className << ".#";
     Mutex::ScopedLock _lock(lock);
     bindingList.push_back(pair<string, string>(string(), key.str()));
-    for (vector<BrokerProxyImpl::Ptr>::iterator iter = brokerList.begin();
+    for (vector<BrokerProxyImpl*>::iterator iter = brokerList.begin();
          iter != brokerList.end(); iter++)
         (*iter)->addBinding(QMF_EXCHANGE, key.str());
 }
@@ -645,6 +788,53 @@
 }
 */
 
+void ConsoleEngineImpl::learnPackage(const string& packageName)
+{
+    Mutex::ScopedLock _lock(lock);
+    if (packages.find(packageName) == packages.end())
+        packages.insert(pair<string, pair<ObjectClassList, EventClassList> >
+                        (packageName, pair<ObjectClassList, EventClassList>(ObjectClassList(), EventClassList())));
+}
+
+void ConsoleEngineImpl::learnClass(SchemaObjectClassImpl::Ptr cls)
+{
+    Mutex::ScopedLock _lock(lock);
+    const SchemaClassKey* key = cls->getClassKey();
+    PackageList::iterator pIter = packages.find(key->getPackageName());
+    if (pIter == packages.end())
+        return;
+
+    ObjectClassList& list = pIter->second.first;
+    if (list.find(key->impl) == list.end())
+        list[key->impl] = cls;
+}
+
+void ConsoleEngineImpl::learnClass(SchemaEventClassImpl::Ptr cls)
+{
+    Mutex::ScopedLock _lock(lock);
+    const SchemaClassKey* key = cls->getClassKey();
+    PackageList::iterator pIter = packages.find(key->getPackageName());
+    if (pIter == packages.end())
+        return;
+
+    EventClassList& list = pIter->second.second;
+    if (list.find(key->impl) == list.end())
+        list[key->impl] = cls;
+}
+
+bool ConsoleEngineImpl::haveClass(const SchemaClassKeyImpl& key) const
+{
+    Mutex::ScopedLock _lock(lock);
+    PackageList::const_iterator pIter = packages.find(key.getPackageName());
+    if (pIter == packages.end())
+        return false;
+
+    const ObjectClassList& oList = pIter->second.first;
+    const EventClassList& eList = pIter->second.second;
+
+    return oList.find(&key) != oList.end() || eList.find(&key) != eList.end();
+}
+
 
 //==================================================================
 // Wrappers
@@ -680,11 +870,11 @@
 const char* ConsoleEngine::getPackageName(uint32_t idx) const { return impl->getPackageName(idx).c_str(); }
 uint32_t ConsoleEngine::classCount(const char* packageName) const { return impl->classCount(packageName); }
 const SchemaClassKey* ConsoleEngine::getClass(const char* packageName, uint32_t idx) const { return impl->getClass(packageName, idx); }
-ClassKind ConsoleEngine::getClassKind(const SchemaClassKey& key) const { return impl->getClassKind(key); }
-const SchemaObjectClass* ConsoleEngine::getObjectClass(const SchemaClassKey& key) const { return impl->getObjectClass(key); }
-const SchemaEventClass* ConsoleEngine::getEventClass(const SchemaClassKey& key) const { return impl->getEventClass(key); }
+ClassKind ConsoleEngine::getClassKind(const SchemaClassKey* key) const { return impl->getClassKind(key); }
+const SchemaObjectClass* ConsoleEngine::getObjectClass(const SchemaClassKey* key) const { return impl->getObjectClass(key); }
+const SchemaEventClass* ConsoleEngine::getEventClass(const SchemaClassKey* key) const { return impl->getEventClass(key); }
 void ConsoleEngine::bindPackage(const char* packageName) { impl->bindPackage(packageName); }
-void ConsoleEngine::bindClass(const SchemaClassKey& key) { impl->bindClass(key); }
+void ConsoleEngine::bindClass(const SchemaClassKey* key) { impl->bindClass(key); }
 void ConsoleEngine::bindClass(const char* packageName, const char* className) { impl->bindClass(packageName, className); }
 uint32_t ConsoleEngine::agentCount() const { return impl->agentCount(); }
 const AgentProxy* ConsoleEngine::getAgent(uint32_t idx) const { return impl->getAgent(idx); }

Modified: qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.h?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.h (original)
+++ qpid/trunk/qpid/cpp/src/qmf/ConsoleEngine.h Wed Sep  2 12:32:56 2009
@@ -92,7 +92,8 @@
             DELETE_QUEUE    = 12,
             BIND            = 13,
             UNBIND          = 14,
-            SETUP_COMPLETE  = 15
+            SETUP_COMPLETE  = 15,
+            STABLE          = 16
         };
 
         EventKind kind;
@@ -169,12 +170,12 @@
         uint32_t classCount(const char* packageName) const;
         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;
+        ClassKind getClassKind(const SchemaClassKey* key) const;
+        const SchemaObjectClass* getObjectClass(const SchemaClassKey* key) const;
+        const SchemaEventClass* getEventClass(const SchemaClassKey* key) const;
 
         void bindPackage(const char* packageName);
-        void bindClass(const SchemaClassKey& key);
+        void bindClass(const SchemaClassKey* key);
         void bindClass(const char* packageName, const char* className);
 
         uint32_t agentCount() const;

Modified: qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp (original)
+++ qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp Wed Sep  2 12:32:56 2009
@@ -270,7 +270,10 @@
     RCSession* sess = (RCSession*) handle.impl;
 
     sess->session.queueDeclare(arg::queue=queue, arg::autoDelete=true, arg::exclusive=true);
+    sess->subscriptions->setAcceptMode(ACCEPT_MODE_NONE);
+    sess->subscriptions->setAcquireMode(ACQUIRE_MODE_PRE_ACQUIRED);
     sess->subscriptions->subscribe(*sess, queue, queue);
+    sess->subscriptions->setFlowControl(queue, FlowControl::unlimited());
     sess->dests.push_back(string(queue));
 }
 

Modified: qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp (original)
+++ qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp Wed Sep  2 12:32:56 2009
@@ -20,6 +20,8 @@
 #include "qmf/SchemaImpl.h"
 #include <qpid/framing/Buffer.h>
 #include <qpid/framing/FieldTable.h>
+#include <qpid/framing/Uuid.h>
+#include <string.h>
 #include <string>
 #include <vector>
 
@@ -27,6 +29,7 @@
 using namespace qmf;
 using qpid::framing::Buffer;
 using qpid::framing::FieldTable;
+using qpid::framing::Uuid;
 
 SchemaHash::SchemaHash()
 {
@@ -34,7 +37,7 @@
         hash[idx] = 0x5A;
 }
 
-void SchemaHash::encode(Buffer& buffer)
+void SchemaHash::encode(Buffer& buffer) const
 {
     buffer.putBin128(hash);
 }
@@ -63,6 +66,21 @@
     }
 }
 
+bool SchemaHash::operator==(const SchemaHash& other) const
+{
+    return ::memcmp(&hash, &other.hash, 16) == 0;
+}
+
+bool SchemaHash::operator<(const SchemaHash& other) const
+{
+    return ::memcmp(&hash, &other.hash, 16) < 0;
+}
+
+bool SchemaHash::operator>(const SchemaHash& other) const
+{
+    return ::memcmp(&hash, &other.hash, 16) > 0;
+}
+
 SchemaArgumentImpl::SchemaArgumentImpl(Buffer& buffer) : envelope(new SchemaArgument(this))
 {
     FieldTable map;
@@ -243,6 +261,37 @@
 SchemaClassKeyImpl::SchemaClassKeyImpl(const string& p, const string& n, const SchemaHash& h) :
     envelope(new SchemaClassKey(this)), package(p), name(n), hash(h) {}
 
+void SchemaClassKeyImpl::encode(qpid::framing::Buffer& buffer) const
+{
+    buffer.putShortString(package);
+    buffer.putShortString(name);
+    hash.encode(buffer);
+}
+
+bool SchemaClassKeyImpl::operator==(const SchemaClassKeyImpl& other) const
+{
+    return package == other.package &&
+        name == other.name &&
+        hash == other.hash;
+}
+
+bool SchemaClassKeyImpl::operator<(const SchemaClassKeyImpl& other) const
+{
+    if (package < other.package) return true;
+    if (package > other.package) return false;
+    if (name < other.name) return true;
+    if (name > other.name) return false;
+    return hash < other.hash;
+}
+
+string SchemaClassKeyImpl::str() const
+{
+    Uuid printableHash(hash.get());
+    stringstream str;
+    str << package << ":" << name << "(" << printableHash << ")";
+    return str.str();
+}
+
 SchemaObjectClassImpl::SchemaObjectClassImpl(Buffer& buffer) :
     envelope(new SchemaObjectClass(this)), hasHash(true), classKey(package, name, hash)
 {
@@ -419,332 +468,74 @@
 // Wrappers
 //==================================================================
 
-SchemaArgument::SchemaArgument(const char* name, Typecode typecode)
-{
-    impl = new SchemaArgumentImpl(this, name, typecode);
-}
-
+SchemaArgument::SchemaArgument(const char* name, Typecode typecode) { impl = new SchemaArgumentImpl(this, name, typecode); }
 SchemaArgument::SchemaArgument(SchemaArgumentImpl* i) : impl(i) {}
-
-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(this, name);
-}
-
+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(this, name); }
 SchemaMethod::SchemaMethod(SchemaMethodImpl* i) : impl(i) {}
-
-SchemaMethod::~SchemaMethod()
-{
-    delete impl;
-}
-
-void SchemaMethod::addArgument(const SchemaArgument& argument)
-{
-    impl->addArgument(argument);
-}
-
-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);
-}
-
-SchemaProperty::SchemaProperty(const char* name, Typecode typecode)
-{
-    impl = new SchemaPropertyImpl(this, name, typecode);
-}
-
+SchemaMethod::~SchemaMethod() { delete impl; }
+void SchemaMethod::addArgument(const SchemaArgument& argument) { impl->addArgument(argument); }
+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); }
+SchemaProperty::SchemaProperty(const char* name, Typecode typecode) { impl = new SchemaPropertyImpl(this, name, typecode); }
 SchemaProperty::SchemaProperty(SchemaPropertyImpl* i) : impl(i) {}
-
-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::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();
-}
-
-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();
-}
-
-const char* SchemaProperty::getUnit() const
-{
-    return impl->getUnit().c_str();
-}
-
-const char* SchemaProperty::getDesc() const
-{
-    return impl->getDesc().c_str();
-}
-
-SchemaStatistic::SchemaStatistic(const char* name, Typecode typecode)
-{
-    impl = new SchemaStatisticImpl(this, name, typecode);
-}
-
+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::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(); }
+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(); }
+const char* SchemaProperty::getUnit() const { return impl->getUnit().c_str(); }
+const char* SchemaProperty::getDesc() const { return impl->getDesc().c_str(); }
+SchemaStatistic::SchemaStatistic(const char* name, Typecode typecode) { impl = new SchemaStatisticImpl(this, name, typecode); }
 SchemaStatistic::SchemaStatistic(SchemaStatisticImpl* i) : impl(i) {}
-
-SchemaStatistic::~SchemaStatistic()
-{
-    delete impl;
-}
-
-void SchemaStatistic::setUnit(const char* val)
-{
-    impl->setUnit(val);
-}
-
-void SchemaStatistic::setDesc(const char* desc)
-{
-    impl->setDesc(desc);
-}
-
-const char* SchemaStatistic::getName() const
-{
-    return impl->getName().c_str();
-}
-
-Typecode SchemaStatistic::getType() const
-{
-    return impl->getType();
-}
-
-const char* SchemaStatistic::getUnit() const
-{
-    return impl->getUnit().c_str();
-}
-
-const char* SchemaStatistic::getDesc() const
-{
-    return impl->getDesc().c_str();
-}
-
+SchemaStatistic::~SchemaStatistic() { delete impl; }
+void SchemaStatistic::setUnit(const char* val) { impl->setUnit(val); }
+void SchemaStatistic::setDesc(const char* desc) { impl->setDesc(desc); }
+const char* SchemaStatistic::getName() const { return impl->getName().c_str(); }
+Typecode SchemaStatistic::getType() const { return impl->getType(); }
+const char* SchemaStatistic::getUnit() const { return impl->getUnit().c_str(); }
+const char* SchemaStatistic::getDesc() const { return impl->getDesc().c_str(); }
 SchemaClassKey::SchemaClassKey(SchemaClassKeyImpl* i) : impl(i) {}
-
-SchemaClassKey::~SchemaClassKey()
-{
-    delete impl;
-}
-
-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();
-}
-
-SchemaObjectClass::SchemaObjectClass(const char* package, const char* name)
-{
-    impl = new SchemaObjectClassImpl(this, package, name);
-}
-
+SchemaClassKey::~SchemaClassKey() { delete impl; }
+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(); }
+SchemaObjectClass::SchemaObjectClass(const char* package, const char* name) { impl = new SchemaObjectClassImpl(this, package, name); }
 SchemaObjectClass::SchemaObjectClass(SchemaObjectClassImpl* i) : impl(i) {}
-
-SchemaObjectClass::~SchemaObjectClass()
-{
-    delete impl;
-}
-
-void SchemaObjectClass::addProperty(const SchemaProperty& property)
-{
-    impl->addProperty(property);
-}
-
-void SchemaObjectClass::addStatistic(const SchemaStatistic& statistic)
-{
-    impl->addStatistic(statistic);
-}
-
-void SchemaObjectClass::addMethod(const SchemaMethod& method)
-{
-    impl->addMethod(method);
-}
-
-const SchemaClassKey* SchemaObjectClass::getClassKey() const
-{
-    return impl->getClassKey();
-}
-
-int SchemaObjectClass::getPropertyCount() const
-{
-    return impl->getPropertyCount();
-}
-
-int SchemaObjectClass::getStatisticCount() const
-{
-    return impl->getStatisticCount();
-}
-
-int SchemaObjectClass::getMethodCount() const
-{
-    return impl->getMethodCount();
-}
-
-const SchemaProperty* SchemaObjectClass::getProperty(int idx) const
-{
-    return impl->getProperty(idx);
-}
-
-const SchemaStatistic* SchemaObjectClass::getStatistic(int idx) const
-{
-    return impl->getStatistic(idx);
-}
-
-const SchemaMethod* SchemaObjectClass::getMethod(int idx) const
-{
-    return impl->getMethod(idx);
-}
-
-SchemaEventClass::SchemaEventClass(const char* package, const char* name)
-{
-    impl = new SchemaEventClassImpl(this, package, name);
-}
-
+SchemaObjectClass::~SchemaObjectClass() { delete impl; }
+void SchemaObjectClass::addProperty(const SchemaProperty& property) { impl->addProperty(property); }
+void SchemaObjectClass::addStatistic(const SchemaStatistic& statistic) { impl->addStatistic(statistic); }
+void SchemaObjectClass::addMethod(const SchemaMethod& method) { impl->addMethod(method); }
+const SchemaClassKey* SchemaObjectClass::getClassKey() const { return impl->getClassKey(); }
+int SchemaObjectClass::getPropertyCount() const { return impl->getPropertyCount(); }
+int SchemaObjectClass::getStatisticCount() const { return impl->getStatisticCount(); }
+int SchemaObjectClass::getMethodCount() const { return impl->getMethodCount(); }
+const SchemaProperty* SchemaObjectClass::getProperty(int idx) const { return impl->getProperty(idx); }
+const SchemaStatistic* SchemaObjectClass::getStatistic(int idx) const { return impl->getStatistic(idx); }
+const SchemaMethod* SchemaObjectClass::getMethod(int idx) const { return impl->getMethod(idx); }
+SchemaEventClass::SchemaEventClass(const char* package, const char* name) { impl = new SchemaEventClassImpl(this, package, name); }
 SchemaEventClass::SchemaEventClass(SchemaEventClassImpl* i) : impl(i) {}
-
-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);
-}
+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); }
 

Modified: qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h?rev=810482&r1=810481&r2=810482&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h (original)
+++ qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h Wed Sep  2 12:32:56 2009
@@ -21,6 +21,7 @@
  */
 
 #include "qmf/Schema.h"
+#include <boost/shared_ptr.hpp>
 #include <string>
 #include <vector>
 #include <qpid/framing/Buffer.h>
@@ -35,7 +36,7 @@
         uint8_t hash[16];
     public:
         SchemaHash();
-        void encode(qpid::framing::Buffer& buffer);
+        void encode(qpid::framing::Buffer& buffer) const;
         void decode(qpid::framing::Buffer& buffer);
         void update(const char* data, uint32_t len);
         void update(uint8_t data);
@@ -45,6 +46,9 @@
         void update(Access a) { update((uint8_t) a); }
         void update(bool b) { update((uint8_t) (b ? 1 : 0)); }
         const uint8_t* get() const { return hash; }
+        bool operator==(const SchemaHash& other) const;
+        bool operator<(const SchemaHash& other) const;
+        bool operator>(const SchemaHash& other) const;
     };
 
     struct SchemaArgumentImpl {
@@ -149,9 +153,15 @@
         const std::string& getPackageName() const { return package; }
         const std::string& getClassName() const { return name; }
         const uint8_t* getHash() const { return hash.get(); }
+
+        void encode(qpid::framing::Buffer& buffer) const;
+        bool operator==(const SchemaClassKeyImpl& other) const;
+        bool operator<(const SchemaClassKeyImpl& other) const;
+        std::string str() const;
     };
 
     struct SchemaObjectClassImpl {
+        typedef boost::shared_ptr<SchemaObjectClassImpl> Ptr;
         SchemaObjectClass* envelope;
         std::string package;
         std::string name;
@@ -180,6 +190,7 @@
     };
 
     struct SchemaEventClassImpl {
+        typedef boost::shared_ptr<SchemaEventClassImpl> Ptr;
         SchemaEventClass* envelope;
         std::string package;
         std::string name;



---------------------------------------------------------------------
Apache Qpid - AMQP Messaging Implementation
Project:      http://qpid.apache.org
Use/Interact: mailto:commits-subscribe@qpid.apache.org