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/05/22 23:40:58 UTC

svn commit: r777720 [1/2] - in /qpid/trunk/qpid/cpp/src: ./ qmf/

Author: tross
Date: Fri May 22 21:40:57 2009
New Revision: 777720

URL: http://svn.apache.org/viewvc?rev=777720&view=rev
Log:
QPID-1874 - First drop of the second-generation QMF libraries.

Added:
    qpid/trunk/qpid/cpp/src/qmf/
    qpid/trunk/qpid/cpp/src/qmf/Agent.cpp
    qpid/trunk/qpid/cpp/src/qmf/Agent.h
    qpid/trunk/qpid/cpp/src/qmf/Console.h
    qpid/trunk/qpid/cpp/src/qmf/Event.h
    qpid/trunk/qpid/cpp/src/qmf/Message.h
    qpid/trunk/qpid/cpp/src/qmf/MessageImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/MessageImpl.h
    qpid/trunk/qpid/cpp/src/qmf/Object.h
    qpid/trunk/qpid/cpp/src/qmf/ObjectId.h
    qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.h
    qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.h
    qpid/trunk/qpid/cpp/src/qmf/Query.h
    qpid/trunk/qpid/cpp/src/qmf/QueryImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/QueryImpl.h
    qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.cpp
    qpid/trunk/qpid/cpp/src/qmf/ResilientConnection.h
    qpid/trunk/qpid/cpp/src/qmf/Schema.h
    qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/SchemaImpl.h
    qpid/trunk/qpid/cpp/src/qmf/Typecode.h
    qpid/trunk/qpid/cpp/src/qmf/Value.h
    qpid/trunk/qpid/cpp/src/qmf/ValueImpl.cpp
    qpid/trunk/qpid/cpp/src/qmf/ValueImpl.h
Modified:
    qpid/trunk/qpid/cpp/src/CMakeLists.txt
    qpid/trunk/qpid/cpp/src/qmf.mk

Modified: qpid/trunk/qpid/cpp/src/CMakeLists.txt
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/CMakeLists.txt?rev=777720&r1=777719&r2=777720&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/CMakeLists.txt (original)
+++ qpid/trunk/qpid/cpp/src/CMakeLists.txt Fri May 22 21:40:57 2009
@@ -578,12 +578,28 @@
      qpid/agent/ManagementAgent.h
      qpid/agent/ManagementAgentImpl.cpp
      qpid/agent/ManagementAgentImpl.h
+     qmf/Agent.cpp
     )
 add_library (qmfagent SHARED ${qmfagent_SOURCES})
-target_link_libraries (qmfagent qpidclient)
+target_link_libraries (qmfagent qmfcommon)
 set_target_properties (qmfagent PROPERTIES
                        VERSION ${qpidc_version})
 
+set (qmfcommon_SOURCES
+    qmf/Agent.cpp
+    qmf/ResilientConnection.cpp
+    qmf/MessageImpl.cpp
+    qmf/SchemaImpl.cpp
+    qmf/ValueImpl.cpp
+    qmf/ObjectIdImpl.cpp
+    qmf/ObjectImpl.cpp
+    qmf/QueryImpl.cpp
+    )
+add_library (qmfcommon SHARED ${qmfcommon_SOURCES})
+target_link_libraries (qmfcommon qpidclient)
+set_target_properties (qmfcommon PROPERTIES
+                       VERSION ${qpidc_version})
+
 # QMF console library
 #module_hdr += \
 #  qpid/console/Agent.h \

Modified: qpid/trunk/qpid/cpp/src/qmf.mk
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf.mk?rev=777720&r1=777719&r2=777720&view=diff
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf.mk (original)
+++ qpid/trunk/qpid/cpp/src/qmf.mk Fri May 22 21:40:57 2009
@@ -20,17 +20,49 @@
 #
 # qmf agent library makefile fragment, to be included in Makefile.am
 # 
-lib_LTLIBRARIES += libqmfagent.la
+lib_LTLIBRARIES += \
+  libqmfcommon.la \
+  libqmfagent.la
 
 module_hdr += \
   qpid/agent/ManagementAgent.h \
   qpid/agent/ManagementAgentImpl.h \
-  qpid/agent/QmfAgentImportExport.h
+  qpid/agent/QmfAgentImportExport.h \
+  qmf/Agent.h \
+  qmf/Console.h \
+  qmf/Event.h \
+  qmf/Message.h \
+  qmf/MessageImpl.h \
+  qmf/Object.h \
+  qmf/ObjectId.h \
+  qmf/ObjectIdImpl.h \
+  qmf/ObjectImpl.h \
+  qmf/Query.h \
+  qmf/QueryImpl.h \
+  qmf/ResilientConnection.h \
+  qmf/Schema.h \
+  qmf/SchemaImpl.h \
+  qmf/Typecode.h \
+  qmf/Value.h \
+  qmf/ValueImpl.h
+
+libqmfcommon_la_SOURCES = \
+  qmf/Agent.cpp \
+  qmf/ResilientConnection.cpp \
+  qmf/MessageImpl.cpp \
+  qmf/SchemaImpl.cpp \
+  qmf/ValueImpl.cpp \
+  qmf/ObjectIdImpl.cpp \
+  qmf/ObjectImpl.cpp \
+  qmf/QueryImpl.cpp
 
 libqmfagent_la_SOURCES = \
   qpid/agent/ManagementAgent.h \
   qpid/agent/ManagementAgentImpl.cpp \
-  qpid/agent/ManagementAgentImpl.h
+  qpid/agent/ManagementAgentImpl.h \
+  qmf/Agent.cpp
 
 libqmfagent_la_LIBADD = libqpidclient.la
 
+libqmfagent_ladir = $(includedir)/qmf
+libqmfagent_la_HEADERS = $(module_hdr)

