1 files changed, 147 insertions, 31 deletions

diff --git a/cpp/src/qmf/ConsoleEngine.h b/cpp/src/qmf/ConsoleEngine.h
index 823e281b14..4ee52f6114 100644
--- a/cpp/src/qmf/ConsoleEngine.h
+++ b/cpp/src/qmf/ConsoleEngine.h
@@ -20,62 +20,178 @@
  * under the License.
  */
 
-#include <qmf/ManagedConnection.h>
-#include <qmf/Broker.h>
-#include <qmf/Package.h>
-#include <qmf/SchemaClassTable.h>
+#include <qmf/ResilientConnection.h>
+#include <qmf/Schema.h>
+#include <qmf/ObjectId.h>
 #include <qmf/Object.h>
-#include <qmf/ConsoleHandler.h>
-#include <set>
-#include <vector>
-#include <string>
+#include <qmf/Event.h>
+#include <qmf/Query.h>
+#include <qmf/Value.h>
+#include <qmf/Message.h>
 
 namespace qmf {
 
+    class ConsoleEngine;
+    class ConsoleEngineImpl;
+    class BrokerProxyImpl;
+    class AgentProxy;
+    class AgentProxyImpl;
+    class MethodResponseImpl;
+
+    /**
+     *
+     */
+    class MethodResponse {
+    public:
+        MethodResponse(MethodResponseImpl* impl);
+        ~MethodResponse();
+        uint32_t getStatus() const;
+        const Value* getException() const;
+        const Value* getArgs() const;
+
+    private:
+        friend class ConsoleEngineImpl;
+        MethodResponseImpl* impl;
+    };
+
+    /**
+     *
+     */
+    struct ConsoleEvent {
+        enum EventKind {
+            AGENT_ADDED     = 1,
+            AGENT_DELETED   = 2,
+            NEW_PACKAGE     = 3,
+            NEW_CLASS       = 4,
+            OBJECT_UPDATE   = 5,
+            QUERY_COMPLETE  = 6,
+            EVENT_RECEIVED  = 7,
+            AGENT_HEARTBEAT = 8,
+            METHOD_RESPONSE = 9
+        };
+
+        EventKind       kind;
+        AgentProxy*     agent;          // (AGENT_[ADDED|DELETED|HEARTBEAT])
+        char*           name;           // (NEW_PACKAGE)
+        SchemaClassKey* classKey;       // (NEW_CLASS)
+        Object*         object;         // (OBJECT_UPDATE)
+        void*           context;        // (OBJECT_UPDATE, QUERY_COMPLETE)
+        Event*          event;          // (EVENT_RECEIVED)
+        uint64_t        timestamp;      // (AGENT_HEARTBEAT)
+        uint32_t        methodHandle;   // (METHOD_RESPONSE)
+        MethodResponse* methodResponse; // (METHOD_RESPONSE)
+    };
+
+    /**
+     *
+     */
+    struct BrokerEvent {
+        enum EventKind {
+            BROKER_INFO     = 10,
+            DECLARE_QUEUE   = 11,
+            DELETE_QUEUE    = 12,
+            BIND            = 13,
+            UNBIND          = 14,
+            SETUP_COMPLETE  = 15
+        };
+
+        EventKind kind;
+        char*     name;       // ([DECLARE|DELETE]_QUEUE, [UN]BIND)
+        char*     exchange;   // ([UN]BIND)
+        char*     bindingKey; // ([UN]BIND)
+    };
+
+    /**
+     *
+     */
+    class BrokerProxy {
+    public:
+        BrokerProxy(ConsoleEngine& console);
+        ~BrokerProxy();
+
+        void sessionOpened(SessionHandle& sh);
+        void sessionClosed();
+        void startProtocol();
+
+        void handleRcvMessage(Message& message);
+        bool getXmtMessage(Message& item) const;
+        void popXmt();
+
+        bool getEvent(BrokerEvent& event) const;
+        void popEvent();
+
+    private:
+        friend class ConsoleEngineImpl;
+        BrokerProxyImpl* impl;
+    };
+
+    /**
+     *
+     */
+    class AgentProxy {
+    public:
+        AgentProxy(ConsoleEngine& console);
+        ~AgentProxy();
+
+    private:
+        friend class ConsoleEngineImpl;
+        AgentProxyImpl* impl;
+    };
+
+    // TODO - move this to a public header
     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) {}
+            userBindings(false) {}
     };
 
     class ConsoleEngine {
     public:
-        ConsoleEngine(ConsoleHandler* handler = 0, ConsoleSettings settings = ConsoleSettings());
+        ConsoleEngine(const ConsoleSettings& settings = ConsoleSettings());
         ~ConsoleEngine();
 
-        Broker* addConnection(ManagedConnection& connection);
-        void delConnection(Broker* broker);
-        void delConnection(ManagedConnection& connection);
+        bool getEvent(ConsoleEvent& event) const;
+        void popEvent();
+
+        void addConnection(BrokerProxy& broker, void* context);
+        void delConnection(BrokerProxy& broker);
+
+        uint32_t packageCount() const;
+        const char* getPackageName(uint32_t idx) const;
+
+        uint32_t classCount(const char* packageName) const;
+        const SchemaClassKey* getClass(const char* packageName, uint32_t idx) const;
 
-        const PackageMap& getPackages() const;
+        ClassKind getClassKind(const SchemaClassKey& key) const;
+        const SchemaObjectClass* getObjectClass(const SchemaClassKey& key) const;
+        const SchemaEventClass* getEventClass(const SchemaClassKey& key) 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 bindPackage(const char* packageName);
+        void bindClass(const SchemaClassKey& key);
+        void bindClass(const char* packageName, const char* className);
+
+        uint32_t agentCount() const;
+        const AgentProxy* getAgent(uint32_t idx) const;
+
+        void sendQuery(const Query& query, void* context);
 
         /*
-        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);
+        void startSync(const Query& query, void* context, SyncQuery& sync);
+        void touchSync(SyncQuery& sync);
+        void endSync(SyncQuery& sync);
         */
+
+    private:
+        friend class BrokerProxyImpl;
+        friend class AgentProxyImpl;
+        ConsoleEngineImpl* impl;
     };
 }