QPID-2612: Fix to windows build from Chuck Rolke

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

13 files changed, 169 insertions, 169 deletions

diff --git a/cpp/include/qpid/messaging/Address.h b/cpp/include/qpid/messaging/Address.h
index 7bb821e644..2e36d0ae22 100644
--- a/cpp/include/qpid/messaging/Address.h
+++ b/cpp/include/qpid/messaging/Address.h
@@ -122,22 +122,22 @@ class AddressImpl;
 class Address
 {
   public:
-    QPID_CLIENT_EXTERN Address();
-    QPID_CLIENT_EXTERN Address(const std::string& address);
-    QPID_CLIENT_EXTERN Address(const std::string& name, const std::string& subject,
+    QPID_MESSAGING_EXTERN Address();
+    QPID_MESSAGING_EXTERN Address(const std::string& address);
+    QPID_MESSAGING_EXTERN Address(const std::string& name, const std::string& subject,
                                const qpid::types::Variant::Map& options, const std::string& type = "");
-    QPID_CLIENT_EXTERN Address(const Address& address);
-    QPID_CLIENT_EXTERN ~Address();
-    QPID_CLIENT_EXTERN Address& operator=(const Address&);
-    QPID_CLIENT_EXTERN const std::string& getName() const;
-    QPID_CLIENT_EXTERN void setName(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getSubject() const;
-    QPID_CLIENT_EXTERN void setSubject(const std::string&);
-    QPID_CLIENT_EXTERN const qpid::types::Variant::Map& getOptions() const;
-    QPID_CLIENT_EXTERN qpid::types::Variant::Map& getOptions();
-    QPID_CLIENT_EXTERN void setOptions(const qpid::types::Variant::Map&);
+    QPID_MESSAGING_EXTERN Address(const Address& address);
+    QPID_MESSAGING_EXTERN ~Address();
+    QPID_MESSAGING_EXTERN Address& operator=(const Address&);
+    QPID_MESSAGING_EXTERN const std::string& getName() const;
+    QPID_MESSAGING_EXTERN void setName(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getSubject() const;
+    QPID_MESSAGING_EXTERN void setSubject(const std::string&);
+    QPID_MESSAGING_EXTERN const qpid::types::Variant::Map& getOptions() const;
+    QPID_MESSAGING_EXTERN qpid::types::Variant::Map& getOptions();
+    QPID_MESSAGING_EXTERN void setOptions(const qpid::types::Variant::Map&);
 
-    QPID_CLIENT_EXTERN std::string getType() const;
+    QPID_MESSAGING_EXTERN std::string getType() const;
     /**
      * The type of and addressed node influences how receivers and
      * senders are constructed for it. It also affects how a reply-to
@@ -146,16 +146,16 @@ class Address
      * broker. The type can be explicitly set to prevent this if
      * needed.
      */
-    QPID_CLIENT_EXTERN void setType(const std::string&);
+    QPID_MESSAGING_EXTERN void setType(const std::string&);
 
-    QPID_CLIENT_EXTERN std::string str() const;
-    QPID_CLIENT_EXTERN operator bool() const;
-    QPID_CLIENT_EXTERN bool operator !() const;
+    QPID_MESSAGING_EXTERN std::string str() const;
+    QPID_MESSAGING_EXTERN operator bool() const;
+    QPID_MESSAGING_EXTERN bool operator !() const;
   private:
     AddressImpl* impl;
 };
 
-QPID_CLIENT_EXTERN std::ostream& operator<<(std::ostream& out, const Address& address);
+QPID_MESSAGING_EXTERN std::ostream& operator<<(std::ostream& out, const Address& address);
 
 }} // namespace qpid::messaging
 
diff --git a/cpp/include/qpid/messaging/Connection.h b/cpp/include/qpid/messaging/Connection.h
index bd13700e0e..a7f67cef8e 100644
--- a/cpp/include/qpid/messaging/Connection.h
+++ b/cpp/include/qpid/messaging/Connection.h
@@ -43,9 +43,9 @@ class Session;
 class Connection : public qpid::messaging::Handle<ConnectionImpl>
 {
   public:
-    QPID_CLIENT_EXTERN Connection(ConnectionImpl* impl);
-    QPID_CLIENT_EXTERN Connection(const Connection&);
-    QPID_CLIENT_EXTERN Connection();
+    QPID_MESSAGING_EXTERN Connection(ConnectionImpl* impl);
+    QPID_MESSAGING_EXTERN Connection(const Connection&);
+    QPID_MESSAGING_EXTERN Connection();
     /**  
      * Current implementation supports the following options:
      * 
@@ -75,29 +75,29 @@ class Connection : public qpid::messaging::Handle<ConnectionImpl>
      *     doubled every failure until the value of max-retry-interval
      *     is reached.
      */
-    QPID_CLIENT_EXTERN Connection(const std::string& url, const qpid::types::Variant::Map& options = qpid::types::Variant::Map());
+    QPID_MESSAGING_EXTERN Connection(const std::string& url, const qpid::types::Variant::Map& options = qpid::types::Variant::Map());
     /**
      * Creates a connection using an option string of the form
      * {name=value,name2=value2...}, see above for options supported.
      * 
      * @exception InvalidOptionString if the string does not match the correct syntax
      */
-    QPID_CLIENT_EXTERN Connection(const std::string& url, const std::string& options);
-    QPID_CLIENT_EXTERN ~Connection();
-    QPID_CLIENT_EXTERN Connection& operator=(const Connection&);
-    QPID_CLIENT_EXTERN void setOption(const std::string& name, const qpid::types::Variant& value);
-    QPID_CLIENT_EXTERN void open();
-    QPID_CLIENT_EXTERN bool isOpen();
+    QPID_MESSAGING_EXTERN Connection(const std::string& url, const std::string& options);
+    QPID_MESSAGING_EXTERN ~Connection();
+    QPID_MESSAGING_EXTERN Connection& operator=(const Connection&);
+    QPID_MESSAGING_EXTERN void setOption(const std::string& name, const qpid::types::Variant& value);
+    QPID_MESSAGING_EXTERN void open();
+    QPID_MESSAGING_EXTERN bool isOpen();
     /**
      * Closes a connection and all sessions associated with it. An
      * opened connection must be closed before the last handle is
      * allowed to go out of scope.
      */
-    QPID_CLIENT_EXTERN void close();
-    QPID_CLIENT_EXTERN Session createTransactionalSession(const std::string& name = std::string());
-    QPID_CLIENT_EXTERN Session createSession(const std::string& name = std::string());
+    QPID_MESSAGING_EXTERN void close();
+    QPID_MESSAGING_EXTERN Session createTransactionalSession(const std::string& name = std::string());
+    QPID_MESSAGING_EXTERN Session createSession(const std::string& name = std::string());
 
-    QPID_CLIENT_EXTERN Session getSession(const std::string& name) const;
+    QPID_MESSAGING_EXTERN Session getSession(const std::string& name) const;
   private:
   friend class qpid::messaging::PrivateImplRef<Connection>;
 
diff --git a/cpp/include/qpid/messaging/Duration.h b/cpp/include/qpid/messaging/Duration.h
index 3198ebe6a2..abcf169090 100644
--- a/cpp/include/qpid/messaging/Duration.h
+++ b/cpp/include/qpid/messaging/Duration.h
@@ -35,19 +35,19 @@ namespace messaging {
 class Duration
 {
   public:
-    QPID_CLIENT_EXTERN explicit Duration(uint64_t milliseconds);
-    QPID_CLIENT_EXTERN uint64_t getMilliseconds() const;
-    QPID_CLIENT_EXTERN static const Duration FOREVER;
-    QPID_CLIENT_EXTERN static const Duration IMMEDIATE;
-    QPID_CLIENT_EXTERN static const Duration SECOND;
-    QPID_CLIENT_EXTERN static const Duration MINUTE;
+    QPID_MESSAGING_EXTERN explicit Duration(uint64_t milliseconds);
+    QPID_MESSAGING_EXTERN uint64_t getMilliseconds() const;
+    QPID_MESSAGING_EXTERN static const Duration FOREVER;
+    QPID_MESSAGING_EXTERN static const Duration IMMEDIATE;
+    QPID_MESSAGING_EXTERN static const Duration SECOND;
+    QPID_MESSAGING_EXTERN static const Duration MINUTE;
   private:
     uint64_t milliseconds;
 };
 
-QPID_CLIENT_EXTERN Duration operator*(const Duration& duration,
+QPID_MESSAGING_EXTERN Duration operator*(const Duration& duration,
                                       uint64_t multiplier);
-QPID_CLIENT_EXTERN Duration operator*(uint64_t multiplier,
+QPID_MESSAGING_EXTERN Duration operator*(uint64_t multiplier,
                                       const Duration& duration);
 
 }} // namespace qpid::messaging
diff --git a/cpp/include/qpid/messaging/FailoverUpdates.h b/cpp/include/qpid/messaging/FailoverUpdates.h
index 1d4cfaa10d..fb9d106557 100644
--- a/cpp/include/qpid/messaging/FailoverUpdates.h
+++ b/cpp/include/qpid/messaging/FailoverUpdates.h
@@ -21,7 +21,7 @@
  * under the License.
  *
  */
-#include "qpid/client/ClientImportExport.h"
+#include "qpid/messaging/ImportExport.h"
 
 namespace qpid {
 namespace messaging {
@@ -35,8 +35,8 @@ class FailoverUpdatesImpl;
 class FailoverUpdates
 {
   public:
-    QPID_CLIENT_EXTERN FailoverUpdates(Connection& connection);
-    QPID_CLIENT_EXTERN ~FailoverUpdates();
+    QPID_MESSAGING_EXTERN FailoverUpdates(Connection& connection);
+    QPID_MESSAGING_EXTERN ~FailoverUpdates();
   private:
     FailoverUpdatesImpl* impl;
 
diff --git a/cpp/include/qpid/messaging/Handle.h b/cpp/include/qpid/messaging/Handle.h
index cfc6e8ebfc..1e634ef888 100644
--- a/cpp/include/qpid/messaging/Handle.h
+++ b/cpp/include/qpid/messaging/Handle.h
@@ -40,26 +40,26 @@ template <class T> class Handle {
   public:
 
     /**@return true if handle is valid,  i.e. not null. */
-    QPID_CLIENT_EXTERN bool isValid() const { return impl; }
+    QPID_MESSAGING_EXTERN bool isValid() const { return impl; }
 
     /**@return true if handle is null. It is an error to call any function on a null handle. */
-    QPID_CLIENT_EXTERN bool isNull() const { return !impl; }
+    QPID_MESSAGING_EXTERN bool isNull() const { return !impl; }
 
     /** Conversion to bool supports idiom if (handle) { handle->... } */
-    QPID_CLIENT_EXTERN operator bool() const { return impl; }
+    QPID_MESSAGING_EXTERN operator bool() const { return impl; }
 
     /** Operator ! supports idiom if (!handle) { do_if_handle_is_null(); } */
-    QPID_CLIENT_EXTERN bool operator !() const { return !impl; }
+    QPID_MESSAGING_EXTERN bool operator !() const { return !impl; }
 
     void swap(Handle<T>& h) { T* t = h.impl; h.impl = impl; impl = t; }
 
   protected:
     typedef T Impl;
-    QPID_CLIENT_EXTERN Handle() :impl() {}
+    QPID_MESSAGING_EXTERN Handle() :impl() {}
 
     // Not implemented,subclasses must implement.
-    QPID_CLIENT_EXTERN Handle(const Handle&);
-    QPID_CLIENT_EXTERN Handle& operator=(const Handle&);
+    QPID_MESSAGING_EXTERN Handle(const Handle&);
+    QPID_MESSAGING_EXTERN Handle& operator=(const Handle&);
 
     Impl* impl;
 
diff --git a/cpp/include/qpid/messaging/ImportExport.h b/cpp/include/qpid/messaging/ImportExport.h
index 7113b437be..52f3eb8568 100644
--- a/cpp/include/qpid/messaging/ImportExport.h
+++ b/cpp/include/qpid/messaging/ImportExport.h
@@ -21,13 +21,13 @@
  */
 
 #if defined(WIN32) && !defined(QPID_DECLARE_STATIC)
-#if defined(CLIENT_EXPORT) || defined (qpidclient_EXPORTS)
-#define QPID_CLIENT_EXTERN __declspec(dllexport)
+#if defined(CLIENT_EXPORT) || defined (qpidmessaging_EXPORTS)
+#define QPID_MESSAGING_EXTERN __declspec(dllexport)
 #else
-#define QPID_CLIENT_EXTERN __declspec(dllimport)
+#define QPID_MESSAGING_EXTERN __declspec(dllimport)
 #endif
 #else
-#define QPID_CLIENT_EXTERN
+#define QPID_MESSAGING_EXTERN
 #endif
 
 #endif  /*!QPID_MESSAGING_IMPORTEXPORT_H*/
diff --git a/cpp/include/qpid/messaging/Message.h b/cpp/include/qpid/messaging/Message.h
index 8e4c274734..ba58b5887c 100644
--- a/cpp/include/qpid/messaging/Message.h
+++ b/cpp/include/qpid/messaging/Message.h
@@ -42,64 +42,64 @@ struct MessageImpl;
 class Message
 {
   public:
-    QPID_CLIENT_EXTERN Message(const std::string& bytes = std::string());
-    QPID_CLIENT_EXTERN Message(const char*, size_t);
-    QPID_CLIENT_EXTERN Message(const Message&);
-    QPID_CLIENT_EXTERN ~Message();
+    QPID_MESSAGING_EXTERN Message(const std::string& bytes = std::string());
+    QPID_MESSAGING_EXTERN Message(const char*, size_t);
+    QPID_MESSAGING_EXTERN Message(const Message&);
+    QPID_MESSAGING_EXTERN ~Message();
 
-    QPID_CLIENT_EXTERN Message& operator=(const Message&);
+    QPID_MESSAGING_EXTERN Message& operator=(const Message&);
 
-    QPID_CLIENT_EXTERN void setReplyTo(const Address&);
-    QPID_CLIENT_EXTERN const Address& getReplyTo() const;
+    QPID_MESSAGING_EXTERN void setReplyTo(const Address&);
+    QPID_MESSAGING_EXTERN const Address& getReplyTo() const;
 
-    QPID_CLIENT_EXTERN void setSubject(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getSubject() const;
+    QPID_MESSAGING_EXTERN void setSubject(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getSubject() const;
 
-    QPID_CLIENT_EXTERN void setContentType(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getContentType() const;
+    QPID_MESSAGING_EXTERN void setContentType(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getContentType() const;
 
-    QPID_CLIENT_EXTERN void setMessageId(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getMessageId() const;
+    QPID_MESSAGING_EXTERN void setMessageId(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getMessageId() const;
 
-    QPID_CLIENT_EXTERN void setUserId(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getUserId() const;
+    QPID_MESSAGING_EXTERN void setUserId(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getUserId() const;
 
-    QPID_CLIENT_EXTERN void setCorrelationId(const std::string&);
-    QPID_CLIENT_EXTERN const std::string& getCorrelationId() const;
+    QPID_MESSAGING_EXTERN void setCorrelationId(const std::string&);
+    QPID_MESSAGING_EXTERN const std::string& getCorrelationId() const;
 
-    QPID_CLIENT_EXTERN void setPriority(uint8_t);
-    QPID_CLIENT_EXTERN uint8_t getPriority() const;
+    QPID_MESSAGING_EXTERN void setPriority(uint8_t);
+    QPID_MESSAGING_EXTERN uint8_t getPriority() const;
 
     /**
      * Set the time to live for this message in milliseconds.
      */
-    QPID_CLIENT_EXTERN void setTtl(Duration ttl);
+    QPID_MESSAGING_EXTERN void setTtl(Duration ttl);
     /**
      *Get the time to live for this message in milliseconds.
      */
-    QPID_CLIENT_EXTERN Duration getTtl() const;
+    QPID_MESSAGING_EXTERN Duration getTtl() const;
 
-    QPID_CLIENT_EXTERN void setDurable(bool durable);
-    QPID_CLIENT_EXTERN bool getDurable() const;
+    QPID_MESSAGING_EXTERN void setDurable(bool durable);
+    QPID_MESSAGING_EXTERN bool getDurable() const;
 
-    QPID_CLIENT_EXTERN bool getRedelivered() const;
-    QPID_CLIENT_EXTERN void setRedelivered(bool);
+    QPID_MESSAGING_EXTERN bool getRedelivered() const;
+    QPID_MESSAGING_EXTERN void setRedelivered(bool);
 
-    QPID_CLIENT_EXTERN const qpid::types::Variant::Map& getProperties() const;
-    QPID_CLIENT_EXTERN qpid::types::Variant::Map& getProperties();
+    QPID_MESSAGING_EXTERN const qpid::types::Variant::Map& getProperties() const;
+    QPID_MESSAGING_EXTERN qpid::types::Variant::Map& getProperties();
 
-    QPID_CLIENT_EXTERN void setContent(const std::string&);
+    QPID_MESSAGING_EXTERN void setContent(const std::string&);
     /**
      * Note that chars are copied.
      */
-    QPID_CLIENT_EXTERN void setContent(const char* chars, size_t count);
+    QPID_MESSAGING_EXTERN void setContent(const char* chars, size_t count);
 
     /** Get the content as a std::string */
-    QPID_CLIENT_EXTERN std::string getContent() const;
+    QPID_MESSAGING_EXTERN std::string getContent() const;
     /** Get a const pointer to the start of the content data. */
-    QPID_CLIENT_EXTERN const char* getContentPtr() const;
+    QPID_MESSAGING_EXTERN const char* getContentPtr() const;
     /** Get the size of content in bytes. */
-    QPID_CLIENT_EXTERN size_t getContentSize() const;
+    QPID_MESSAGING_EXTERN size_t getContentSize() const;
   private:
     MessageImpl* impl;
     friend struct MessageImplAccess;
@@ -119,7 +119,7 @@ struct EncodingException : qpid::types::Exception
  * any encoding specified by the content-type of the message
  * @exception EncodingException
  */
-QPID_CLIENT_EXTERN void decode(const Message& message,
+QPID_MESSAGING_EXTERN void decode(const Message& message,
                                qpid::types::Variant::Map& map,
                                const std::string& encoding = std::string());
 /**
@@ -131,7 +131,7 @@ QPID_CLIENT_EXTERN void decode(const Message& message,
  * any encoding specified by the content-type of the message
  * @exception EncodingException
  */
-QPID_CLIENT_EXTERN void decode(const Message& message,
+QPID_MESSAGING_EXTERN void decode(const Message& message,
                                qpid::types::Variant::List& list,
                                const std::string& encoding = std::string());
 /**
@@ -143,7 +143,7 @@ QPID_CLIENT_EXTERN void decode(const Message& message,
  * any encoding specified by the content-type of the message
  * @exception EncodingException
  */
-QPID_CLIENT_EXTERN void encode(const qpid::types::Variant::Map& map,
+QPID_MESSAGING_EXTERN void encode(const qpid::types::Variant::Map& map,
                                Message& message,
                                const std::string& encoding = std::string());
 /**
@@ -155,7 +155,7 @@ QPID_CLIENT_EXTERN void encode(const qpid::types::Variant::Map& map,
  * any encoding specified by the content-type of the message
  * @exception EncodingException
  */
-QPID_CLIENT_EXTERN void encode(const qpid::types::Variant::List& list,
+QPID_MESSAGING_EXTERN void encode(const qpid::types::Variant::List& list,
                                Message& message,
                                const std::string& encoding = std::string());
 
diff --git a/cpp/include/qpid/messaging/Receiver.h b/cpp/include/qpid/messaging/Receiver.h
index 2cd024f26f..a1129975cf 100644
--- a/cpp/include/qpid/messaging/Receiver.h
+++ b/cpp/include/qpid/messaging/Receiver.h
@@ -42,16 +42,16 @@ class Session;
 class Receiver : public qpid::messaging::Handle<ReceiverImpl>
 {
   public:
-    QPID_CLIENT_EXTERN Receiver(ReceiverImpl* impl = 0);
-    QPID_CLIENT_EXTERN Receiver(const Receiver&);
-    QPID_CLIENT_EXTERN ~Receiver();
-    QPID_CLIENT_EXTERN Receiver& operator=(const Receiver&);
+    QPID_MESSAGING_EXTERN Receiver(ReceiverImpl* impl = 0);
+    QPID_MESSAGING_EXTERN Receiver(const Receiver&);
+    QPID_MESSAGING_EXTERN ~Receiver();
+    QPID_MESSAGING_EXTERN Receiver& operator=(const Receiver&);
     /**
      * Retrieves a message from this receivers local queue, or waits
      * for upto the specified timeout for a message to become
      * available.
      */
-    QPID_CLIENT_EXTERN bool get(Message& message, Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN bool get(Message& message, Duration timeout=Duration::FOREVER);
     /**
      * Retrieves a message from this receivers local queue, or waits
      * for up to the specified timeout for a message to become
@@ -61,7 +61,7 @@ class Receiver : public qpid::messaging::Handle<ReceiverImpl>
      * after waiting for the specified timeout, or if the Receiver is
      * closed, in which case isClose() will be true.
      */
-    QPID_CLIENT_EXTERN Message get(Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN Message get(Duration timeout=Duration::FOREVER);
     /**
      * Retrieves a message for this receivers subscription or waits
      * for up to the specified timeout for one to become
@@ -73,7 +73,7 @@ class Receiver : public qpid::messaging::Handle<ReceiverImpl>
      * waiting for the specified timeout, or if the Receiver is
      * closed, in which case isClose() will be true.
      */
-    QPID_CLIENT_EXTERN bool fetch(Message& message, Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN bool fetch(Message& message, Duration timeout=Duration::FOREVER);
     /**
      * Retrieves a message for this receivers subscription or waits
      * for up to the specified timeout for one to become
@@ -85,52 +85,52 @@ class Receiver : public qpid::messaging::Handle<ReceiverImpl>
      * after waiting for the specified timeout, or if the Receiver is
      * closed, in which case isClose() will be true.
      */
-    QPID_CLIENT_EXTERN Message fetch(Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN Message fetch(Duration timeout=Duration::FOREVER);
     /**
      * Sets the capacity for the receiver. The capacity determines how
      * many incoming messages can be held in the receiver before being
      * requested by a client via fetch() (or pushed to a listener).
      */
-    QPID_CLIENT_EXTERN void setCapacity(uint32_t);
+    QPID_MESSAGING_EXTERN void setCapacity(uint32_t);
     /**
      * @return the capacity of the receiver. The capacity determines
      * how many incoming messages can be held in the receiver before
      * being requested by a client via fetch() (or pushed to a
      * listener).
      */
-    QPID_CLIENT_EXTERN uint32_t getCapacity();
+    QPID_MESSAGING_EXTERN uint32_t getCapacity();
     /**
      * @return the number of messages received and waiting to be
      * fetched.
      */
-    QPID_CLIENT_EXTERN uint32_t getAvailable();
+    QPID_MESSAGING_EXTERN uint32_t getAvailable();
     /**
      * @return a count of the number of messages received on this
      * receiver that have been acknowledged, but for which that
      * acknowledgement has not yet been confirmed as processed by the
      * server.
      */
-    QPID_CLIENT_EXTERN uint32_t getUnsettled();
+    QPID_MESSAGING_EXTERN uint32_t getUnsettled();
 
     /**
      * Cancels this receiver.
      */
-    QPID_CLIENT_EXTERN void close();
+    QPID_MESSAGING_EXTERN void close();
 
     /**
      * Return true if the receiver was closed by a call to close()
      */
-    QPID_CLIENT_EXTERN bool isClosed() const;
+    QPID_MESSAGING_EXTERN bool isClosed() const;
 
     /**
      * Returns the name of this receiver.
      */
-    QPID_CLIENT_EXTERN const std::string& getName() const;
+    QPID_MESSAGING_EXTERN const std::string& getName() const;
 
     /**
      * Returns a handle to the session associated with this receiver.
      */
-    QPID_CLIENT_EXTERN Session getSession() const;
+    QPID_MESSAGING_EXTERN Session getSession() const;
 
   private:
   friend class qpid::messaging::PrivateImplRef<Receiver>;
diff --git a/cpp/include/qpid/messaging/Sender.h b/cpp/include/qpid/messaging/Sender.h
index 9b5d0452e8..80ebf517a4 100644
--- a/cpp/include/qpid/messaging/Sender.h
+++ b/cpp/include/qpid/messaging/Sender.h
@@ -41,10 +41,10 @@ class Session;
 class Sender : public qpid::messaging::Handle<SenderImpl>
 {
   public:
-    QPID_CLIENT_EXTERN Sender(SenderImpl* impl = 0);
-    QPID_CLIENT_EXTERN Sender(const Sender&);
-    QPID_CLIENT_EXTERN ~Sender();
-    QPID_CLIENT_EXTERN Sender& operator=(const Sender&);
+    QPID_MESSAGING_EXTERN Sender(SenderImpl* impl = 0);
+    QPID_MESSAGING_EXTERN Sender(const Sender&);
+    QPID_MESSAGING_EXTERN ~Sender();
+    QPID_MESSAGING_EXTERN Sender& operator=(const Sender&);
 
     /**
      * Sends a message
@@ -54,39 +54,39 @@ class Sender : public qpid::messaging::Handle<SenderImpl>
      * confirms receipt of the messages; if false will only block for
      * available capacity (i.e. pending == capacity)
      */
-    QPID_CLIENT_EXTERN void send(const Message& message, bool sync=false);
-    QPID_CLIENT_EXTERN void close();
+    QPID_MESSAGING_EXTERN void send(const Message& message, bool sync=false);
+    QPID_MESSAGING_EXTERN void close();
 
     /**
      * Sets the capacity for the sender. The capacity determines how
      * many outgoing messages can be held pending confirmation of
      * receipt by the broker.
      */
-    QPID_CLIENT_EXTERN void setCapacity(uint32_t);
+    QPID_MESSAGING_EXTERN void setCapacity(uint32_t);
     /**
      * Returns the capacity of the sender. 
      * @see setCapacity
      */
-    QPID_CLIENT_EXTERN uint32_t getCapacity();
+    QPID_MESSAGING_EXTERN uint32_t getCapacity();
     /**
      * Returns the number of sent messages pending confirmation of
      * receipt by the broker. (These are the 'in-doubt' messages).
      */
-    QPID_CLIENT_EXTERN uint32_t getUnsettled();
+    QPID_MESSAGING_EXTERN uint32_t getUnsettled();
     /**
      * Returns the number of messages for which there is available
      * capacity.
      */
-    QPID_CLIENT_EXTERN uint32_t getAvailable();
+    QPID_MESSAGING_EXTERN uint32_t getAvailable();
     /**
      * Returns the name of this sender.
      */
-    QPID_CLIENT_EXTERN const std::string& getName() const;
+    QPID_MESSAGING_EXTERN const std::string& getName() const;
 
     /**
      * Returns a handle to the session associated with this sender.
      */
-    QPID_CLIENT_EXTERN Session getSession() const;
+    QPID_MESSAGING_EXTERN Session getSession() const;
   private:
   friend class qpid::messaging::PrivateImplRef<Sender>;
 };
diff --git a/cpp/include/qpid/messaging/Session.h b/cpp/include/qpid/messaging/Session.h
index 9fa9fe48d1..34fccdb868 100644
--- a/cpp/include/qpid/messaging/Session.h
+++ b/cpp/include/qpid/messaging/Session.h
@@ -49,10 +49,10 @@ class Subscription;
 class Session : public qpid::messaging::Handle<SessionImpl>
 {
   public:
-    QPID_CLIENT_EXTERN Session(SessionImpl* impl = 0);
-    QPID_CLIENT_EXTERN Session(const Session&);
-    QPID_CLIENT_EXTERN ~Session();
-    QPID_CLIENT_EXTERN Session& operator=(const Session&);
+    QPID_MESSAGING_EXTERN Session(SessionImpl* impl = 0);
+    QPID_MESSAGING_EXTERN Session(const Session&);
+    QPID_MESSAGING_EXTERN ~Session();
+    QPID_MESSAGING_EXTERN Session& operator=(const Session&);
 
     /**
      * Closes a session and all associated senders and receivers. An
@@ -60,10 +60,10 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * goes out of scope. All a connections sessions can be closed by
      * a call to Connection::close().
      */
-    QPID_CLIENT_EXTERN void close();
+    QPID_MESSAGING_EXTERN void close();
 
-    QPID_CLIENT_EXTERN void commit();
-    QPID_CLIENT_EXTERN void rollback();
+    QPID_MESSAGING_EXTERN void commit();
+    QPID_MESSAGING_EXTERN void rollback();
 
     /**
      * Acknowledges all outstanding messages that have been received
@@ -72,19 +72,19 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * @param sync if true, blocks until the acknowledgement has been
      * processed by the server
      */
-    QPID_CLIENT_EXTERN void acknowledge(bool sync=false);
+    QPID_MESSAGING_EXTERN void acknowledge(bool sync=false);
     /**
      * Rejects the specified message. This will prevent the message
      * being redelivered. This must be called before the message is
      * acknowledged.
      */
-    QPID_CLIENT_EXTERN void reject(Message&);
+    QPID_MESSAGING_EXTERN void reject(Message&);
     /**
      * Releases the specified message. This will allow the broker to
      * redeliver the message. This must be called before the message
      * is acknowledged.
      */
-    QPID_CLIENT_EXTERN void release(Message&);
+    QPID_MESSAGING_EXTERN void release(Message&);
 
     /**
      * Request synchronisation with the server.
@@ -94,7 +94,7 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * call will request notifcation from the server but will return
      * before receiving it.
      */
-    QPID_CLIENT_EXTERN void sync(bool block=true);
+    QPID_MESSAGING_EXTERN void sync(bool block=true);
 
     /**
      * Returns the total number of messages received and waiting to be
@@ -102,13 +102,13 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * total number of available messages across all receivers on this
      * session.
      */
-    QPID_CLIENT_EXTERN uint32_t getReceivable();
+    QPID_MESSAGING_EXTERN uint32_t getReceivable();
     /**
      * Returns a count of the number of messages received this session
      * that have been acknowledged, but for which that acknowledgement
      * has not yet been confirmed as processed by the server.
      */
-    QPID_CLIENT_EXTERN uint32_t getUnsettledAcks();
+    QPID_MESSAGING_EXTERN uint32_t getUnsettledAcks();
     /**
      * Retrieves the receiver for the next available message. If there
      * are no available messages at present the call will block for up
@@ -117,7 +117,7 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * which case the passed in receiver reference will be set to the
      * receiver for that message or false if no message was available.
      */
-    QPID_CLIENT_EXTERN bool nextReceiver(Receiver&, Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN bool nextReceiver(Receiver&, Duration timeout=Duration::FOREVER);
     /**
      * Returns the receiver for the next available message. If there
      * are no available messages at present the call will block for up
@@ -126,40 +126,40 @@ class Session : public qpid::messaging::Handle<SessionImpl>
      * @exception Receiver::NoMessageAvailable if no message became
      * available in time.
      */
-    QPID_CLIENT_EXTERN Receiver nextReceiver(Duration timeout=Duration::FOREVER);
+    QPID_MESSAGING_EXTERN Receiver nextReceiver(Duration timeout=Duration::FOREVER);
     
     /**
      * Create a new sender through which messages can be sent to the
      * specified address.
      */
-    QPID_CLIENT_EXTERN Sender createSender(const Address& address);
-    QPID_CLIENT_EXTERN Sender createSender(const std::string& address);
+    QPID_MESSAGING_EXTERN Sender createSender(const Address& address);
+    QPID_MESSAGING_EXTERN Sender createSender(const std::string& address);
 
     /**
      * Create a new receiver through which messages can be received
      * from the specified address.
      */
-    QPID_CLIENT_EXTERN Receiver createReceiver(const Address& address);
-    QPID_CLIENT_EXTERN Receiver createReceiver(const std::string& address);
+    QPID_MESSAGING_EXTERN Receiver createReceiver(const Address& address);
+    QPID_MESSAGING_EXTERN Receiver createReceiver(const std::string& address);
 
     /**
      * Returns the sender with the specified name.
      *@exception KeyError if there is none for that name.
      */
-    QPID_CLIENT_EXTERN Sender getSender(const std::string& name) const;
+    QPID_MESSAGING_EXTERN Sender getSender(const std::string& name) const;
     /**
      * Returns the receiver with the specified name.
      *@exception KeyError if there is none for that name.
      */
-    QPID_CLIENT_EXTERN Receiver getReceiver(const std::string& name) const;
+    QPID_MESSAGING_EXTERN Receiver getReceiver(const std::string& name) const;
     /**
      * Returns a handle to the connection this session is associated
      * with.
      */
-    QPID_CLIENT_EXTERN Connection getConnection() const;
+    QPID_MESSAGING_EXTERN Connection getConnection() const;
 
-    QPID_CLIENT_EXTERN bool hasError();
-    QPID_CLIENT_EXTERN void checkError();
+    QPID_MESSAGING_EXTERN bool hasError();
+    QPID_MESSAGING_EXTERN void checkError();
 
   private:
   friend class qpid::messaging::PrivateImplRef<Session>;
diff --git a/cpp/include/qpid/messaging/exceptions.h b/cpp/include/qpid/messaging/exceptions.h
index 74393e2463..0ff608b343 100644
--- a/cpp/include/qpid/messaging/exceptions.h
+++ b/cpp/include/qpid/messaging/exceptions.h
@@ -22,9 +22,9 @@
  *
  */
 
+#include "qpid/messaging/ImportExport.h"
 #include "qpid/types/Exception.h"
 #include "qpid/types/Variant.h"
-#include "qpid/messaging/ImportExport.h"
 
 namespace qpid {
 namespace messaging {
@@ -34,8 +34,8 @@ namespace messaging {
 
 struct MessagingException : public qpid::types::Exception 
 {
-    QPID_CLIENT_EXTERN MessagingException(const std::string& msg);
-    QPID_CLIENT_EXTERN virtual ~MessagingException() throw();
+    QPID_MESSAGING_EXTERN MessagingException(const std::string& msg);
+    QPID_MESSAGING_EXTERN virtual ~MessagingException() throw();
     
     qpid::types::Variant::Map detail;
     //TODO: override what() to include detail if present
@@ -43,22 +43,22 @@ struct MessagingException : public qpid::types::Exception
 
 struct InvalidOptionString : public MessagingException 
 {
-    QPID_CLIENT_EXTERN InvalidOptionString(const std::string& msg);
+    QPID_MESSAGING_EXTERN InvalidOptionString(const std::string& msg);
 };
 
 struct KeyError : public MessagingException
 {
-    QPID_CLIENT_EXTERN KeyError(const std::string&);
+    QPID_MESSAGING_EXTERN KeyError(const std::string&);
 };
 
 struct LinkError : public MessagingException
 {
-    QPID_CLIENT_EXTERN LinkError(const std::string&);
+    QPID_MESSAGING_EXTERN LinkError(const std::string&);
 };
 
 struct AddressError : public LinkError
 {
-    QPID_CLIENT_EXTERN AddressError(const std::string&);
+    QPID_MESSAGING_EXTERN AddressError(const std::string&);
 };
 
 /**
@@ -67,17 +67,17 @@ struct AddressError : public LinkError
  */
 struct ResolutionError : public AddressError 
 {
-    QPID_CLIENT_EXTERN ResolutionError(const std::string& msg);
+    QPID_MESSAGING_EXTERN ResolutionError(const std::string& msg);
 };
 
 struct AssertionFailed : public ResolutionError 
 {
-    QPID_CLIENT_EXTERN AssertionFailed(const std::string& msg);
+    QPID_MESSAGING_EXTERN AssertionFailed(const std::string& msg);
 };
 
 struct NotFound : public ResolutionError 
 {
-    QPID_CLIENT_EXTERN NotFound(const std::string& msg);
+    QPID_MESSAGING_EXTERN NotFound(const std::string& msg);
 };
 
 /**
@@ -85,67 +85,67 @@ struct NotFound : public ResolutionError
  */
 struct MalformedAddress : public AddressError 
 {
-    QPID_CLIENT_EXTERN MalformedAddress(const std::string& msg);
+    QPID_MESSAGING_EXTERN MalformedAddress(const std::string& msg);
 };
 
 struct ReceiverError : public LinkError
 {
-    QPID_CLIENT_EXTERN ReceiverError(const std::string&);
+    QPID_MESSAGING_EXTERN ReceiverError(const std::string&);
 };
 
 struct FetchError : public ReceiverError
 {
-    QPID_CLIENT_EXTERN FetchError(const std::string&);
+    QPID_MESSAGING_EXTERN FetchError(const std::string&);
 };
 
 struct NoMessageAvailable : public FetchError
 {
-    QPID_CLIENT_EXTERN NoMessageAvailable();
+    QPID_MESSAGING_EXTERN NoMessageAvailable();
 };
 
 struct SenderError : public LinkError
 {
-    QPID_CLIENT_EXTERN SenderError(const std::string&);
+    QPID_MESSAGING_EXTERN SenderError(const std::string&);
 };
 
 struct SendError : public SenderError
 {
-    QPID_CLIENT_EXTERN SendError(const std::string&);
+    QPID_MESSAGING_EXTERN SendError(const std::string&);
 };
 
 struct TargetCapacityExceeded : public SendError
 {
-    QPID_CLIENT_EXTERN TargetCapacityExceeded(const std::string&);
+    QPID_MESSAGING_EXTERN TargetCapacityExceeded(const std::string&);
 };
 
 struct SessionError : public MessagingException
 {
-    QPID_CLIENT_EXTERN SessionError(const std::string&);
+    QPID_MESSAGING_EXTERN SessionError(const std::string&);
 };
 
 struct TransactionError : public SessionError
 {
-    QPID_CLIENT_EXTERN TransactionError(const std::string&);
+    QPID_MESSAGING_EXTERN TransactionError(const std::string&);
 };
 
 struct TransactionAborted : public TransactionError
 {
-    QPID_CLIENT_EXTERN TransactionAborted(const std::string&);
+    QPID_MESSAGING_EXTERN TransactionAborted(const std::string&);
 };
 
 struct UnauthorizedAccess : public SessionError
 {
-    QPID_CLIENT_EXTERN UnauthorizedAccess(const std::string&);
+    QPID_MESSAGING_EXTERN UnauthorizedAccess(const std::string&);
 };
 
 struct ConnectionError : public MessagingException
 {
-    QPID_CLIENT_EXTERN ConnectionError(const std::string&);
+    QPID_MESSAGING_EXTERN ConnectionError(const std::string&);
 };
 
 struct TransportFailure : public MessagingException
 {
-    QPID_CLIENT_EXTERN TransportFailure(const std::string&);
+    QPID_MESSAGING_EXTERN TransportFailure(const std::string&);
 };
 
 }} // namespace qpid::messaging
diff --git a/cpp/src/qpid/broker/windows/SaslAuthenticator.cpp b/cpp/src/qpid/broker/windows/SaslAuthenticator.cpp
index 212d7c4db4..642be29f2f 100644
--- a/cpp/src/qpid/broker/windows/SaslAuthenticator.cpp
+++ b/cpp/src/qpid/broker/windows/SaslAuthenticator.cpp
@@ -78,7 +78,7 @@ void SaslAuthenticator::fini(void)
     return;
 }
 
-std::auto_ptr<SaslAuthenticator> SaslAuthenticator::createAuthenticator(Connection& c)
+std::auto_ptr<SaslAuthenticator> SaslAuthenticator::createAuthenticator(Connection& c, bool)
 {
     if (c.getBroker().getOptions().auth) {
         return std::auto_ptr<SaslAuthenticator>(new SspiAuthenticator(c));
diff --git a/cpp/src/qpid/client/SessionImpl.h b/cpp/src/qpid/client/SessionImpl.h
index 7259bc0733..cd7b2c123d 100644
--- a/cpp/src/qpid/client/SessionImpl.h
+++ b/cpp/src/qpid/client/SessionImpl.h
@@ -83,8 +83,8 @@ public:
     void resume(boost::shared_ptr<ConnectionImpl>);
     void suspend();
 
-    void assertOpen() const;
-    bool hasError() const;
+    QPID_CLIENT_EXTERN void assertOpen() const;
+    QPID_CLIENT_EXTERN bool hasError() const;
 
     Future send(const framing::AMQBody& command);
     Future send(const framing::AMQBody& command, const framing::MethodContent& content);