Added: qpid/trunk/qpid/cpp/src/qmf/Agent.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Agent.cpp?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Agent.cpp (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Agent.cpp Fri May 22 21:40:57 2009
@@ -0,0 +1,962 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "Agent.h"
+#include "MessageImpl.h"
+#include "SchemaImpl.h"
+#include "Typecode.h"
+#include "ObjectImpl.h"
+#include "ObjectIdImpl.h"
+#include "QueryImpl.h"
+#include "ValueImpl.h"
+#include <qpid/framing/Buffer.h>
+#include <qpid/framing/Uuid.h>
+#include <qpid/framing/FieldTable.h>
+#include <qpid/framing/FieldValue.h>
+#include <qpid/sys/Mutex.h>
+#include <qpid/log/Statement.h>
+#include <qpid/sys/Time.h>
+#include <string.h>
+#include <string>
+#include <deque>
+#include <map>
+#include <unistd.h>
+#include <fcntl.h>
+#include <iostream>
+#include <fstream>
+#include <boost/shared_ptr.hpp>
+
+using namespace std;
+using namespace qmf;
+using namespace qpid::framing;
+using namespace qpid::sys;
+
+namespace qmf {
+
+    struct AgentEventImpl {
+        typedef boost::shared_ptr<AgentEventImpl> Ptr;
+        AgentEvent::EventKind kind;
+        uint32_t    sequence;
+        string      authUserId;
+        string      authToken;
+        string      name;
+        Object*     object;
+        boost::shared_ptr<ObjectId> objectId;
+        Query       query;
+        boost::shared_ptr<Value> arguments;
+        string      exchange;
+        string      bindingKey;
+        SchemaObjectClass* objectClass;
+
+        AgentEventImpl(AgentEvent::EventKind k) :
+            kind(k), sequence(0), object(0), objectClass(0) {}
+        ~AgentEventImpl() {}
+        AgentEvent copy();
+    };
+
+    struct AgentQueryContext {
+        typedef boost::shared_ptr<AgentQueryContext> Ptr;
+        uint32_t sequence;
+        string   exchange;
+        string   key;
+        SchemaMethodImpl* schemaMethod;
+        AgentQueryContext() : schemaMethod(0) {}
+    };
+
+    class AgentImpl {
+    public:
+        AgentImpl(char* label, bool internalStore);
+        ~AgentImpl();
+
+        void setStoreDir(char* path);
+        void setTransferDir(char* path);
+        void handleRcvMessage(Message& message);
+        bool getXmtMessage(Message& item);
+        void popXmt();
+        bool getEvent(AgentEvent& event);
+        void popEvent();
+        void newSession();
+        void startProtocol();
+        void heartbeat();
+        void methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments);
+        void queryResponse(uint32_t sequence, Object& object, bool prop, bool stat);
+        void queryComplete(uint32_t sequence);
+        void registerClass(SchemaObjectClass* cls);
+        void registerClass(SchemaEventClass* cls);
+        const ObjectId* addObject(Object& obj, uint64_t persistId);
+        const ObjectId* allocObjectId(uint64_t persistId);
+        const ObjectId* allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi);
+        void raiseEvent(Event& event);
+
+    private:
+        Mutex     lock;
+        Mutex     addLock;
+        string    label;
+        string    queueName;
+        string    storeDir;
+        string    transferDir;
+        bool      internalStore;
+        uint64_t  nextTransientId;
+        Uuid      systemId;
+        uint32_t  requestedBrokerBank;
+        uint32_t  requestedAgentBank;
+        uint32_t  assignedBrokerBank;
+        uint32_t  assignedAgentBank;
+        AgentAttachment attachment;
+        uint16_t  bootSequence;
+        uint64_t  nextObjectId;
+        uint32_t  nextContextNum;
+        deque<AgentEventImpl::Ptr> eventQueue;
+        deque<MessageImpl::Ptr> xmtQueue;
+        map<uint32_t, AgentQueryContext::Ptr> contextMap;
+
+        static const char* QMF_EXCHANGE;
+        static const char* DIR_EXCHANGE;
+        static const char* BROKER_KEY;
+        static const uint32_t MERR_UNKNOWN_METHOD = 2;
+        static const uint32_t MERR_UNKNOWN_PACKAGE = 8;
+        static const uint32_t MERR_UNKNOWN_CLASS = 9;
+        static const uint32_t MERR_INTERNAL_ERROR = 10;
+#       define MA_BUFFER_SIZE 65536
+        char outputBuffer[MA_BUFFER_SIZE];
+
+        struct SchemaClassKey {
+            string name;
+            uint8_t hash[16];
+            SchemaClassKey(const string& n, const uint8_t* h) : name(n) {
+                memcpy(hash, h, 16);
+            }
+            SchemaClassKey(Buffer& buffer) {
+                buffer.getShortString(name);
+                buffer.getBin128(hash);
+            }
+            string repr() {
+                return name;
+            }
+        };
+
+        struct SchemaClassKeyComp {
+            bool operator() (const SchemaClassKey& lhs, const SchemaClassKey& rhs) const
+            {
+                if (lhs.name != rhs.name)
+                    return lhs.name < rhs.name;
+                else
+                    for (int i = 0; i < 16; i++)
+                        if (lhs.hash[i] != rhs.hash[i])
+                            return lhs.hash[i] < rhs.hash[i];
+                return false;
+            }
+        };
+
+        typedef map<SchemaClassKey, SchemaObjectClassImpl*, SchemaClassKeyComp> ObjectClassMap;
+        typedef map<SchemaClassKey, SchemaEventClassImpl*, SchemaClassKeyComp>  EventClassMap;
+
+        struct ClassMaps {
+            ObjectClassMap objectClasses;
+            EventClassMap  eventClasses;
+        };
+
+        map<string, ClassMaps> packages;
+
+        bool checkHeader(Buffer& buf, uint8_t *opcode, uint32_t *seq);
+        void encodeHeader(Buffer& buf, uint8_t opcode, uint32_t seq = 0);
+        AgentEventImpl::Ptr eventDeclareQueue(const string& queueName);
+        AgentEventImpl::Ptr eventBind(const string& exchange, const string& queue, const string& key);
+        AgentEventImpl::Ptr eventSetupComplete();
+        AgentEventImpl::Ptr eventQuery(uint32_t num, const string& userId, const string& package, const string& cls,
+                                       boost::shared_ptr<ObjectId> oid);
+        AgentEventImpl::Ptr eventMethod(uint32_t num, const string& userId, const string& method,
+                                        boost::shared_ptr<ObjectId> oid, boost::shared_ptr<Value> argMap,
+                                        SchemaObjectClass* objectClass);
+        void sendBufferLH(Buffer& buf, const string& destination, const string& routingKey);
+
+        void sendPackageIndicationLH(const string& packageName);
+        void sendClassIndicationLH(ClassKind kind, const string& packageName, const SchemaClassKey& key);
+        void sendCommandCompleteLH(const string& exchange, const string& key, uint32_t seq,
+                                   uint32_t code = 0, const string& text = "OK");
+        void sendMethodErrorLH(uint32_t sequence, const string& key, uint32_t code, const string& text="");
+        void handleAttachResponse(Buffer& inBuffer);
+        void handlePackageRequest(Buffer& inBuffer);
+        void handleClassQuery(Buffer& inBuffer);
+        void handleSchemaRequest(Buffer& inBuffer, uint32_t sequence,
+                                 const string& replyToExchange, const string& replyToKey);
+        void handleGetQuery(Buffer& inBuffer, uint32_t sequence, const string& replyTo, const string& userId);
+        void handleMethodRequest(Buffer& inBuffer, uint32_t sequence, const string& replyTo, const string& userId);
+        void handleConsoleAddedIndication();
+    };
+}
+
+const char* AgentImpl::QMF_EXCHANGE = "qpid.management";
+const char* AgentImpl::DIR_EXCHANGE = "amq.direct";
+const char* AgentImpl::BROKER_KEY   = "broker";
+
+#define STRING_REF(s) {if (!s.empty()) item.s = const_cast<char*>(s.c_str());}
+
+AgentEvent AgentEventImpl::copy()
+{
+    AgentEvent item;
+
+    ::memset(&item, 0, sizeof(AgentEvent));
+    item.kind      = kind;
+    item.sequence  = sequence;
+    item.object    = object;
+    item.objectId  = objectId.get();
+    item.query     = &query;
+    item.arguments = arguments.get();
+    item.objectClass = objectClass;
+
+    STRING_REF(authUserId);
+    STRING_REF(authToken);
+    STRING_REF(name);
+    STRING_REF(exchange);
+    STRING_REF(bindingKey);
+
+    return item;
+}
+
+AgentImpl::AgentImpl(char* _label, bool i) :
+    label(_label), queueName("qmfa-"), internalStore(i), nextTransientId(1),
+    requestedBrokerBank(0), requestedAgentBank(0),
+    assignedBrokerBank(0), assignedAgentBank(0),
+    bootSequence(1), nextObjectId(1), nextContextNum(1)
+{
+    queueName += label;
+}
+
+AgentImpl::~AgentImpl()
+{
+    cout << "AgentImpl::~AgentImpl" << endl;
+}
+
+void AgentImpl::setStoreDir(char* path)
+{
+    Mutex::ScopedLock _lock(lock);
+    if (path)
+        storeDir = path;
+    else
+        storeDir.clear();
+}
+
+void AgentImpl::setTransferDir(char* path)
+{
+    Mutex::ScopedLock _lock(lock);
+    if (path)
+        transferDir = path;
+    else
+        transferDir.clear();
+}
+
+void AgentImpl::handleRcvMessage(Message& message)
+{
+    Buffer   inBuffer(message.body, message.length);
+    uint8_t  opcode;
+    uint32_t sequence;
+    string   replyToExchange(message.replyExchange ? message.replyExchange : "");
+    string   replyToKey(message.replyKey ? message.replyKey : "");
+    string   userId(message.userId ? message.userId : "");
+
+    if (checkHeader(inBuffer, &opcode, &sequence)) {
+        if      (opcode == 'a') handleAttachResponse(inBuffer);
+        else if (opcode == 'S') handleSchemaRequest(inBuffer, sequence, replyToExchange, replyToKey);
+        else if (opcode == 'x') handleConsoleAddedIndication();
+        else if (opcode == 'G') handleGetQuery(inBuffer, sequence, replyToKey, userId);
+        else if (opcode == 'M') handleMethodRequest(inBuffer, sequence, replyToKey, userId);
+    }
+}
+
+bool AgentImpl::getXmtMessage(Message& item)
+{
+    Mutex::ScopedLock _lock(lock);
+    if (xmtQueue.empty())
+        return false;
+    item =  xmtQueue.front()->copy();
+    return true;
+}
+
+void AgentImpl::popXmt()
+{
+    Mutex::ScopedLock _lock(lock);
+    if (!xmtQueue.empty())
+        xmtQueue.pop_front();
+}
+
+bool AgentImpl::getEvent(AgentEvent& event)
+{
+    Mutex::ScopedLock _lock(lock);
+    if (eventQueue.empty())
+        return false;
+    event = eventQueue.front()->copy();
+    return true;
+}
+
+void AgentImpl::popEvent()
+{
+    Mutex::ScopedLock _lock(lock);
+    if (!eventQueue.empty())
+        eventQueue.pop_front();
+}
+
+void AgentImpl::newSession()
+{
+    Mutex::ScopedLock _lock(lock);
+    eventQueue.clear();
+    xmtQueue.clear();
+    eventQueue.push_back(eventDeclareQueue(queueName));
+    eventQueue.push_back(eventBind("amq.direct", queueName, queueName));
+    eventQueue.push_back(eventSetupComplete());
+}
+
+void AgentImpl::startProtocol()
+{
+    Mutex::ScopedLock _lock(lock);
+    char    rawbuffer[512];
+    Buffer  buffer(rawbuffer, 512);
+
+    encodeHeader(buffer, 'A');
+    buffer.putShortString("qmfa");
+    systemId.encode(buffer);
+    buffer.putLong(requestedBrokerBank);
+    buffer.putLong(requestedAgentBank);
+    sendBufferLH(buffer, QMF_EXCHANGE, BROKER_KEY);
+    QPID_LOG(trace, "SENT AttachRequest: reqBroker=" << requestedBrokerBank <<
+             " reqAgent=" << requestedAgentBank);
+}
+
+void AgentImpl::heartbeat()
+{
+    Mutex::ScopedLock _lock(lock);
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+
+    encodeHeader(buffer, 'h');
+    buffer.putLongLong(uint64_t(Duration(now())));
+    stringstream key;
+    key << "console.heartbeat." << assignedBrokerBank << "." << assignedAgentBank;
+    sendBufferLH(buffer, QMF_EXCHANGE, key.str());
+    QPID_LOG(trace, "SENT HeartbeatIndication");
+}
+
+void AgentImpl::methodResponse(uint32_t sequence, uint32_t status, char* text,
+                               const Value& argMap)
+{
+    Mutex::ScopedLock _lock(lock);
+    map<uint32_t, AgentQueryContext::Ptr>::iterator iter = contextMap.find(sequence);
+    if (iter == contextMap.end())
+        return;
+    AgentQueryContext::Ptr context = iter->second;
+    contextMap.erase(iter);
+
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'm', context->sequence);
+    buffer.putLong(status);
+    buffer.putMediumString(text);
+    if (status == 0) {
+        for (vector<SchemaArgumentImpl*>::const_iterator aIter = context->schemaMethod->arguments.begin();
+             aIter != context->schemaMethod->arguments.end(); aIter++) {
+            const SchemaArgumentImpl* schemaArg = *aIter;
+            if (schemaArg->dir == DIR_OUT || schemaArg->dir == DIR_IN_OUT) {
+                if (argMap.keyInMap(schemaArg->name.c_str())) {
+                    const Value* val = argMap.byKey(schemaArg->name.c_str());
+                    val->impl->encode(buffer);
+                } else {
+                    Value val(schemaArg->typecode);
+                    val.impl->encode(buffer);
+                }
+            }
+        }
+    }
+    sendBufferLH(buffer, context->exchange, context->key);
+    QPID_LOG(trace, "SENT MethodResponse");
+}
+
+void AgentImpl::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
+{
+    Mutex::ScopedLock _lock(lock);
+    map<uint32_t, AgentQueryContext::Ptr>::iterator iter = contextMap.find(sequence);
+    if (iter == contextMap.end())
+        return;
+    AgentQueryContext::Ptr context = iter->second;
+
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'g', context->sequence);
+
+    object.impl->encodeSchemaKey(buffer);
+    object.impl->encodeManagedObjectData(buffer);
+    if (prop)
+        object.impl->encodeProperties(buffer);
+    if (stat)
+        object.impl->encodeStatistics(buffer);
+    
+    sendBufferLH(buffer, context->exchange, context->key);
+    QPID_LOG(trace, "SENT ContentIndication");
+}
+
+void AgentImpl::queryComplete(uint32_t sequence)
+{
+    Mutex::ScopedLock _lock(lock);
+    map<uint32_t, AgentQueryContext::Ptr>::iterator iter = contextMap.find(sequence);
+    if (iter == contextMap.end())
+        return;
+
+    AgentQueryContext::Ptr context = iter->second;
+    contextMap.erase(iter);
+    sendCommandCompleteLH(context->exchange, context->key, context->sequence, 0, "OK");
+}
+
+void AgentImpl::registerClass(SchemaObjectClass* cls)
+{
+    Mutex::ScopedLock _lock(lock);
+    SchemaObjectClassImpl* impl = cls->impl;
+
+    map<string, ClassMaps>::iterator iter = packages.find(impl->package);
+    if (iter == packages.end()) {
+        packages[impl->package] = ClassMaps();
+        iter = packages.find(impl->package);
+        // TODO: Indicate this package if connected
+    }
+
+    SchemaClassKey key(impl->name, impl->getHash());
+    iter->second.objectClasses[key] = impl;
+
+    // TODO: Indicate this schema if connected.
+}
+
+void AgentImpl::registerClass(SchemaEventClass* cls)
+{
+    Mutex::ScopedLock _lock(lock);
+    SchemaEventClassImpl* impl = cls->impl;
+
+    map<string, ClassMaps>::iterator iter = packages.find(impl->package);
+    if (iter == packages.end()) {
+        packages[impl->package] = ClassMaps();
+        iter = packages.find(impl->package);
+        // TODO: Indicate this package if connected
+    }
+
+    SchemaClassKey key(impl->name, impl->getHash());
+    iter->second.eventClasses[key] = impl;
+
+    // TODO: Indicate this schema if connected.
+}
+
+const ObjectId* AgentImpl::addObject(Object&, uint64_t)
+{
+    Mutex::ScopedLock _lock(lock);
+    return 0;
+}
+
+const ObjectId* AgentImpl::allocObjectId(uint64_t persistId)
+{
+    Mutex::ScopedLock _lock(lock);
+    uint16_t sequence  = persistId ? 0 : bootSequence;
+    uint64_t objectNum = persistId ? persistId : nextObjectId++;
+
+    ObjectIdImpl* oid = new ObjectIdImpl(&attachment, 0, sequence, objectNum);
+    return oid->envelope;
+}
+
+const ObjectId* AgentImpl::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
+{
+    return allocObjectId(((uint64_t) persistIdHi) << 32 | (uint64_t) persistIdLo);
+}
+
+void AgentImpl::raiseEvent(Event&)
+{
+    Mutex::ScopedLock _lock(lock);
+}
+
+void AgentImpl::encodeHeader(Buffer& buf, uint8_t opcode, uint32_t seq)
+{
+    buf.putOctet('A');
+    buf.putOctet('M');
+    buf.putOctet('2');
+    buf.putOctet(opcode);
+    buf.putLong (seq);
+}
+
+bool AgentImpl::checkHeader(Buffer& buf, uint8_t *opcode, uint32_t *seq)
+{
+    if (buf.getSize() < 8)
+        return false;
+
+    uint8_t h1 = buf.getOctet();
+    uint8_t h2 = buf.getOctet();
+    uint8_t h3 = buf.getOctet();
+
+    *opcode = buf.getOctet();
+    *seq    = buf.getLong();
+
+    return h1 == 'A' && h2 == 'M' && h3 == '2';
+}
+
+AgentEventImpl::Ptr AgentImpl::eventDeclareQueue(const string& name)
+{
+    AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::DECLARE_QUEUE));
+    event->name = name;
+
+    return event;
+}
+
+AgentEventImpl::Ptr AgentImpl::eventBind(const string& exchange, const string& queue,
+                                         const string& key)
+{
+    AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::BIND));
+    event->name       = queue;
+    event->exchange   = exchange;
+    event->bindingKey = key;
+
+    return event;
+}
+
+AgentEventImpl::Ptr AgentImpl::eventSetupComplete()
+{
+    AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::SETUP_COMPLETE));
+    return event;
+}
+
+AgentEventImpl::Ptr AgentImpl::eventQuery(uint32_t num, const string& userId, const string& package,
+                                          const string& cls, boost::shared_ptr<ObjectId> oid)
+{
+    AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::GET_QUERY));
+    event->sequence = num;
+    event->authUserId = userId;
+    event->query.impl->packageName = package;    
+    event->query.impl->className = cls;
+    event->query.impl->oid = oid;
+    return event;
+}
+
+AgentEventImpl::Ptr AgentImpl::eventMethod(uint32_t num, const string& userId, const string& method,
+                                           boost::shared_ptr<ObjectId> oid, boost::shared_ptr<Value> argMap,
+                                           SchemaObjectClass* objectClass)
+{
+    AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::METHOD_CALL));
+    event->sequence = num;
+    event->authUserId = userId;
+    event->name = method;
+    event->objectId = oid;
+    event->arguments = argMap;
+    event->objectClass = objectClass;
+    return event;
+}
+
+void AgentImpl::sendBufferLH(Buffer& buf, const string& destination, const string& routingKey)
+{
+    uint32_t length = buf.getPosition();
+    MessageImpl::Ptr message(new MessageImpl);
+
+    buf.reset();
+    buf.getRawData(message->body, length);
+    message->destination   = destination;
+    message->routingKey    = routingKey;
+    message->replyExchange = "amq.direct";
+    message->replyKey      = queueName;
+
+    xmtQueue.push_back(message);
+}
+
+void AgentImpl::sendPackageIndicationLH(const string& packageName)
+{
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'p');
+    buffer.putShortString(packageName);
+    sendBufferLH(buffer, QMF_EXCHANGE, BROKER_KEY);
+    QPID_LOG(trace, "SENT PackageIndication:  package_name=" << packageName);
+}
+
+void AgentImpl::sendClassIndicationLH(ClassKind kind, const string& packageName, const SchemaClassKey& key)
+{
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'q');
+    buffer.putOctet((int) kind);
+    buffer.putShortString(packageName);
+    buffer.putShortString(key.name);
+    buffer.putBin128(const_cast<uint8_t*>(key.hash)); // const_cast needed for older Qpid libraries
+    sendBufferLH(buffer, QMF_EXCHANGE, BROKER_KEY);
+    QPID_LOG(trace, "SENT ClassIndication:  package_name=" << packageName << " class_name=" << key.name);
+}
+
+void AgentImpl::sendCommandCompleteLH(const string& exchange, const string& replyToKey,
+                                      uint32_t sequence, uint32_t code, const string& text)
+{
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'z', sequence);
+    buffer.putLong(code);
+    buffer.putShortString(text);
+    sendBufferLH(buffer, exchange, replyToKey);
+    QPID_LOG(trace, "SENT CommandComplete: seq=" << sequence << " code=" << code << " text=" << text);
+}
+
+void AgentImpl::sendMethodErrorLH(uint32_t sequence, const string& key, uint32_t code, const string& text)
+{
+    Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+    encodeHeader(buffer, 'm', sequence);
+    buffer.putLong(code);
+
+    string fulltext;
+    switch (code) {
+    case MERR_UNKNOWN_PACKAGE: fulltext = "Unknown Package";  break;
+    case MERR_UNKNOWN_CLASS:   fulltext = "Unknown Class"; break;
+    case MERR_UNKNOWN_METHOD:  fulltext = "Unknown Method"; break;
+    case MERR_INTERNAL_ERROR:  fulltext = "Internal Error"; break;
+    default:                   fulltext = "Unspecified Error"; break;
+    }
+
+    if (!text.empty()) {
+        fulltext += " (";
+        fulltext += text;
+        fulltext += ")";
+    }
+
+    buffer.putMediumString(fulltext);
+    sendBufferLH(buffer, DIR_EXCHANGE, key);
+    QPID_LOG(trace, "SENT MethodResponse: errorCode=" << code << " text=" << fulltext);
+}
+
+void AgentImpl::handleAttachResponse(Buffer& inBuffer)
+{
+    Mutex::ScopedLock _lock(lock);
+
+    assignedBrokerBank = inBuffer.getLong();
+    assignedAgentBank  = inBuffer.getLong();
+
+    QPID_LOG(trace, "RCVD AttachResponse: broker=" << assignedBrokerBank << " agent=" << assignedAgentBank);
+
+    if ((assignedBrokerBank != requestedBrokerBank) ||
+        (assignedAgentBank  != requestedAgentBank)) {
+        if (requestedAgentBank == 0) {
+            QPID_LOG(notice, "Initial object-id bank assigned: " << assignedBrokerBank << "." <<
+                     assignedAgentBank);
+        } else {
+            QPID_LOG(warning, "Collision in object-id! New bank assigned: " << assignedBrokerBank <<
+                     "." << assignedAgentBank);
+        }
+        //storeData(); // TODO
+        requestedBrokerBank = assignedBrokerBank;
+        requestedAgentBank = assignedAgentBank;
+    }
+
+    attachment.setBanks(assignedBrokerBank, assignedAgentBank);
+
+    // Bind to qpid.management to receive commands
+    stringstream key;
+    key << "agent." << assignedBrokerBank << "." << assignedAgentBank;
+    eventQueue.push_back(eventBind(QMF_EXCHANGE, queueName, key.str()));
+
+    // Send package indications for all local packages
+    for (map<string, ClassMaps>::iterator pIter = packages.begin();
+         pIter != packages.end();
+         pIter++) {
+        sendPackageIndicationLH(pIter->first);
+
+        // Send class indications for all local classes
+        ClassMaps cMap = pIter->second;
+        for (ObjectClassMap::iterator cIter = cMap.objectClasses.begin();
+             cIter != cMap.objectClasses.end(); cIter++)
+            sendClassIndicationLH(CLASS_OBJECT, pIter->first, cIter->first);
+        for (EventClassMap::iterator cIter = cMap.eventClasses.begin();
+             cIter != cMap.eventClasses.end(); cIter++)
+            sendClassIndicationLH(CLASS_EVENT, pIter->first, cIter->first);
+    }
+}
+
+void AgentImpl::handlePackageRequest(Buffer&)
+{
+    Mutex::ScopedLock _lock(lock);
+}
+
+void AgentImpl::handleClassQuery(Buffer&)
+{
+    Mutex::ScopedLock _lock(lock);
+}
+
+void AgentImpl::handleSchemaRequest(Buffer& inBuffer, uint32_t sequence,
+                                    const string& replyExchange, const string& replyKey)
+{
+    Mutex::ScopedLock _lock(lock);
+    string rExchange(replyExchange);
+    string rKey(replyKey);
+    string packageName;
+    inBuffer.getShortString(packageName);
+    SchemaClassKey key(inBuffer);
+
+    if (rExchange.empty())
+        rExchange = QMF_EXCHANGE;
+    if (rKey.empty())
+        rKey = BROKER_KEY;
+
+    QPID_LOG(trace, "RCVD SchemaRequest: package=" << packageName << " class=" << key.name);
+
+    map<string, ClassMaps>::iterator pIter = packages.find(packageName);
+    if (pIter == packages.end()) {
+        sendCommandCompleteLH(rExchange, rKey, sequence, 1, "package not found");
+        return;
+    }
+
+    ClassMaps cMap = pIter->second;
+    ObjectClassMap::iterator ocIter = cMap.objectClasses.find(key);
+    if (ocIter != cMap.objectClasses.end()) {
+        SchemaObjectClassImpl* oImpl = ocIter->second;
+        Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+        encodeHeader(buffer, 's', sequence);
+        oImpl->encode(buffer);
+        sendBufferLH(buffer, rExchange, rKey);
+        QPID_LOG(trace, "SENT SchemaResponse: (object) package=" << packageName << " class=" << key.name);
+        return;
+    }
+
+    EventClassMap::iterator ecIter = cMap.eventClasses.find(key);
+    if (ecIter != cMap.eventClasses.end()) {
+        SchemaEventClassImpl* eImpl = ecIter->second;
+        Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
+        encodeHeader(buffer, 's', sequence);
+        eImpl->encode(buffer);
+        sendBufferLH(buffer, rExchange, rKey);
+        QPID_LOG(trace, "SENT SchemaResponse: (event) package=" << packageName << " class=" << key.name);
+        return;
+    }
+
+    sendCommandCompleteLH(rExchange, rKey, sequence, 1, "class not found");
+}
+
+void AgentImpl::handleGetQuery(Buffer& inBuffer, uint32_t sequence, const string& replyTo, const string& userId)
+{
+    Mutex::ScopedLock _lock(lock);
+    FieldTable ft;
+    FieldTable::ValuePtr value;
+    map<string, ClassMaps>::const_iterator pIter = packages.end();
+    string pname;
+    string cname;
+    string oidRepr;
+    boost::shared_ptr<ObjectId> oid;
+
+    ft.decode(inBuffer);
+    
+    QPID_LOG(trace, "RCVD GetQuery: map=" << ft);
+
+    value = ft.get("_package");
+    if (value.get() && value->convertsTo<string>()) {
+        pname = value->get<string>();
+        pIter = packages.find(pname);
+        if (pIter == packages.end()) {
+            sendCommandCompleteLH(DIR_EXCHANGE, replyTo, sequence);
+            return;
+        }
+    }
+
+    value = ft.get("_class");
+    if (value.get() && value->convertsTo<string>()) {
+        cname = value->get<string>();
+        // TODO - check for validity of class (in package or any package)
+        if (pIter == packages.end()) {
+        } else {
+            
+        }
+    }
+
+    value = ft.get("_objectid");
+    if (value.get() && value->convertsTo<string>()) {
+        oidRepr = value->get<string>();
+        oid.reset(new ObjectId());
+        oid->impl->fromString(oidRepr);
+    }
+
+    AgentQueryContext::Ptr context(new AgentQueryContext);
+    uint32_t contextNum = nextContextNum++;
+    context->sequence = sequence;
+    context->exchange = DIR_EXCHANGE;
+    context->key = replyTo;
+    contextMap[contextNum] = context;
+
+    eventQueue.push_back(eventQuery(contextNum, userId, pname, cname, oid));
+}
+
+void AgentImpl::handleMethodRequest(Buffer& buffer, uint32_t sequence, const string& replyTo, const string& userId)
+{
+    Mutex::ScopedLock _lock(lock);
+    string pname;
+    string method;
+    ObjectIdImpl* oidImpl = new ObjectIdImpl(buffer);
+    boost::shared_ptr<ObjectId> oid(oidImpl->envelope);
+    buffer.getShortString(pname);
+    SchemaClassKey classKey(buffer);
+    buffer.getShortString(method);
+
+    map<string, ClassMaps>::const_iterator pIter = packages.find(pname);
+    if (pIter == packages.end()) {
+        sendMethodErrorLH(sequence, replyTo, MERR_UNKNOWN_PACKAGE, pname);
+        return;
+    }
+
+    ObjectClassMap::const_iterator cIter = pIter->second.objectClasses.find(classKey);
+    if (cIter == pIter->second.objectClasses.end()) {
+        sendMethodErrorLH(sequence, replyTo, MERR_UNKNOWN_CLASS, classKey.repr());
+        return;
+    }
+
+    const SchemaObjectClassImpl* schema = cIter->second;
+    vector<SchemaMethodImpl*>::const_iterator mIter = schema->methods.begin();
+    for (; mIter != schema->methods.end(); mIter++) {
+        if ((*mIter)->name == method)
+            break;
+    }
+
+    if (mIter == schema->methods.end()) {
+        sendMethodErrorLH(sequence, replyTo, MERR_UNKNOWN_METHOD, method);
+        return;
+    }
+
+    SchemaMethodImpl* schemaMethod = *mIter;
+    boost::shared_ptr<Value> argMap(new Value(TYPE_MAP));
+    ValueImpl* value;
+    for (vector<SchemaArgumentImpl*>::const_iterator aIter = schemaMethod->arguments.begin();
+         aIter != schemaMethod->arguments.end(); aIter++) {
+        const SchemaArgumentImpl* schemaArg = *aIter;
+        if (schemaArg->dir == DIR_IN || schemaArg->dir == DIR_IN_OUT)
+            value = new ValueImpl(schemaArg->typecode, buffer);
+        else
+            value = new ValueImpl(schemaArg->typecode);
+        argMap->insert(schemaArg->name.c_str(), value->envelope);
+    }
+
+    AgentQueryContext::Ptr context(new AgentQueryContext);
+    uint32_t contextNum = nextContextNum++;
+    context->sequence = sequence;
+    context->exchange = DIR_EXCHANGE;
+    context->key = replyTo;
+    context->schemaMethod = schemaMethod;
+    contextMap[contextNum] = context;
+
+    eventQueue.push_back(eventMethod(contextNum, userId, method, oid, argMap, schema->envelope));
+}
+
+void AgentImpl::handleConsoleAddedIndication()
+{
+    Mutex::ScopedLock _lock(lock);
+}
+
+//==================================================================
+// Wrappers
+//==================================================================
+
+Agent::Agent(char* label, bool internalStore)
+{
+    impl = new AgentImpl(label, internalStore);
+}
+
+Agent::~Agent()
+{
+    cout << "Agent::~Agent" << endl;
+    delete impl;
+}
+
+void Agent::setStoreDir(char* path)
+{
+    impl->setStoreDir(path);
+}
+
+void Agent::setTransferDir(char* path)
+{
+    impl->setTransferDir(path);
+}
+
+void Agent::handleRcvMessage(Message& message)
+{
+    impl->handleRcvMessage(message);
+}
+
+bool Agent::getXmtMessage(Message& item)
+{
+    return impl->getXmtMessage(item);
+}
+
+void Agent::popXmt()
+{
+    impl->popXmt();
+}
+
+bool Agent::getEvent(AgentEvent& event)
+{
+    return impl->getEvent(event);
+}
+
+void Agent::popEvent()
+{
+    impl->popEvent();
+}
+
+void Agent::newSession()
+{
+    impl->newSession();
+}
+
+void Agent::startProtocol()
+{
+    impl->startProtocol();
+}
+
+void Agent::heartbeat()
+{
+    impl->heartbeat();
+}
+
+void Agent::methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments)
+{
+    impl->methodResponse(sequence, status, text, arguments);
+}
+
+void Agent::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
+{
+    impl->queryResponse(sequence, object, prop, stat);
+}
+
+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);
+}
+
+const ObjectId* Agent::addObject(Object& obj, uint64_t persistId)
+{
+    return impl->addObject(obj, persistId);
+}
+
+const ObjectId* Agent::allocObjectId(uint64_t persistId)
+{
+    return impl->allocObjectId(persistId);
+}
+
+const ObjectId* Agent::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
+{
+    return impl->allocObjectId(persistIdLo, persistIdHi);
+}
+
+void Agent::raiseEvent(Event& event)
+{
+    impl->raiseEvent(event);
+}
+

