Refactored the QMF engine to adhere to the following rules regarding

the pimpl (Pointer to Implementation) pattern:

1) Impl classes have constructors matching the public constructors
2) Additional Impl constructors are accessed through a static factory function
3) All linkages to objects are to the public object
4) If a back-link (from Impl to public) is needed, the Impl class must be
   derived from boost::noncopyable
5) All public classes have non-default copy constructors that make a copy of the
   Impl class



git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@816770 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 48 insertions, 12 deletions

diff --git a/qpid/cpp/src/qmf/Schema.h b/qpid/cpp/src/qmf/Schema.h
index 1123acc3b8..92801c40fe 100644
--- a/qpid/cpp/src/qmf/Schema.h
+++ b/qpid/cpp/src/qmf/Schema.h
@@ -42,7 +42,7 @@ namespace qmf {
     class SchemaArgument {
     public:
         SchemaArgument(const char* name, Typecode typecode);
-        SchemaArgument(SchemaArgumentImpl* impl);
+        SchemaArgument(const SchemaArgument& from);
         ~SchemaArgument();
         void setDirection(Direction dir);
         void setUnit(const char* val);
@@ -53,6 +53,11 @@ namespace qmf {
         const char* getUnit() const;
         const char* getDesc() const;
 
+    private:
+        friend class SchemaArgumentImpl;
+        friend class SchemaMethodImpl;
+        friend class SchemaEventClassImpl;
+        SchemaArgument(SchemaArgumentImpl* impl);
         SchemaArgumentImpl* impl;
     };
 
@@ -61,15 +66,20 @@ namespace qmf {
     class SchemaMethod {
     public:
         SchemaMethod(const char* name);
-        SchemaMethod(SchemaMethodImpl* impl);
+        SchemaMethod(const SchemaMethod& from);
         ~SchemaMethod();
-        void addArgument(const SchemaArgument& argument);
+        void addArgument(const SchemaArgument* argument);
         void setDesc(const char* desc);
         const char* getName() const;
         const char* getDesc() const;
         int getArgumentCount() const;
         const SchemaArgument* getArgument(int idx) const;
 
+    private:
+        friend class SchemaMethodImpl;
+        friend class SchemaObjectClassImpl;
+        friend class AgentEngineImpl;
+        SchemaMethod(SchemaMethodImpl* impl);
         SchemaMethodImpl* impl;
     };
 
@@ -78,7 +88,7 @@ namespace qmf {
     class SchemaProperty {
     public:
         SchemaProperty(const char* name, Typecode typecode);
-        SchemaProperty(SchemaPropertyImpl* impl);
+        SchemaProperty(const SchemaProperty& from);
         ~SchemaProperty();
         void setAccess(Access access);
         void setIndex(bool val);
@@ -93,6 +103,10 @@ namespace qmf {
         const char* getUnit() const;
         const char* getDesc() const;
 
+    private:
+        friend class SchemaPropertyImpl;
+        friend class SchemaObjectClassImpl;
+        SchemaProperty(SchemaPropertyImpl* impl);
         SchemaPropertyImpl* impl;
     };
 
@@ -101,7 +115,7 @@ namespace qmf {
     class SchemaStatistic {
     public:
         SchemaStatistic(const char* name, Typecode typecode);
-        SchemaStatistic(SchemaStatisticImpl* impl);
+        SchemaStatistic(const SchemaStatistic& from);
         ~SchemaStatistic();
         void setUnit(const char* val);
         void setDesc(const char* desc);
@@ -110,6 +124,10 @@ namespace qmf {
         const char* getUnit() const;
         const char* getDesc() const;
 
+    private:
+        friend class SchemaStatisticImpl;
+        friend class SchemaObjectClassImpl;
+        SchemaStatistic(SchemaStatisticImpl* impl);
         SchemaStatisticImpl* impl;
     };
 
@@ -117,13 +135,21 @@ namespace qmf {
      */
     class SchemaClassKey {
     public:
-        SchemaClassKey(SchemaClassKeyImpl* impl);
+        SchemaClassKey(const SchemaClassKey& from);
         ~SchemaClassKey();
 
         const char* getPackageName() const;
         const char* getClassName() const;
         const uint8_t* getHash() const;
 
+        bool operator==(const SchemaClassKey& other) const;
+        bool operator<(const SchemaClassKey& other) const;
+
+    private:
+        friend class SchemaClassKeyImpl;
+        friend class BrokerProxyImpl;
+        friend class ConsoleEngineImpl;
+        SchemaClassKey(SchemaClassKeyImpl* impl);
         SchemaClassKeyImpl* impl;
     };
 
@@ -132,11 +158,11 @@ namespace qmf {
     class SchemaObjectClass {
     public:
         SchemaObjectClass(const char* package, const char* name);
-        SchemaObjectClass(SchemaObjectClassImpl* impl);
+        SchemaObjectClass(const SchemaObjectClass& from);
         ~SchemaObjectClass();
-        void addProperty(const SchemaProperty& property);
-        void addStatistic(const SchemaStatistic& statistic);
-        void addMethod(const SchemaMethod& method);
+        void addProperty(const SchemaProperty* property);
+        void addStatistic(const SchemaStatistic* statistic);
+        void addMethod(const SchemaMethod* method);
 
         const SchemaClassKey* getClassKey() const;
         int getPropertyCount() const;
@@ -146,6 +172,11 @@ namespace qmf {
         const SchemaStatistic* getStatistic(int idx) const;
         const SchemaMethod* getMethod(int idx) const;
 
+    private:
+        friend class SchemaObjectClassImpl;
+        friend class BrokerProxyImpl;
+        friend class AgentEngineImpl;
+        SchemaObjectClass(SchemaObjectClassImpl* impl);
         SchemaObjectClassImpl* impl;
     };
 
@@ -154,15 +185,20 @@ namespace qmf {
     class SchemaEventClass {
     public:
         SchemaEventClass(const char* package, const char* name);
-        SchemaEventClass(SchemaEventClassImpl* impl);
+        SchemaEventClass(const SchemaEventClass& from);
         ~SchemaEventClass();
-        void addArgument(const SchemaArgument& argument);
+        void addArgument(const SchemaArgument* argument);
         void setDesc(const char* desc);
 
         const SchemaClassKey* getClassKey() const;
         int getArgumentCount() const;
         const SchemaArgument* getArgument(int idx) const;
 
+    private:
+        friend class SchemaEventClassImpl;
+        friend class BrokerProxyImpl;
+        friend class AgentEngineImpl;
+        SchemaEventClass(SchemaEventClassImpl* impl);
         SchemaEventClassImpl* impl;
     };
 }