Changes to make messaging API build on Windows: Prepend VAR_ to Variant types enum to avoid name clashes, add 'reference' type for FieldTable ValueMap to satisfy STL, refer to structs as such, not as class (avoids compile warning)

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

13 files changed, 205 insertions, 203 deletions

diff --git a/cpp/include/qpid/framing/FieldTable.h b/cpp/include/qpid/framing/FieldTable.h
index b2331cd4e1..fd09cfc6f6 100644
--- a/cpp/include/qpid/framing/FieldTable.h
+++ b/cpp/include/qpid/framing/FieldTable.h
@@ -52,6 +52,7 @@ class FieldTable
     typedef std::map<std::string, ValuePtr> ValueMap;
     typedef ValueMap::iterator iterator;
     typedef ValueMap::const_reference const_reference;
+    typedef ValueMap::reference reference;
     typedef ValueMap::value_type value_type;
 
     QPID_COMMON_EXTERN FieldTable() {};
@@ -108,7 +109,7 @@ class FieldTable
     ValueMap::iterator find(const std::string& s) { return values.find(s); }
 
     std::pair <ValueMap::iterator, bool> insert(const ValueMap::value_type&);
-    ValueMap::iterator insert(ValueMap::iterator, const ValueMap::value_type&);
+    QPID_COMMON_EXTERN ValueMap::iterator insert(ValueMap::iterator, const ValueMap::value_type&);
     void clear() { values.clear(); }
 
     // ### Hack Alert
diff --git a/cpp/include/qpid/framing/List.h b/cpp/include/qpid/framing/List.h
index cb1129ebf8..0f17c7884c 100644
--- a/cpp/include/qpid/framing/List.h
+++ b/cpp/include/qpid/framing/List.h
@@ -44,6 +44,7 @@ class List
     typedef Values::const_iterator const_iterator;
     typedef Values::iterator iterator;
     typedef Values::const_reference const_reference;
+    typedef Values::reference reference;
 
     QPID_COMMON_EXTERN uint32_t encodedSize() const;
     QPID_COMMON_EXTERN void encode(Buffer& buffer) const;