Added: qpid/trunk/qpid/cpp/src/qmf/Agent.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Agent.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Agent.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Agent.h Fri May 22 21:40:57 2009
@@ -0,0 +1,206 @@
+#ifndef _QmfAgent_
+#define _QmfAgent_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/Schema.h>
+#include <qmf/ObjectId.h>
+#include <qmf/Object.h>
+#include <qmf/Event.h>
+#include <qmf/Query.h>
+#include <qmf/Value.h>
+#include <qmf/Message.h>
+
+namespace qmf {
+
+    /**
+     * AgentEvent
+     *
+     *  This structure represents a QMF event coming from the agent to
+     *  the application.
+     */
+    struct AgentEvent {
+        enum EventKind {
+            GET_QUERY      = 1,
+            START_SYNC     = 2,
+            END_SYNC       = 3,
+            METHOD_CALL    = 4,
+            DECLARE_QUEUE  = 5,
+            DELETE_QUEUE   = 6,
+            BIND           = 7,
+            UNBIND         = 8,
+            SETUP_COMPLETE = 9
+        };
+
+        EventKind    kind;
+        uint32_t     sequence;    // Protocol sequence (for all kinds)
+        char*        authUserId;  // Authenticated user ID (for all kinds)
+        char*        authToken;   // Authentication token if issued (for all kinds)
+        char*        name;        // Name of the method/sync query
+                                  //    (METHOD_CALL, START_SYNC, END_SYNC, DECLARE_QUEUE, BIND, UNBIND)
+        Object*      object;      // Object involved in method call (METHOD_CALL)
+        ObjectId*    objectId;    // ObjectId for method call (METHOD_CALL)
+        Query*       query;       // Query parameters (GET_QUERY, START_SYNC)
+        Value*       arguments;   // Method parameters (METHOD_CALL)
+        char*        exchange;    // Exchange for bind (BIND, UNBIND)
+        char*        bindingKey;  // Key for bind (BIND, UNBIND)
+        SchemaObjectClass* objectClass; // (METHOD_CALL)
+    };
+
+    class AgentImpl;
+
+    /**
+     * Agent - Protocol engine for the QMF agent
+     */
+    class Agent {
+    public:
+        Agent(char* label, bool internalStore=true);
+        ~Agent();
+
+        /**
+         * Configure the directory path for storing persistent data.
+         *@param path Null-terminated string containing a directory path where files can be
+         *            created, written, and read.  If NULL, no persistent storage will be
+         *            attempted.
+         */
+        void setStoreDir(char* path);
+
+        /**
+         * Configure the directory path for files transferred over QMF.
+         *@param path Null-terminated string containing a directory path where files can be
+         *            created, deleted, written, and read.  If NULL, file transfers shall not
+         *            be permitted.
+         */
+        void setTransferDir(char* path);
+
+        /**
+         * Pass messages received from the AMQP session to the Agent engine.
+         *@param message AMQP messages received on the agent session.
+         */
+        void handleRcvMessage(Message& message);
+
+        /**
+         * Get the next message to be sent to the AMQP network.
+         *@param item The Message structure describing the message to be produced.
+         *@return true if the Message is valid, false if there are no messages to send.
+         */
+        bool getXmtMessage(Message& item);
+
+        /**
+         * Remove and discard one message from the head of the transmit queue.
+         */
+        void popXmt();
+
+        /**
+         * Get the next application event from the agent engine.
+         *@param event The event iff the return value is true
+         *@return true if event is valid, false if there are no events to process
+         */
+        bool getEvent(AgentEvent& event);
+
+        /**
+         * Remove and discard one event from the head of the event queue.
+         */
+        void popEvent();
+
+        /**
+         * A new AMQP session has been established for Agent communication.
+         */
+        void newSession();
+
+        /**
+         * Start the QMF Agent protocol.  This should be invoked after a SETUP_COMPLETE event
+         * is received from the Agent engine.
+         */
+        void startProtocol();
+
+        /**
+         * This method is called periodically so the agent can supply a heartbeat.
+         */
+        void heartbeat();
+
+        /**
+         * Respond to a method request.
+         *@param sequence  The sequence number from the method request event.
+         *@param status    The method's completion status.
+         *@param text      Status text ("OK" or an error message)
+         *@param arguments The list of output arguments from the method call.
+         */
+        void methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments);
+
+        /**
+         * Send a content indication to the QMF bus.  This is only needed for objects that are
+         * managed by the application.  This is *NOT* needed for objects managed by the Agent
+         * (inserted using addObject).
+         *@param sequence The sequence number of the GET request or the SYNC_START request.
+         *@param object   The object (annotated with "changed" flags) for publication.
+         *@param prop     If true, changed object properties are transmitted.
+         *@param stat     If true, changed object statistics are transmitted.
+         */
+        void queryResponse(uint32_t sequence, Object& object, bool prop = true, bool stat = true);
+
+        /**
+         * Indicate the completion of a query.  This is not used for SYNC_START requests.
+         *@param sequence The sequence number of the GET request.
+         */
+        void queryComplete(uint32_t sequence);
+
+        /**
+         * Register a schema class with the Agent.
+         *@param cls A SchemaObejctClass 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);
+
+        /**
+         * Give an object to the Agent for storage and management.  Once added, the agent takes
+         * responsibility for the life cycle of the object.
+         *@param obj       The object to be managed by the Agent.
+         *@param persistId A unique non-zero value if the object-id is to be persistent.
+         *@return The objectId of the managed object.
+         */
+        const ObjectId* addObject(Object& obj, uint64_t persistId);
+
+        /**
+         * Allocate an objecc-id for an object that will be managed by the application.
+         *@param persistId A unique non-zero value if the object-id is to be persistent.
+         @return The objectId structure for the allocated ID.
+         */
+        const ObjectId* allocObjectId(uint64_t persistId);
+        const ObjectId* allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi);
+
+        /**
+         * Raise an event into the QMF network..
+         *@param event The event object for the event to be raised.
+         */
+        void raiseEvent(Event& event);
+
+    private:
+        AgentImpl* impl;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/Console.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Console.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Console.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Console.h Fri May 22 21:40:57 2009
@@ -0,0 +1,82 @@
+#ifndef _QmfConsole_
+#define _QmfConsole_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/ManagedConnection.h>
+#include <qmf/Agent.h>
+#include <qmf/Broker.h>
+#include <qmf/Package.h>
+#include <qmf/SchemaClassTable.h>
+#include <qmf/Object.h>
+#include <qmf/ConsoleHandler.h>
+#include <set>
+#include <vector>
+#include <string>
+
+namespace qmf {
+
+    struct ConsoleSettings {
+        bool rcvObjects;
+        bool rcvEvents;
+        bool rcvHeartbeats;
+        bool userBindings;
+        uint32_t methodTimeout;
+        uint32_t getTimeout;
+
+        ConsoleSettings() :
+            rcvObjects(true),
+            rcvEvents(true),
+            rcvHeartbeats(true),
+            userBindings(false),
+            methodTimeout(20),
+            getTimeout(20) {}
+    };
+
+    class Console {
+    public:
+        Console(ConsoleHandler* handler = 0, ConsoleSettings settings = ConsoleSettings());
+        ~Console();
+
+        Broker* addConnection(ManagedConnection& connection);
+        void delConnection(Broker* broker);
+        void delConnection(ManagedConnection& connection);
+
+        const PackageMap& getPackages() const;
+
+        void bindPackage(const Package& package);
+        void bindPackage(const std::string& packageName);
+        void bindClass(const SchemaClass& otype);
+        void bindClass(const std::string& packageName, const std::string& className);
+
+        void getAgents(std::set<Agent>& agents, Broker* = 0);
+        void getObjects(std::vector<Object>& objects, const std::string& typeName,
+                        const std::string& packageName = "",
+                        Broker* broker = 0,
+                        Agent* agent = 0);
+        void getObjects(std::vector<Object>& objects,
+                        const std::map<std::string, std::string>& query,
+                        Broker* broker = 0,
+                        Agent* agent = 0);
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/Event.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Event.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Event.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Event.h Fri May 22 21:40:57 2009
@@ -0,0 +1,30 @@
+#ifndef _QmfEvent_
+#define _QmfEvent_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+namespace qmf {
+
+    class Event {
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/Message.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Message.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Message.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Message.h Fri May 22 21:40:57 2009
@@ -0,0 +1,39 @@
+#ifndef _QmfMessage_
+#define _QmfMessage_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <string>
+
+namespace qmf {
+
+    struct Message {
+        char*    body;
+        uint32_t length;
+        char*    destination;
+        char*    routingKey;
+        char*    replyExchange;
+        char*    replyKey;
+        char*    userId;
+    };
+
+}
+
+#endif

Added: qpid/trunk/qpid/cpp/src/qmf/MessageImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/MessageImpl.cpp?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/MessageImpl.cpp (added)
+++ qpid/trunk/qpid/cpp/src/qmf/MessageImpl.cpp Fri May 22 21:40:57 2009
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "MessageImpl.h"
+#include <string.h>
+
+using namespace std;
+using namespace qmf;
+
+#define STRING_REF(s) {if (!s.empty()) item.s = const_cast<char*>(s.c_str());}
+
+Message MessageImpl::copy()
+{
+    Message item;
+
+    ::memset(&item, 0, sizeof(Message));
+    item.body   = const_cast<char*>(body.c_str());
+    item.length = body.length();
+    STRING_REF(destination);
+    STRING_REF(routingKey);
+    STRING_REF(replyExchange);
+    STRING_REF(replyKey);
+    STRING_REF(userId);
+
+    return item;
+}
+

Added: qpid/trunk/qpid/cpp/src/qmf/MessageImpl.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/MessageImpl.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/MessageImpl.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/MessageImpl.h Fri May 22 21:40:57 2009
@@ -0,0 +1,42 @@
+#ifndef _QmfMessageImpl_
+#define _QmfMessageImpl_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "Message.h"
+#include <string>
+#include <boost/shared_ptr.hpp>
+
+namespace qmf {
+
+    struct MessageImpl {
+        typedef boost::shared_ptr<MessageImpl> Ptr;
+        std::string body;
+        std::string destination;
+        std::string routingKey;
+        std::string replyExchange;
+        std::string replyKey;
+        std::string userId;
+
+        Message copy();
+    };
+}
+
+#endif

Added: qpid/trunk/qpid/cpp/src/qmf/Object.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Object.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Object.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Object.h Fri May 22 21:40:57 2009
@@ -0,0 +1,47 @@
+#ifndef _QmfObject_
+#define _QmfObject_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/Schema.h>
+#include <qmf/ObjectId.h>
+#include <qmf/Value.h>
+
+namespace qmf {
+
+    class ObjectImpl;
+    class Object {
+    public:
+        Object(const SchemaObjectClass* type);
+        Object(ObjectImpl* impl);
+        ~Object();
+
+        void destroy();
+        const ObjectId* getObjectId() const;
+        void setObjectId(ObjectId* oid);
+        const SchemaObjectClass* getClass() const;
+        Value* getValue(char* key);
+
+        ObjectImpl* impl;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/ObjectId.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ObjectId.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ObjectId.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/ObjectId.h Fri May 22 21:40:57 2009
@@ -0,0 +1,53 @@
+#ifndef _QmfObjectId_
+#define _QmfObjectId_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <stdint.h>
+
+namespace qmf {
+
+    // TODO: Add to/from string and << operator
+
+    class ObjectIdImpl;
+    class ObjectId {
+    public:
+        ObjectId();
+        ObjectId(ObjectIdImpl* impl);
+        ~ObjectId();
+
+        uint64_t getObjectNum() const;
+        uint32_t getObjectNumHi() const;
+        uint32_t getObjectNumLo() const;
+        bool isDurable() const;
+
+        bool operator==(const ObjectId& other) const;
+        bool operator!=(const ObjectId& other) const;
+        bool operator<(const ObjectId& other) const;
+        bool operator>(const ObjectId& other) const;
+        bool operator<=(const ObjectId& other) const;
+        bool operator>=(const ObjectId& other) const;
+
+        ObjectIdImpl* impl;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.cpp?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.cpp (added)
+++ qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.cpp Fri May 22 21:40:57 2009
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "ObjectIdImpl.h"
+#include <stdlib.h>
+
+using namespace std;
+using namespace qmf;
+using qpid::framing::Buffer;
+
+
+void AgentAttachment::setBanks(uint32_t broker, uint32_t agent)
+{
+    first =
+        ((uint64_t) (broker & 0x000fffff)) << 28 |
+        ((uint64_t) (agent  & 0x0fffffff));
+}
+
+ObjectIdImpl::ObjectIdImpl(Buffer& buffer) : envelope(new ObjectId(this)), agent(0)
+{
+    decode(buffer);
+}
+
+ObjectIdImpl::ObjectIdImpl(AgentAttachment* a, uint8_t flags, uint16_t seq, uint64_t object) :
+    envelope(new ObjectId(this)), agent(a)
+{
+    first =
+        ((uint64_t) (flags &   0x0f)) << 60 |
+        ((uint64_t) (seq   & 0x0fff)) << 48;
+    second = object;
+}
+
+void ObjectIdImpl::decode(Buffer& buffer)
+{
+    first = buffer.getLongLong();
+    second = buffer.getLongLong();
+}
+
+void ObjectIdImpl::encode(Buffer& buffer) const
+{
+    if (agent == 0)
+        buffer.putLongLong(first);
+    else
+        buffer.putLongLong(first | agent->first);
+    buffer.putLongLong(second);
+}
+
+void ObjectIdImpl::fromString(const std::string& repr)
+{
+#define FIELDS 5
+#if defined (_WIN32) && !defined (atoll)
+#  define atoll(X) _atoi64(X)
+#endif
+
+    std::string copy(repr.c_str());
+    char* cText;
+    char* field[FIELDS];
+    bool  atFieldStart = true;
+    int   idx = 0;
+
+    cText = const_cast<char*>(copy.c_str());
+    for (char* cursor = cText; *cursor; cursor++) {
+        if (atFieldStart) {
+            if (idx >= FIELDS)
+                return; // TODO error
+            field[idx++] = cursor;
+            atFieldStart = false;
+        } else {
+            if (*cursor == '-') {
+                *cursor = '\0';
+                atFieldStart = true;
+            }
+        }
+    }
+
+    if (idx != FIELDS)
+        return;  // TODO error
+
+    first = (atoll(field[0]) << 60) +
+        (atoll(field[1]) << 48) +
+        (atoll(field[2]) << 28) +
+        atoll(field[3]);
+    second = atoll(field[4]);
+    agent = 0;
+}
+
+bool ObjectIdImpl::operator==(const ObjectIdImpl& other) const
+{
+    uint64_t otherFirst = agent == 0 ? other.first : other.first & 0xffff000000000000LL;
+
+    return first == otherFirst && second == other.second;
+}
+
+bool ObjectIdImpl::operator<(const ObjectIdImpl& other) const
+{
+    uint64_t otherFirst = agent == 0 ? other.first : other.first & 0xffff000000000000LL;
+
+    return (first < otherFirst) || ((first == otherFirst) && (second < other.second));
+}
+
+bool ObjectIdImpl::operator>(const ObjectIdImpl& other) const
+{
+    uint64_t otherFirst = agent == 0 ? other.first : other.first & 0xffff000000000000LL;
+
+    return (first > otherFirst) || ((first == otherFirst) && (second > other.second));
+}
+
+
+//==================================================================
+// Wrappers
+//==================================================================
+
+ObjectId::ObjectId()
+{
+    impl = new ObjectIdImpl(this);
+}
+
+ObjectId::ObjectId(ObjectIdImpl* i)
+{
+    impl = i;
+}
+
+ObjectId::~ObjectId()
+{
+    delete impl;
+}
+
+uint64_t ObjectId::getObjectNum() const
+{
+    return impl->getObjectNum();
+}
+
+uint32_t ObjectId::getObjectNumHi() const
+{
+    return impl->getObjectNumHi();
+}
+
+uint32_t ObjectId::getObjectNumLo() const
+{
+    return impl->getObjectNumLo();
+}
+
+bool ObjectId::isDurable() const
+{
+    return impl->isDurable();
+}
+
+bool ObjectId::operator==(const ObjectId& other) const
+{
+    return *impl == *other.impl;
+}
+
+bool ObjectId::operator!=(const ObjectId& other) const
+{
+    return !(*impl == *other.impl);
+}
+
+bool ObjectId::operator<(const ObjectId& other) const
+{
+    return *impl < *other.impl;
+}
+
+bool ObjectId::operator>(const ObjectId& other) const
+{
+    return *impl > *other.impl;
+}
+
+bool ObjectId::operator<=(const ObjectId& other) const
+{
+    return !(*impl > *other.impl);
+}
+
+bool ObjectId::operator>=(const ObjectId& other) const
+{
+    return !(*impl < *other.impl);
+}

Added: qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/ObjectIdImpl.h Fri May 22 21:40:57 2009
@@ -0,0 +1,66 @@
+#ifndef _QmfObjectIdImpl_
+#define _QmfObjectIdImpl_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/ObjectId.h>
+#include <qpid/framing/Buffer.h>
+
+namespace qmf {
+
+    struct AgentAttachment {
+        uint64_t first;
+
+        AgentAttachment() : first(0) {}
+        void setBanks(uint32_t broker, uint32_t bank);
+        uint64_t getFirst() const { return first; }
+    };
+
+    struct ObjectIdImpl {
+        ObjectId* envelope;
+        AgentAttachment* agent;
+        uint64_t first;
+        uint64_t second;
+
+        ObjectIdImpl(ObjectId* e) : envelope(e), agent(0) {}
+        ObjectIdImpl(qpid::framing::Buffer& buffer);
+        ObjectIdImpl(AgentAttachment* agent, uint8_t flags, uint16_t seq, uint64_t object);
+
+        void decode(qpid::framing::Buffer& buffer);
+        void encode(qpid::framing::Buffer& buffer) const;
+        void fromString(const std::string& repr);
+        uint8_t getFlags() const { return (first & 0xF000000000000000LL) >> 60; }
+        uint16_t getSequence() const { return (first & 0x0FFF000000000000LL) >> 48; }
+        uint32_t getBrokerBank() const { return (first & 0x0000FFFFF0000000LL) >> 28; }
+        uint32_t getAgentBank() const { return first & 0x000000000FFFFFFFLL; }
+        uint64_t getObjectNum() const { return second; }
+        uint32_t getObjectNumHi() const { return (uint32_t) (second >> 32); }
+        uint32_t getObjectNumLo() const { return (uint32_t) (second & 0x00000000FFFFFFFFLL); }
+        bool isDurable() const { return getSequence() == 0; }
+        void setValue(uint64_t f, uint64_t s) { first = f; second = s; }
+
+        bool operator==(const ObjectIdImpl& other) const;
+        bool operator<(const ObjectIdImpl& other) const;
+        bool operator>(const ObjectIdImpl& other) const;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.cpp?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.cpp (added)
+++ qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.cpp Fri May 22 21:40:57 2009
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "ObjectImpl.h"
+#include "ValueImpl.h"
+#include <qpid/sys/Time.h>
+
+using namespace std;
+using namespace qmf;
+using namespace qpid::sys;
+using qpid::framing::Buffer;
+
+ObjectImpl::ObjectImpl(Object* e, const SchemaObjectClass* type) :
+    envelope(e), objectClass(type), createTime(uint64_t(Duration(now()))),
+    destroyTime(0), lastUpdatedTime(createTime)
+{
+    int propCount = objectClass->getPropertyCount();
+    int statCount = objectClass->getStatisticCount();
+    int idx;
+
+    for (idx = 0; idx < propCount; idx++) {
+        const SchemaProperty* prop = objectClass->getProperty(idx);
+        properties[prop->getName()] = ValuePtr(new Value(prop->getType()));
+    }
+
+    for (idx = 0; idx < statCount; idx++) {
+        const SchemaStatistic* stat = objectClass->getStatistic(idx);
+        statistics[stat->getName()] = ValuePtr(new Value(stat->getType()));
+    }
+}
+
+ObjectImpl::ObjectImpl(const SchemaObjectClass* type, Buffer& buffer) :
+    envelope(new Object(this)), objectClass(type), createTime(uint64_t(Duration(now()))),
+    destroyTime(0), lastUpdatedTime(createTime)
+{
+    int propCount = objectClass->getPropertyCount();
+    int statCount = objectClass->getStatisticCount();
+    int idx;
+    set<string> excludes;
+
+    parsePresenceMasks(buffer, excludes);
+    for (idx = 0; idx < propCount; idx++) {
+        const SchemaProperty* prop = objectClass->getProperty(idx);
+        if (excludes.count(prop->getName()) != 0) {
+            properties[prop->getName()] = ValuePtr(new Value(prop->getType()));
+        } else {
+            ValueImpl* pval = new ValueImpl(prop->getType(), buffer);
+            properties[prop->getName()] = ValuePtr(pval->envelope);
+        }
+    }
+
+    for (idx = 0; idx < statCount; idx++) {
+        const SchemaStatistic* stat = objectClass->getStatistic(idx);
+        ValueImpl* sval = new ValueImpl(stat->getType(), buffer);
+        statistics[stat->getName()] = ValuePtr(sval->envelope);
+    }
+}
+
+ObjectImpl::~ObjectImpl()
+{
+}
+
+void ObjectImpl::destroy()
+{
+    destroyTime = uint64_t(Duration(now()));
+    // TODO - flag deletion
+}
+
+Value* ObjectImpl::getValue(const string& key)
+{
+    map<string, ValuePtr>::const_iterator iter;
+
+    iter = properties.find(key);
+    if (iter != properties.end())
+        return iter->second.get();
+
+    iter = statistics.find(key);
+    if (iter != statistics.end())
+        return iter->second.get();
+
+    return 0;
+}
+
+void ObjectImpl::parsePresenceMasks(Buffer& buffer, set<string>& excludeList)
+{
+    int propCount = objectClass->getPropertyCount();
+    excludeList.clear();
+    uint8_t bit = 0;
+    uint8_t mask = 0;
+
+    for (int idx = 0; idx < propCount; idx++) {
+        const SchemaProperty* prop = objectClass->getProperty(idx);
+        if (prop->isOptional()) {
+            if (bit == 0) {
+                mask = buffer.getOctet();
+                bit = 1;
+            }
+            if ((mask & bit) == 0)
+                excludeList.insert(string(prop->getName()));
+            if (bit == 0x80)
+                bit = 0;
+            else
+                bit = bit << 1;
+        }
+    }
+}
+
+void ObjectImpl::encodeSchemaKey(qpid::framing::Buffer& buffer) const
+{
+    buffer.putShortString(objectClass->getPackage());
+    buffer.putShortString(objectClass->getName());
+    buffer.putBin128(const_cast<uint8_t*>(objectClass->getHash()));
+}
+
+void ObjectImpl::encodeManagedObjectData(qpid::framing::Buffer& buffer) const
+{
+    buffer.putLongLong(lastUpdatedTime);
+    buffer.putLongLong(createTime);
+    buffer.putLongLong(destroyTime);
+    objectId->impl->encode(buffer);
+}
+
+void ObjectImpl::encodeProperties(qpid::framing::Buffer& buffer) const
+{
+    int propCount = objectClass->getPropertyCount();
+    uint8_t bit = 0;
+    uint8_t mask = 0;
+    ValuePtr value;
+
+    for (int idx = 0; idx < propCount; idx++) {
+        const SchemaProperty* prop = objectClass->getProperty(idx);
+        if (prop->isOptional()) {
+            value = properties[prop->getName()];
+            if (bit == 0)
+                bit = 1;
+            if (!value->isNull())
+                mask |= bit;
+            if (bit == 0x80) {
+                buffer.putOctet(mask);
+                bit = 0;
+                mask = 0;
+            } else
+                bit = bit << 1;
+        }
+    }
+    if (bit != 0) {
+        buffer.putOctet(mask);
+    }
+
+    for (int idx = 0; idx < propCount; idx++) {
+        const SchemaProperty* prop = objectClass->getProperty(idx);
+        value = properties[prop->getName()];
+        if (!prop->isOptional() || !value->isNull()) {
+            value->impl->encode(buffer);
+        }
+    }
+}
+
+void ObjectImpl::encodeStatistics(qpid::framing::Buffer& buffer) const
+{
+    int statCount = objectClass->getStatisticCount();
+    for (int idx = 0; idx < statCount; idx++) {
+        const SchemaStatistic* stat = objectClass->getStatistic(idx);
+        ValuePtr value = statistics[stat->getName()];
+        value->impl->encode(buffer);
+    }
+}
+
+//==================================================================
+// Wrappers
+//==================================================================
+
+Object::Object(const SchemaObjectClass* type) : impl(new ObjectImpl(this, type)) {}
+
+Object::Object(ObjectImpl* i) : impl(i) {}
+
+Object::~Object()
+{
+    delete impl;
+}
+
+void Object::destroy()
+{
+    impl->destroy();
+}
+
+const ObjectId* Object::getObjectId() const
+{
+    return impl->getObjectId();
+}
+
+void Object::setObjectId(ObjectId* oid)
+{
+    impl->setObjectId(oid);
+}
+
+const SchemaObjectClass* Object::getClass() const
+{
+    return impl->getClass();
+}
+
+Value* Object::getValue(char* key)
+{
+    return impl->getValue(key);
+}
+

Added: qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/ObjectImpl.h Fri May 22 21:40:57 2009
@@ -0,0 +1,62 @@
+#ifndef _QmfObjectImpl_
+#define _QmfObjectImpl_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/Object.h>
+#include <map>
+#include <set>
+#include <string>
+#include <qpid/framing/Buffer.h>
+#include <boost/shared_ptr.hpp>
+
+namespace qmf {
+
+    struct ObjectImpl {
+        typedef boost::shared_ptr<Value> ValuePtr;
+        Object* envelope;
+        const SchemaObjectClass* objectClass;
+        boost::shared_ptr<ObjectId> objectId;
+        uint64_t createTime;
+        uint64_t destroyTime;
+        uint64_t lastUpdatedTime;
+        mutable std::map<std::string, ValuePtr> properties;
+        mutable std::map<std::string, ValuePtr> statistics;
+
+        ObjectImpl(Object* e, const SchemaObjectClass* type);
+        ObjectImpl(const SchemaObjectClass* type, qpid::framing::Buffer& buffer);
+        ~ObjectImpl();
+
+        void destroy();
+        const ObjectId* getObjectId() const { return objectId.get(); }
+        void setObjectId(ObjectId* oid) { objectId.reset(oid); }
+        const SchemaObjectClass* getClass() const { return objectClass; }
+        Value* getValue(const std::string& key);
+
+        void parsePresenceMasks(qpid::framing::Buffer& buffer, std::set<std::string>& excludeList);
+        void encodeSchemaKey(qpid::framing::Buffer& buffer) const;
+        void encodeManagedObjectData(qpid::framing::Buffer& buffer) const;
+        void encodeProperties(qpid::framing::Buffer& buffer) const;
+        void encodeStatistics(qpid::framing::Buffer& buffer) const;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/Query.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/Query.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/Query.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/Query.h Fri May 22 21:40:57 2009
@@ -0,0 +1,54 @@
+#ifndef _QmfQuery_
+#define _QmfQuery_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/ObjectId.h>
+#include <qmf/Value.h>
+
+namespace qmf {
+
+    class QueryImpl;
+    class Query {
+    public:
+        Query();
+        Query(QueryImpl* impl);
+        ~Query();
+
+        const char* getPackage() const;
+        const char* getClass() const;
+        const ObjectId* getObjectId() const;
+
+        enum Oper {
+            OPER_AND = 1,
+            OPER_OR  = 2
+        };
+
+        int whereCount() const;
+        Oper whereOper() const;
+        const char* whereKey() const;
+        const Value* whereValue() const;
+
+        QueryImpl* impl;
+    };
+}
+
+#endif
+

Added: qpid/trunk/qpid/cpp/src/qmf/QueryImpl.cpp
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/QueryImpl.cpp?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/QueryImpl.cpp (added)
+++ qpid/trunk/qpid/cpp/src/qmf/QueryImpl.cpp Fri May 22 21:40:57 2009
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "QueryImpl.h"
+
+using namespace std;
+using namespace qmf;
+
+//==================================================================
+// Wrappers
+//==================================================================
+
+Query::Query() : impl(new QueryImpl(this)) {}
+Query::Query(QueryImpl* i) : impl(i) {}
+
+Query::~Query()
+{
+    delete impl;
+}
+
+const char* Query::getPackage() const
+{
+    return impl->getPackage();
+}
+
+const char* Query::getClass() const
+{
+    return impl->getClass();
+}
+
+const ObjectId* Query::getObjectId() const
+{
+    return impl->getObjectId();
+}
+
+int Query::whereCount() const
+{
+    return impl->whereCount();
+}
+
+Query::Oper Query::whereOper() const
+{
+    return impl->whereOper();
+}
+
+const char* Query::whereKey() const
+{
+    return impl->whereKey();
+}
+
+const Value* Query::whereValue() const
+{
+    return impl->whereValue();
+}
+

Added: qpid/trunk/qpid/cpp/src/qmf/QueryImpl.h
URL: http://svn.apache.org/viewvc/qpid/trunk/qpid/cpp/src/qmf/QueryImpl.h?rev=777720&view=auto
==============================================================================
--- qpid/trunk/qpid/cpp/src/qmf/QueryImpl.h (added)
+++ qpid/trunk/qpid/cpp/src/qmf/QueryImpl.h Fri May 22 21:40:57 2009
@@ -0,0 +1,48 @@
+#ifndef _QmfQueryImpl_
+#define _QmfQueryImpl_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <qmf/Query.h>
+#include <string>
+#include <boost/shared_ptr.hpp>
+
+namespace qmf {
+
+    struct QueryImpl {
+        Query* envelope;
+        std::string packageName;
+        std::string className;
+        boost::shared_ptr<ObjectId> oid;
+
+        QueryImpl(Query* e) : envelope(e) {}
+
+        const char* getPackage() const { return packageName.empty() ? 0 : packageName.c_str(); }
+        const char* getClass() const { return className.empty() ? 0 : className.c_str(); }
+        const ObjectId* getObjectId() const { return oid.get(); }
+
+        int whereCount() const { return 0;}
+        Query::Oper whereOper() const { return Query::OPER_AND; }
+        const char* whereKey() const { return 0; }
+        const Value* whereValue() const { return 0; }
+    };
+}
+
+#endif



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