2 files changed, 108 insertions, 12 deletions

diff --git a/cpp/broker/inc/Broker.h b/cpp/broker/inc/Broker.h
new file mode 100644
index 0000000000..0cd2bd749e
--- /dev/null
+++ b/cpp/broker/inc/Broker.h
@@ -0,0 +1,86 @@
+#ifndef _Broker_
+#define _Broker_
+
+/*
+ *
+ * Copyright (c) 2006 The Apache Software Foundation
+ *
+ * Licensed 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 "Acceptor.h"
+#include "Configuration.h"
+#include "Runnable.h"
+#include "SessionHandlerFactoryImpl.h"
+#include <boost/noncopyable.hpp>
+#include <tr1/memory>
+
+namespace qpid {
+    namespace broker {
+        /**
+         * A broker instance. 
+         */
+        class Broker : public qpid::concurrent::Runnable, private boost::noncopyable {
+            Broker(const Configuration& config); // Private, use create()
+            std::auto_ptr<qpid::io::Acceptor> acceptor;
+            SessionHandlerFactoryImpl factory;
+            int16_t port;
+            bool isBound;
+            
+          public:
+            static const int16_t DEFAULT_PORT;
+            
+            virtual ~Broker();
+            typedef std::tr1::shared_ptr<Broker> shared_ptr;
+
+            /**
+             * Create a broker.
+             * @param port Port to listen on or 0 to pick a port dynamically.
+             */
+            static shared_ptr create(int port = DEFAULT_PORT);
+
+            /**
+             * Create a broker from a Configuration.
+             */
+            static shared_ptr create(const Configuration& config);
+
+            /**
+             * Bind to the listening port.
+             * @return The port number bound. 
+             */
+            virtual int16_t bind();
+
+            /**
+             * Return listening port. If called before bind this is
+             * the configured port. If called after it is the actual
+             * port, which will be different if the configured port is
+             * 0.
+             */
+            virtual int16_t getPort() { return port; }
+            
+            /**
+             * Run the broker. Implements Runnable::run() so the broker
+             * can be run in a separate thread.
+             */
+            virtual void run();
+
+            /** Shut down the broker */
+            virtual void shutdown();
+        };
+    }
+}
+            
+
+
+#endif  /*!_Broker_*/
diff --git a/cpp/broker/inc/Configuration.h b/cpp/broker/inc/Configuration.h
index 5ec70a839b..aaabdd23a0 100644
--- a/cpp/broker/inc/Configuration.h
+++ b/cpp/broker/inc/Configuration.h
@@ -21,11 +21,12 @@
 #include <cstdlib>
 #include <iostream>
 #include <vector>
+#include "Exception.h"
 
 namespace qpid {
     namespace broker {
         class Configuration{
-            class Option{
+            class Option {
                 const std::string flag;
                 const std::string name;
                 const std::string desc;
@@ -56,6 +57,7 @@ namespace qpid {
                 int getValue() const;
                 virtual bool needsValue() const;
                 virtual void setValue(const std::string& value);
+                virtual void setValue(int _value) { value = _value; }
             };
 
             class StringOption : public Option{
@@ -82,6 +84,7 @@ namespace qpid {
                 bool getValue() const;
                 virtual bool needsValue() const;
                 virtual void setValue(const std::string& value);
+                virtual void setValue(bool _value) { value = _value; }
             };
 
             BoolOption trace;
@@ -96,10 +99,9 @@ namespace qpid {
             std::vector<Option*> options;
 
         public:
-            class ParseException{
-            public:
-                const std::string& error;
-                ParseException(const std::string& _error) : error(_error) {}
+            class ParseException : public Exception {
+              public:
+                ParseException(const std::string& msg) : Exception(msg) {}
             };
 
 
@@ -108,13 +110,21 @@ namespace qpid {
 
             void parse(int argc, char** argv);
 
-            bool isHelp();
-            bool isTrace();
-            int getPort();
-            int getWorkerThreads();
-            int getMaxConnections();
-            int getConnectionBacklog();
-            const std::string& getAcceptor();
+            bool isHelp() const;
+            bool isTrace() const;
+            int getPort() const;
+            int getWorkerThreads() const;
+            int getMaxConnections() const;
+            int getConnectionBacklog() const;
+            std::string getAcceptor() const;
+
+            void setHelp(bool b) { help.setValue(b); }
+            void setTrace(bool b) { trace.setValue(b); }
+            void setPort(int i) { port.setValue(i); }
+            void setWorkerThreads(int i) { workerThreads.setValue(i); }
+            void setMaxConnections(int i) { maxConnections.setValue(i); }
+            void setConnectionBacklog(int i) { connectionBacklog.setValue(i); }
+            void setAcceptor(const std::string& val) { acceptor.setValue(val); }
 
             void usage();
         };