diff --git a/cpp/include/qpid/messaging/Connection.h b/cpp/include/qpid/messaging/Connection.h
index 5517e45af9..19dae586a4 100644
--- a/cpp/include/qpid/messaging/Connection.h
+++ b/cpp/include/qpid/messaging/Connection.h
@@ -41,7 +41,7 @@ class Session;
 class Connection : public qpid::client::Handle<ConnectionImpl>
 {
   public:
-    static Connection open(const std::string& url, const Variant::Map& options = Variant::Map());
+    static QPID_CLIENT_EXTERN Connection open(const std::string& url, const Variant::Map& options = Variant::Map());
 
     QPID_CLIENT_EXTERN Connection(ConnectionImpl* impl = 0);
     QPID_CLIENT_EXTERN Connection(const Connection&);
diff --git a/cpp/include/qpid/messaging/Message.h b/cpp/include/qpid/messaging/Message.h
index 329388048e..e68d8a1141 100644
--- a/cpp/include/qpid/messaging/Message.h
+++ b/cpp/include/qpid/messaging/Message.h
@@ -33,9 +33,9 @@ namespace client {
 
 namespace messaging {
 
-class Address;
+struct Address;
 class Codec;
-class MessageImpl;
+struct MessageImpl;
 
 /**
  * Representation of a message.
@@ -81,7 +81,7 @@ class Message
 
   private:
     MessageImpl* impl;
-  friend class MessageImplAccess;
+    friend struct MessageImplAccess;
 };
 }} // namespace qpid::messaging
 
diff --git a/cpp/include/qpid/messaging/Session.h b/cpp/include/qpid/messaging/Session.h
index 3a354c009f..1d88882db6 100644
--- a/cpp/include/qpid/messaging/Session.h
+++ b/cpp/include/qpid/messaging/Session.h
@@ -35,8 +35,8 @@ template <class> class PrivateImplRef;
 
 namespace messaging {
 
-class Address;
-class Filter;
+struct Address;
+struct Filter;
 class Message;
 class MessageListener;
 class Sender;
diff --git a/cpp/include/qpid/messaging/Variant.h b/cpp/include/qpid/messaging/Variant.h
index ac000244c2..1e51914794 100644
--- a/cpp/include/qpid/messaging/Variant.h
+++ b/cpp/include/qpid/messaging/Variant.h
@@ -44,21 +44,21 @@ struct InvalidConversion : public qpid::Exception
 };
 
 enum VariantType {
-    VOID = 0,
-    BOOL,
-    UINT8,
-    UINT16,
-    UINT32,
-    UINT64,
-    INT8,
-    INT16,
-    INT32,
-    INT64,
-    FLOAT,
-    DOUBLE,
-    STRING,
-    MAP,
-    LIST
+    VAR_VOID = 0,
+    VAR_BOOL,
+    VAR_UINT8,
+    VAR_UINT16,
+    VAR_UINT32,
+    VAR_UINT64,
+    VAR_INT8,
+    VAR_INT16,
+    VAR_INT32,
+    VAR_INT64,
+    VAR_FLOAT,
+    VAR_DOUBLE,
+    VAR_STRING,
+    VAR_MAP,
+    VAR_LIST
 };
 
 class VariantImpl;
diff --git a/cpp/src/qpid/client/amqp0_10/AddressResolution.h b/cpp/src/qpid/client/amqp0_10/AddressResolution.h
index 87758abe6d..9d5657450d 100644
--- a/cpp/src/qpid/client/amqp0_10/AddressResolution.h
+++ b/cpp/src/qpid/client/amqp0_10/AddressResolution.h
@@ -31,8 +31,8 @@ class ReplyTo;
 }
 
 namespace messaging {
-class Address;
-class Filter;
+struct Address;
+struct Filter;
 }
 
 namespace client {
diff --git a/cpp/src/qpid/client/amqp0_10/Codecs.cpp b/cpp/src/qpid/client/amqp0_10/Codecs.cpp
index 9aee3118fe..57184e3937 100644
--- a/cpp/src/qpid/client/amqp0_10/Codecs.cpp
+++ b/cpp/src/qpid/client/amqp0_10/Codecs.cpp
@@ -183,25 +183,25 @@ boost::shared_ptr<FieldValue> toFieldValue(const Variant& in)
 {
     boost::shared_ptr<FieldValue> out;
     switch (in.getType()) {
-      case VOID: out = boost::shared_ptr<FieldValue>(new VoidValue()); break;
-      case BOOL: out = boost::shared_ptr<FieldValue>(new BoolValue(in.asBool())); break;
-      case UINT8: out = boost::shared_ptr<FieldValue>(new Unsigned8Value(in.asUint8())); break;
-      case UINT16: out = boost::shared_ptr<FieldValue>(new Unsigned16Value(in.asUint16())); break;
-      case UINT32: out = boost::shared_ptr<FieldValue>(new Unsigned32Value(in.asUint32())); break;
-      case UINT64: out = boost::shared_ptr<FieldValue>(new Unsigned64Value(in.asUint64())); break;
-      case INT8: out = boost::shared_ptr<FieldValue>(new Integer8Value(in.asInt8())); break;
-      case INT16: out = boost::shared_ptr<FieldValue>(new Integer16Value(in.asInt16())); break;
-      case INT32: out = boost::shared_ptr<FieldValue>(new Integer32Value(in.asInt32())); break;
-      case INT64: out = boost::shared_ptr<FieldValue>(new Integer64Value(in.asInt64())); break;
-      case FLOAT: out = boost::shared_ptr<FieldValue>(new FloatValue(in.asFloat())); break;
-      case DOUBLE: out = boost::shared_ptr<FieldValue>(new DoubleValue(in.asDouble())); break;
+      case VAR_VOID: out = boost::shared_ptr<FieldValue>(new VoidValue()); break;
+      case VAR_BOOL: out = boost::shared_ptr<FieldValue>(new BoolValue(in.asBool())); break;
+      case VAR_UINT8: out = boost::shared_ptr<FieldValue>(new Unsigned8Value(in.asUint8())); break;
+      case VAR_UINT16: out = boost::shared_ptr<FieldValue>(new Unsigned16Value(in.asUint16())); break;
+      case VAR_UINT32: out = boost::shared_ptr<FieldValue>(new Unsigned32Value(in.asUint32())); break;
+      case VAR_UINT64: out = boost::shared_ptr<FieldValue>(new Unsigned64Value(in.asUint64())); break;
+      case VAR_INT8: out = boost::shared_ptr<FieldValue>(new Integer8Value(in.asInt8())); break;
+      case VAR_INT16: out = boost::shared_ptr<FieldValue>(new Integer16Value(in.asInt16())); break;
+      case VAR_INT32: out = boost::shared_ptr<FieldValue>(new Integer32Value(in.asInt32())); break;
+      case VAR_INT64: out = boost::shared_ptr<FieldValue>(new Integer64Value(in.asInt64())); break;
+      case VAR_FLOAT: out = boost::shared_ptr<FieldValue>(new FloatValue(in.asFloat())); break;
+      case VAR_DOUBLE: out = boost::shared_ptr<FieldValue>(new DoubleValue(in.asDouble())); break;
         //TODO: check encoding (and length?) when deciding what AMQP type to treat string as
-      case STRING: out = boost::shared_ptr<FieldValue>(new Str16Value(in.asString())); break;
-      case MAP: 
+      case VAR_STRING: out = boost::shared_ptr<FieldValue>(new Str16Value(in.asString())); break;
+      case VAR_MAP: 
         //out = boost::shared_ptr<FieldValue>(toFieldValueCollection<FieldTableValue>(in.asMap(), &toFieldTableEntry));
         out = boost::shared_ptr<FieldValue>(toFieldTableValue(in.asMap()));
         break;
-      case LIST: 
+      case VAR_LIST: 
         //out = boost::shared_ptr<FieldValue>(toFieldValueCollection<ListValue>(in.asList(), &toFieldValue));
         out = boost::shared_ptr<FieldValue>(toListValue(in.asList()));
         break;
diff --git a/cpp/src/qpid/client/amqp0_10/SessionImpl.h b/cpp/src/qpid/client/amqp0_10/SessionImpl.h
index 6926fb0235..7032a8db4a 100644
--- a/cpp/src/qpid/client/amqp0_10/SessionImpl.h
+++ b/cpp/src/qpid/client/amqp0_10/SessionImpl.h
@@ -32,8 +32,8 @@
 namespace qpid {
 
 namespace messaging {
-class Address;
-class Filter;
+struct Address;
+struct Filter;
 class Message;
 class Receiver;
 class Sender;
diff --git a/cpp/src/qpid/messaging/MessageImpl.cpp b/cpp/src/qpid/messaging/MessageImpl.cpp
index 3c7f4fa515..402a93e753 100644
--- a/cpp/src/qpid/messaging/MessageImpl.cpp
+++ b/cpp/src/qpid/messaging/MessageImpl.cpp
@@ -28,8 +28,8 @@ namespace {
 const std::string EMPTY_STRING = "";
 }
 
-MessageImpl::MessageImpl(const std::string& c) : bytes(c), type(VOID), internalId(0) {}
-MessageImpl::MessageImpl(const char* chars, size_t count) : bytes(chars, count), type(VOID), internalId(0) {}
+MessageImpl::MessageImpl(const std::string& c) : bytes(c), type(VAR_VOID), internalId(0) {}
+MessageImpl::MessageImpl(const char* chars, size_t count) : bytes(chars, count), type(VAR_VOID), internalId(0) {}
 
 void MessageImpl::setReplyTo(const Address& d) { replyTo = d; }
 const Address& MessageImpl::getReplyTo() const { return replyTo; }
@@ -54,9 +54,9 @@ Variant& MessageImpl::operator[](const std::string& key) { return asMap()[key];
 
 std::ostream& MessageImpl::print(std::ostream& out) const
 {
-    if (type == MAP) {
+    if (type == VAR_MAP) {
         return out << content.asMap();
-    } else if (type == LIST) {
+    } else if (type == VAR_LIST) {
         return out << content.asList();
     } else {
         return out << bytes;
@@ -65,13 +65,13 @@ std::ostream& MessageImpl::print(std::ostream& out) const
 
 template <class T> MessageContent& MessageImpl::append(T& t)
 {
-    if (type == VOID) {
+    if (type == VAR_VOID) {
         //TODO: this is inefficient, probably want to hold on to the stream object
         std::stringstream s;
         s << bytes;
         s << t;
         bytes = s.str();
-    } else if (type == LIST) {
+    } else if (type == VAR_LIST) {
         content.asList().push_back(Variant(t));
     } else {
         throw InvalidConversion("<< operator only valid on strings and lists");
@@ -94,33 +94,33 @@ MessageContent& MessageImpl::operator<<(double v) { return append(v); }
 MessageContent& MessageImpl::operator<<(float v) { return append(v); }
 MessageContent& MessageImpl::operator=(const std::string& s) 
 { 
-    type = VOID;
+    type = VAR_VOID;
     bytes = s; 
     return *this;
 }
 MessageContent& MessageImpl::operator=(const char* c) 
 { 
-    type = VOID;
+    type = VAR_VOID;
     bytes = c;
     return *this;
 }
 MessageContent& MessageImpl::operator=(const Variant::Map& m)
 { 
-    type = MAP;
+    type = VAR_MAP;
     content = m; 
     return *this;
 }
 
 MessageContent& MessageImpl::operator=(const Variant::List& l)
 { 
-    type = LIST;
+    type = VAR_LIST;
     content = l; 
     return *this;
 }
 
 void MessageImpl::encode(Codec& codec)
 {
-    if (content.getType() != VOID) {
+    if (content.getType() != VAR_VOID) {
         bytes = EMPTY_STRING;
         codec.encode(content, bytes);
     }
@@ -129,15 +129,15 @@ void MessageImpl::encode(Codec& codec)
 void MessageImpl::decode(Codec& codec) 
 {
     codec.decode(bytes, content);    
-    if (content.getType() == MAP) type = MAP;
-    else if (content.getType() == LIST) type = LIST;
-    else type = VOID;//TODO: what if codec set some type other than map or list??
+    if (content.getType() == VAR_MAP) type = VAR_MAP;
+    else if (content.getType() == VAR_LIST) type = VAR_LIST;
+    else type = VAR_VOID;//TODO: what if codec set some type other than map or list??
 }
 
 void MessageImpl::setInternalId(qpid::framing::SequenceNumber i) { internalId = i; }
 qpid::framing::SequenceNumber MessageImpl::getInternalId() { return internalId; }
 
-bool MessageImpl::isVoid() const { return type == VOID; }
+bool MessageImpl::isVoid() const { return type == VAR_VOID; }
 
 const std::string& MessageImpl::asString() const 
 { 
@@ -165,24 +165,24 @@ Variant::Map& MessageImpl::asMap()
 { 
     if (isVoid()) {
         content = Variant::Map(); 
-        type = MAP; 
+        type = VAR_MAP; 
     }
     return content.asMap(); 
 }
-bool MessageImpl::isMap() const { return type == MAP; }
+bool MessageImpl::isMap() const { return type == VAR_MAP; }
 
 const Variant::List& MessageImpl::asList() const { return content.asList(); }
 Variant::List& MessageImpl::asList()
 { 
     if (isVoid()) {
-        content = Variant::List(); 
-        type = LIST; 
+        content = Variant::List();
+        type = VAR_LIST; 
     }
     return content.asList(); 
 }
-bool MessageImpl::isList() const { return type == LIST; }
+bool MessageImpl::isList() const { return type == VAR_LIST; }
 
-void MessageImpl::clear() { bytes = EMPTY_STRING; content.reset(); type = VOID; } 
+void MessageImpl::clear() { bytes = EMPTY_STRING; content.reset(); type = VAR_VOID; } 
 
 MessageImpl& MessageImplAccess::get(Message& msg)
 {
diff --git a/cpp/src/qpid/messaging/SessionImpl.h b/cpp/src/qpid/messaging/SessionImpl.h
index 7a7ce731f8..9b122a24bc 100644
--- a/cpp/src/qpid/messaging/SessionImpl.h
+++ b/cpp/src/qpid/messaging/SessionImpl.h
@@ -32,8 +32,8 @@ namespace client {
 
 namespace messaging {
 
-class Address;
-class Filter;
+struct Address;
+struct Filter;
 class Message;
 class Sender;
 class Receiver;
diff --git a/cpp/src/qpid/messaging/Variant.cpp b/cpp/src/qpid/messaging/Variant.cpp
index 59770939e1..4e37134b39 100644
--- a/cpp/src/qpid/messaging/Variant.cpp
+++ b/cpp/src/qpid/messaging/Variant.cpp
@@ -113,31 +113,31 @@ class VariantImpl
 };
 
 
-VariantImpl::VariantImpl() : type(VOID) { value.i64 = 0; }
-VariantImpl::VariantImpl(bool b) : type(BOOL) { value.b = b; }
-VariantImpl::VariantImpl(uint8_t i) : type(UINT8) { value.ui8 = i; }
-VariantImpl::VariantImpl(uint16_t i) : type(UINT16) { value.ui16 = i; }
-VariantImpl::VariantImpl(uint32_t i) : type(UINT32) { value.ui32 = i; }
-VariantImpl::VariantImpl(uint64_t i) : type(UINT64) { value.ui64 = i; }
-VariantImpl::VariantImpl(int8_t i) : type(INT8) { value.i8 = i; }
-VariantImpl::VariantImpl(int16_t i) : type(INT16) { value.i16 = i; }
-VariantImpl::VariantImpl(int32_t i) : type(INT32) { value.i32 = i; }
-VariantImpl::VariantImpl(int64_t i) : type(INT64) { value.i64 = i; }
-VariantImpl::VariantImpl(float f) : type(FLOAT) { value.f = f; }
-VariantImpl::VariantImpl(double d) : type(DOUBLE) { value.d = d; }
-VariantImpl::VariantImpl(const std::string& s) : type(STRING) { value.v = new std::string(s); }
-VariantImpl::VariantImpl(const Variant::Map& m) : type(MAP) { value.v = new Variant::Map(m); }
-VariantImpl::VariantImpl(const Variant::List& l) : type(LIST) { value.v = new Variant::List(l); }
+VariantImpl::VariantImpl() : type(VAR_VOID) { value.i64 = 0; }
+VariantImpl::VariantImpl(bool b) : type(VAR_BOOL) { value.b = b; }
+VariantImpl::VariantImpl(uint8_t i) : type(VAR_UINT8) { value.ui8 = i; }
+VariantImpl::VariantImpl(uint16_t i) : type(VAR_UINT16) { value.ui16 = i; }
+VariantImpl::VariantImpl(uint32_t i) : type(VAR_UINT32) { value.ui32 = i; }
+VariantImpl::VariantImpl(uint64_t i) : type(VAR_UINT64) { value.ui64 = i; }
+VariantImpl::VariantImpl(int8_t i) : type(VAR_INT8) { value.i8 = i; }
+VariantImpl::VariantImpl(int16_t i) : type(VAR_INT16) { value.i16 = i; }
+VariantImpl::VariantImpl(int32_t i) : type(VAR_INT32) { value.i32 = i; }
+VariantImpl::VariantImpl(int64_t i) : type(VAR_INT64) { value.i64 = i; }
+VariantImpl::VariantImpl(float f) : type(VAR_FLOAT) { value.f = f; }
+VariantImpl::VariantImpl(double d) : type(VAR_DOUBLE) { value.d = d; }
+VariantImpl::VariantImpl(const std::string& s) : type(VAR_STRING) { value.v = new std::string(s); }
+VariantImpl::VariantImpl(const Variant::Map& m) : type(VAR_MAP) { value.v = new Variant::Map(m); }
+VariantImpl::VariantImpl(const Variant::List& l) : type(VAR_LIST) { value.v = new Variant::List(l); }
 
 VariantImpl::~VariantImpl() { 
     switch (type) {
-      case STRING:
+      case VAR_STRING:
         delete reinterpret_cast<std::string*>(value.v);
         break;
-      case MAP:
+      case VAR_MAP:
         delete reinterpret_cast<Variant::Map*>(value.v);
         break;
-      case LIST:
+      case VAR_LIST:
         delete reinterpret_cast<Variant::List*>(value.v);
         break;
       default:
@@ -175,169 +175,169 @@ bool toBool(const std::string& s)
 bool VariantImpl::asBool() const
 {
     switch(type) {
-      case VOID: return false;
-      case BOOL: return value.b;
-      case UINT8: return value.ui8;
-      case UINT16: return value.ui16;
-      case UINT32: return value.ui32;
-      case UINT64: return value.ui64;
-      case INT8: return value.i8;
-      case INT16: return value.i16;
-      case INT32: return value.i32;
-      case INT64: return value.i64;
-      case STRING: return toBool(*reinterpret_cast<std::string*>(value.v));
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(BOOL)));
+      case VAR_VOID: return false;
+      case VAR_BOOL: return value.b;
+      case VAR_UINT8: return value.ui8;
+      case VAR_UINT16: return value.ui16;
+      case VAR_UINT32: return value.ui32;
+      case VAR_UINT64: return value.ui64;
+      case VAR_INT8: return value.i8;
+      case VAR_INT16: return value.i16;
+      case VAR_INT32: return value.i32;
+      case VAR_INT64: return value.i64;
+      case VAR_STRING: return toBool(*reinterpret_cast<std::string*>(value.v));
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_BOOL)));
     }
 }
 uint8_t VariantImpl::asUint8() const
 {
     switch(type) {
-      case UINT8: return value.ui8;
-      case STRING: return convertFromString<uint8_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(UINT8)));
+      case VAR_UINT8: return value.ui8;
+      case VAR_STRING: return convertFromString<uint8_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT8)));
     }
 }
 uint16_t VariantImpl::asUint16() const
 {
     switch(type) {
-      case UINT8: return value.ui8;
-      case UINT16: return value.ui16;
-      case STRING: return convertFromString<uint16_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(UINT16)));
+      case VAR_UINT8: return value.ui8;
+      case VAR_UINT16: return value.ui16;
+      case VAR_STRING: return convertFromString<uint16_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT16)));
     }
 }
 uint32_t VariantImpl::asUint32() const
 {
     switch(type) {
-      case UINT8: return value.ui8;
-      case UINT16: return value.ui16;
-      case UINT32: return value.ui32;
-      case STRING: return convertFromString<uint32_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(UINT32)));
+      case VAR_UINT8: return value.ui8;
+      case VAR_UINT16: return value.ui16;
+      case VAR_UINT32: return value.ui32;
+      case VAR_STRING: return convertFromString<uint32_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT32)));
     }
 }
 uint64_t VariantImpl::asUint64() const
 {
     switch(type) {
-      case UINT8: return value.ui8;
-      case UINT16: return value.ui16;
-      case UINT32: return value.ui32;
-      case UINT64: return value.ui64;
-      case STRING: return convertFromString<uint64_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(UINT64)));
+      case VAR_UINT8: return value.ui8;
+      case VAR_UINT16: return value.ui16;
+      case VAR_UINT32: return value.ui32;
+      case VAR_UINT64: return value.ui64;
+      case VAR_STRING: return convertFromString<uint64_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UINT64)));
     }
 }
 int8_t VariantImpl::asInt8() const
 {
     switch(type) {
-      case INT8: return value.i8;
-      case STRING: return convertFromString<int8_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(INT8)));
+      case VAR_INT8: return value.i8;
+      case VAR_STRING: return convertFromString<int8_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT8)));
     }
 }
 int16_t VariantImpl::asInt16() const
 {
     switch(type) {
-      case INT8: return value.i8;
-      case INT16: return value.i16;
-      case STRING: return convertFromString<int16_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(INT16)));
+      case VAR_INT8: return value.i8;
+      case VAR_INT16: return value.i16;
+      case VAR_STRING: return convertFromString<int16_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT16)));
     }
 }
 int32_t VariantImpl::asInt32() const
 {
     switch(type) {
-      case INT8: return value.i8;
-      case INT16: return value.i16;
-      case INT32: return value.i32;
-      case STRING: return convertFromString<int32_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(INT32)));
+      case VAR_INT8: return value.i8;
+      case VAR_INT16: return value.i16;
+      case VAR_INT32: return value.i32;
+      case VAR_STRING: return convertFromString<int32_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT32)));
     }
 }
 int64_t VariantImpl::asInt64() const
 {
     switch(type) {
-      case INT8: return value.i8;
-      case INT16: return value.i16;
-      case INT32: return value.i32;
-      case INT64: return value.i64;
-      case STRING: return convertFromString<int64_t>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(INT64)));
+      case VAR_INT8: return value.i8;
+      case VAR_INT16: return value.i16;
+      case VAR_INT32: return value.i32;
+      case VAR_INT64: return value.i64;
+      case VAR_STRING: return convertFromString<int64_t>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_INT64)));
     }
 }
 float VariantImpl::asFloat() const
 {
     switch(type) {
-      case FLOAT: return value.f;
-      case STRING: return convertFromString<float>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(FLOAT)));
+      case VAR_FLOAT: return value.f;
+      case VAR_STRING: return convertFromString<float>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_FLOAT)));
     }
 }
 double VariantImpl::asDouble() const
 {
     switch(type) {
-      case FLOAT: return value.f;
-      case DOUBLE: return value.d;
-      case STRING: return convertFromString<double>();
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(DOUBLE)));
+      case VAR_FLOAT: return value.f;
+      case VAR_DOUBLE: return value.d;
+      case VAR_STRING: return convertFromString<double>();
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_DOUBLE)));
     }
 }
 std::string VariantImpl::asString() const
 {
     switch(type) {
-      case VOID: return EMPTY;
-      case BOOL: return value.b ? TRUE : FALSE;
-      case UINT8: return boost::lexical_cast<std::string>((int) value.ui8);
-      case UINT16: return boost::lexical_cast<std::string>(value.ui16);
-      case UINT32: return boost::lexical_cast<std::string>(value.ui32);
-      case UINT64: return boost::lexical_cast<std::string>(value.ui64);
-      case INT8: return boost::lexical_cast<std::string>((int) value.i8);
-      case INT16: return boost::lexical_cast<std::string>(value.i16);
-      case INT32: return boost::lexical_cast<std::string>(value.i32);
-      case INT64: return boost::lexical_cast<std::string>(value.i64);
-      case DOUBLE: return boost::lexical_cast<std::string>(value.d);
-      case FLOAT: return boost::lexical_cast<std::string>(value.f);
-      case STRING: return *reinterpret_cast<std::string*>(value.v);
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(STRING)));
+      case VAR_VOID: return EMPTY;
+      case VAR_BOOL: return value.b ? TRUE : FALSE;
+      case VAR_UINT8: return boost::lexical_cast<std::string>((int) value.ui8);
+      case VAR_UINT16: return boost::lexical_cast<std::string>(value.ui16);
+      case VAR_UINT32: return boost::lexical_cast<std::string>(value.ui32);
+      case VAR_UINT64: return boost::lexical_cast<std::string>(value.ui64);
+      case VAR_INT8: return boost::lexical_cast<std::string>((int) value.i8);
+      case VAR_INT16: return boost::lexical_cast<std::string>(value.i16);
+      case VAR_INT32: return boost::lexical_cast<std::string>(value.i32);
+      case VAR_INT64: return boost::lexical_cast<std::string>(value.i64);
+      case VAR_DOUBLE: return boost::lexical_cast<std::string>(value.d);
+      case VAR_FLOAT: return boost::lexical_cast<std::string>(value.f);
+      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_STRING)));
     }
 }
 
 const Variant::Map& VariantImpl::asMap() const
 {
     switch(type) {
-      case MAP: return *reinterpret_cast<Variant::Map*>(value.v);
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(MAP)));
+      case VAR_MAP: return *reinterpret_cast<Variant::Map*>(value.v);
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_MAP)));
     }
 }
 
 Variant::Map& VariantImpl::asMap()
 {
     switch(type) {
-      case MAP: return *reinterpret_cast<Variant::Map*>(value.v);
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(MAP)));
+      case VAR_MAP: return *reinterpret_cast<Variant::Map*>(value.v);
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_MAP)));
     }
 }
 
 const Variant::List& VariantImpl::asList() const
 {
     switch(type) {
-      case LIST: return *reinterpret_cast<Variant::List*>(value.v);
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(LIST)));
+      case VAR_LIST: return *reinterpret_cast<Variant::List*>(value.v);
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_LIST)));
     }
 }
 
 Variant::List& VariantImpl::asList()
 {
     switch(type) {
-      case LIST: return *reinterpret_cast<Variant::List*>(value.v);
-      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(LIST)));
+      case VAR_LIST: return *reinterpret_cast<Variant::List*>(value.v);
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_LIST)));
     }
 }
 
 std::string& VariantImpl::getString()
 {
     switch(type) {
-      case STRING: return *reinterpret_cast<std::string*>(value.v);
+      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
       default: throw InvalidConversion(QPID_MSG("Variant is not a string; use asString() if conversion is required."));
     }
 }
@@ -345,7 +345,7 @@ std::string& VariantImpl::getString()
 const std::string& VariantImpl::getString() const
 {
     switch(type) {
-      case STRING: return *reinterpret_cast<std::string*>(value.v);
+      case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
       default: throw InvalidConversion(QPID_MSG("Variant is not a string; use asString() if conversion is required."));
     }
 }
@@ -356,21 +356,21 @@ const std::string& VariantImpl::getEncoding() const { return encoding; }
 std::string VariantImpl::getTypeName(VariantType type) const
 {
     switch (type) {
-      case VOID: return "void";
-      case BOOL: return "bool";
-      case UINT8: return "uint8";
-      case UINT16: return "uint16";
-      case UINT32: return "uint32";
-      case UINT64: return "uint64";
-      case INT8: return "int8";
-      case INT16: return "int16";
-      case INT32: return "int32";
-      case INT64: return "int64";
-      case FLOAT: return "float";
-      case DOUBLE: return "double";
-      case STRING: return "string";
-      case MAP: return "map";
-      case LIST: return "list";
+      case VAR_VOID: return "void";
+      case VAR_BOOL: return "bool";
+      case VAR_UINT8: return "uint8";
+      case VAR_UINT16: return "uint16";
+      case VAR_UINT32: return "uint32";
+      case VAR_UINT64: return "uint64";
+      case VAR_INT8: return "int8";
+      case VAR_INT16: return "int16";
+      case VAR_INT32: return "int32";
+      case VAR_INT64: return "int64";
+      case VAR_FLOAT: return "float";
+      case VAR_DOUBLE: return "double";
+      case VAR_STRING: return "string";
+      case VAR_MAP: return "map";
+      case VAR_LIST: return "list";
     }
     return "<unknown>";//should never happen
 }
@@ -378,20 +378,20 @@ std::string VariantImpl::getTypeName(VariantType type) const
 VariantImpl* VariantImpl::create(const Variant& v) 
 {
     switch (v.getType()) {
-      case BOOL: return new VariantImpl(v.asBool());
-      case UINT8: return new VariantImpl(v.asUint8());
-      case UINT16: return new VariantImpl(v.asUint16());
-      case UINT32: return new VariantImpl(v.asUint32());
-      case UINT64: return new VariantImpl(v.asUint64());
-      case INT8: return new VariantImpl(v.asInt8());
-      case INT16: return new VariantImpl(v.asInt16());
-      case INT32: return new VariantImpl(v.asInt32());
-      case INT64: return new VariantImpl(v.asInt64());
-      case FLOAT: return new VariantImpl(v.asFloat());
-      case DOUBLE: return new VariantImpl(v.asDouble());
-      case STRING: return new VariantImpl(v.asString());
-      case MAP: return new VariantImpl(v.asMap());
-      case LIST: return new VariantImpl(v.asList());
+      case VAR_BOOL: return new VariantImpl(v.asBool());
+      case VAR_UINT8: return new VariantImpl(v.asUint8());
+      case VAR_UINT16: return new VariantImpl(v.asUint16());
+      case VAR_UINT32: return new VariantImpl(v.asUint32());
+      case VAR_UINT64: return new VariantImpl(v.asUint64());
+      case VAR_INT8: return new VariantImpl(v.asInt8());
+      case VAR_INT16: return new VariantImpl(v.asInt16());
+      case VAR_INT32: return new VariantImpl(v.asInt32());
+      case VAR_INT64: return new VariantImpl(v.asInt64());
+      case VAR_FLOAT: return new VariantImpl(v.asFloat());
+      case VAR_DOUBLE: return new VariantImpl(v.asDouble());
+      case VAR_STRING: return new VariantImpl(v.asString());
+      case VAR_MAP: return new VariantImpl(v.asMap());
+      case VAR_LIST: return new VariantImpl(v.asList());
       default: return new VariantImpl();
     }
 }
@@ -584,13 +584,13 @@ std::ostream& operator<<(std::ostream& out, const Variant::List& list)
 std::ostream& operator<<(std::ostream& out, const Variant& value)
 {
     switch (value.getType()) {
-      case MAP:
+      case VAR_MAP:
         out << "{" << value.asMap() << "}";
         break;
-      case LIST:
+      case VAR_LIST:
         out << "[" << value.asList() << "]";
         break;
-      case VOID:
+      case VAR_VOID:
         out << "<void>";
         break;
       default:
diff --git a/cpp/src/tests/Variant.cpp b/cpp/src/tests/Variant.cpp
index 1bf2ed98ce..8ad659e59a 100644
--- a/cpp/src/tests/Variant.cpp
+++ b/cpp/src/tests/Variant.cpp
@@ -87,14 +87,14 @@ QPID_AUTO_TEST_CASE(testAssignment)
 {
     Variant value("abc");
     Variant other = value;
-    BOOST_CHECK_EQUAL(STRING, value.getType());
+    BOOST_CHECK_EQUAL(VAR_STRING, value.getType());
     BOOST_CHECK_EQUAL(other.getType(), value.getType());
     BOOST_CHECK_EQUAL(other.asString(), value.asString());
 
     const uint32_t i(1000);
     value = i;
-    BOOST_CHECK_EQUAL(UINT32, value.getType());
-    BOOST_CHECK_EQUAL(STRING, other.getType());    
+    BOOST_CHECK_EQUAL(VAR_UINT32, value.getType());
+    BOOST_CHECK_EQUAL(VAR_STRING, other.getType());    
 }
 
 QPID_AUTO_TEST_CASE(testList)
@@ -111,17 +111,17 @@ QPID_AUTO_TEST_CASE(testList)
     Variant::List::const_iterator i = value.asList().begin(); 
 
     BOOST_CHECK(i != value.asList().end());
-    BOOST_CHECK_EQUAL(STRING, i->getType());
+    BOOST_CHECK_EQUAL(VAR_STRING, i->getType());
     BOOST_CHECK_EQUAL(s, i->asString());
     i++;
 
     BOOST_CHECK(i != value.asList().end());
-    BOOST_CHECK_EQUAL(FLOAT, i->getType());
+    BOOST_CHECK_EQUAL(VAR_FLOAT, i->getType());
     BOOST_CHECK_EQUAL(f, i->asFloat());
     i++;
 
     BOOST_CHECK(i != value.asList().end());
-    BOOST_CHECK_EQUAL(INT16, i->getType());
+    BOOST_CHECK_EQUAL(VAR_INT16, i->getType());
     BOOST_CHECK_EQUAL(x, i->asInt16());
     i++;
 
@@ -140,17 +140,17 @@ QPID_AUTO_TEST_CASE(testMap)
     value.asMap()["my-key"] = x;
     BOOST_CHECK_EQUAL(3u, value.asMap().size());
 
-    BOOST_CHECK_EQUAL(STRING, value.asMap()["colour"].getType());
+    BOOST_CHECK_EQUAL(VAR_STRING, value.asMap()["colour"].getType());
     BOOST_CHECK_EQUAL(red, value.asMap()["colour"].asString());
 
-    BOOST_CHECK_EQUAL(FLOAT, value.asMap()["pi"].getType());
+    BOOST_CHECK_EQUAL(VAR_FLOAT, value.asMap()["pi"].getType());
     BOOST_CHECK_EQUAL(pi, value.asMap()["pi"].asFloat());
     
-    BOOST_CHECK_EQUAL(INT16, value.asMap()["my-key"].getType());
+    BOOST_CHECK_EQUAL(VAR_INT16, value.asMap()["my-key"].getType());
     BOOST_CHECK_EQUAL(x, value.asMap()["my-key"].asInt16());
 
     value.asMap()["my-key"] = "now it's a string";
-    BOOST_CHECK_EQUAL(STRING, value.asMap()["my-key"].getType());
+    BOOST_CHECK_EQUAL(VAR_STRING, value.asMap()["my-key"].getType());
     BOOST_CHECK_EQUAL(std::string("now it's a string"), value.asMap()["my-key"].asString());
 }