synchronized with trunk except for ruby dir

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

17 files changed, 2060 insertions, 0 deletions

diff --git a/cpp/src/qpid/messaging/Address.cpp b/cpp/src/qpid/messaging/Address.cpp
new file mode 100644
index 0000000000..ff72f62705
--- /dev/null
+++ b/cpp/src/qpid/messaging/Address.cpp
@@ -0,0 +1,362 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Address.h"
+#include "qpid/framing/Uuid.h"
+#include <sstream>
+#include <boost/format.hpp>
+
+namespace qpid {
+namespace messaging {
+
+namespace {
+const std::string SUBJECT_DIVIDER = "/";
+const std::string OPTIONS_DIVIDER = ";";
+const std::string SPACE = " ";
+const std::string TYPE = "type";
+}
+class AddressImpl
+{
+  public:
+    std::string name;
+    std::string subject;
+    Variant::Map options;
+ 
+    AddressImpl() {}
+    AddressImpl(const std::string& n, const std::string& s, const Variant::Map& o) :
+        name(n), subject(s), options(o) {}
+};
+
+class AddressParser
+{
+  public:
+    AddressParser(const std::string&);
+    bool parse(Address& address);
+  private:
+    const std::string& input;
+    std::string::size_type current;
+    static const std::string RESERVED;
+
+    bool readChar(char c);
+    bool readQuotedString(std::string& s);
+    bool readQuotedValue(Variant& value);
+    bool readString(std::string& value, char delimiter);
+    bool readWord(std::string& word, const std::string& delims = RESERVED);
+    bool readSimpleValue(Variant& word);
+    bool readKey(std::string& key);
+    bool readValue(Variant& value);
+    bool readKeyValuePair(Variant::Map& map);
+    bool readMap(Variant& value);
+    bool readList(Variant& value);
+    bool readName(std::string& name);
+    bool readSubject(std::string& subject);
+    bool error(const std::string& message);
+    bool eos();
+    bool iswhitespace();
+    bool in(const std::string& delims);
+    bool isreserved();
+};
+
+Address::Address() : impl(new AddressImpl()) {}
+Address::Address(const std::string& address) : impl(new AddressImpl())
+{ 
+    AddressParser parser(address);
+    parser.parse(*this);
+}
+Address::Address(const std::string& name, const std::string& subject, const Variant::Map& options,
+                 const std::string& type)
+    : impl(new AddressImpl(name, subject, options)) { setType(type); }
+Address::Address(const Address& a) :
+    impl(new AddressImpl(a.impl->name, a.impl->subject, a.impl->options)) {}
+Address::~Address() { delete impl; }
+
+Address& Address::operator=(const Address& a) { *impl = *a.impl; return *this; }
+
+
+std::string Address::toStr() const
+{
+    std::stringstream out;
+    out << impl->name;
+    if (!impl->subject.empty()) out << SUBJECT_DIVIDER << impl->subject;
+    if (!impl->options.empty()) out << OPTIONS_DIVIDER << impl->options;
+    return out.str();
+}
+Address::operator bool() const { return !impl->name.empty(); }
+bool Address::operator !() const { return impl->name.empty(); }
+
+const std::string& Address::getName() const { return impl->name; }
+void Address::setName(const std::string& name) { impl->name = name; }
+const std::string& Address::getSubject() const { return impl->subject; }
+bool Address::hasSubject() const { return !(impl->subject.empty()); }
+void Address::setSubject(const std::string& subject) { impl->subject = subject; }
+const Variant::Map& Address::getOptions() const { return impl->options; }
+Variant::Map& Address::getOptions() { return impl->options; }
+void Address::setOptions(const Variant::Map& options) { impl->options = options; }
+
+
+namespace{
+const Variant EMPTY_VARIANT;
+const std::string EMPTY_STRING;
+const std::string NODE_PROPERTIES="node-properties";
+}
+
+const Variant& find(const Variant::Map& map, const std::string& key)
+{
+    Variant::Map::const_iterator i = map.find(key);
+    if (i == map.end()) return EMPTY_VARIANT;
+    else return i->second;
+}
+
+std::string Address::getType() const
+{
+    const Variant& props = getOption(NODE_PROPERTIES);
+    if (props.getType() == VAR_MAP) {
+        const Variant& type = find(props.asMap(), TYPE);
+        if (!type.isVoid()) return type.asString();
+    }
+    return EMPTY_STRING;
+}
+
+void Address::setType(const std::string& type)
+{ 
+    Variant& props = impl->options[NODE_PROPERTIES];
+    if (props.isVoid()) props = Variant::Map();
+    props.asMap()[TYPE] = type;
+}
+
+const Variant& Address::getOption(const std::string& key) const
+{
+    return find(impl->options, key);
+}
+
+std::ostream& operator<<(std::ostream& out, const Address& address)
+{
+    out << address.toStr();
+    return out;
+}
+
+InvalidAddress::InvalidAddress(const std::string& msg) : Exception(msg) {}
+
+MalformedAddress::MalformedAddress(const std::string& msg) : Exception(msg) {}
+
+AddressParser::AddressParser(const std::string& s) : input(s), current(0) {}
+
+bool AddressParser::error(const std::string& message)
+{
+    throw MalformedAddress((boost::format("%1%, character %2% of %3%") % message % current % input).str());
+}
+
+bool AddressParser::parse(Address& address)
+{
+    std::string name;
+    if (readName(name)) {
+        if (name.find('#') == 0) name = qpid::framing::Uuid(true).str() + name;
+        address.setName(name);
+        if (readChar('/')) {
+            std::string subject;
+            if (readSubject(subject)) {
+                address.setSubject(subject);
+            } else {
+                return error("Expected subject after /");
+            }
+        }
+        if (readChar(';')) {
+            Variant options = Variant::Map();
+            if (readMap(options)) {
+                address.setOptions(options.asMap());
+            }
+        }
+        //skip trailing whitespace
+        while (!eos() && iswhitespace()) ++current;
+        return eos() || error("Unexpected chars in address: " + input.substr(current));
+    } else {
+        return input.empty() || error("Expected name");
+    }
+}
+
+bool AddressParser::readList(Variant& value)
+{
+    if (readChar('[')) {
+        value = Variant::List();
+        Variant item;
+        while (readValue(item)) {
+            value.asList().push_back(item);
+            if (!readChar(',')) break;
+        }
+        return readChar(']') || error("Unmatched '['!");
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readMap(Variant& value)
+{
+    if (readChar('{')) {
+        value = Variant::Map();
+        while (readKeyValuePair(value.asMap()) && readChar(',')) {}
+        return readChar('}') || error("Unmatched '{'!");
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readKeyValuePair(Variant::Map& map)
+{
+    std::string key;
+    Variant value;
+    if (readKey(key)) {
+        if (readChar(':') && readValue(value)) {
+            map[key] = value;
+            return true;
+        } else {
+            return error("Bad key-value pair, expected ':'");
+        }
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readKey(std::string& key)
+{
+    return readWord(key);
+}
+
+bool AddressParser::readValue(Variant& value)
+{
+    return readSimpleValue(value) || readQuotedValue(value) || 
+        readMap(value)  || readList(value) || error("Expected value");
+}
+
+bool AddressParser::readString(std::string& value, char delimiter)
+{
+    if (readChar(delimiter)) {
+        std::string::size_type start = current++;
+        while (!eos()) {
+            if (input.at(current) == delimiter) {
+                if (current > start) {
+                    value = input.substr(start, current - start);
+                } else {
+                    value = "";
+                }
+                ++current;
+                return true;
+            } else {
+                ++current;
+            }
+        }
+        return error("Unmatched delimiter");
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readName(std::string& name)
+{
+    return readQuotedString(name) || readWord(name, "/;");
+}
+
+bool AddressParser::readSubject(std::string& subject)
+{
+    return readQuotedString(subject) || readWord(subject, ";");
+}
+
+bool AddressParser::readQuotedString(std::string& s)
+{
+    return readString(s, '"') || readString(s, '\'');
+}
+
+bool AddressParser::readQuotedValue(Variant& value)
+{
+    std::string s;
+    if (readQuotedString(s)) {
+        value = s;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readSimpleValue(Variant& value)
+{
+    std::string s;
+    if (readWord(s)) {
+        value = s;
+        try { value = value.asInt64(); return true; } catch (const InvalidConversion&) {}
+        try { value = value.asDouble(); return true; } catch (const InvalidConversion&) {}
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readWord(std::string& value, const std::string& delims)
+{
+    //skip leading whitespace
+    while (!eos() && iswhitespace()) ++current;
+
+    //read any number of non-whitespace, non-reserved chars into value
+    std::string::size_type start = current;
+    while (!eos() && !iswhitespace() && !in(delims)) ++current;
+    
+    if (current > start) {
+        value = input.substr(start, current - start);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool AddressParser::readChar(char c)
+{
+    while (!eos()) {
+        if (iswhitespace()) { 
+            ++current; 
+        } else if (input.at(current) == c) {
+            ++current;
+            return true;
+        } else {
+            return false;
+        }
+    }
+    return false;
+}
+
+bool AddressParser::iswhitespace()
+{
+    return ::isspace(input.at(current));
+}
+
+bool AddressParser::isreserved()
+{
+    return in(RESERVED);
+}
+
+bool AddressParser::in(const std::string& chars)
+{
+    return chars.find(input.at(current)) != std::string::npos;
+}
+
+bool AddressParser::eos()
+{
+    return current >= input.size();
+}
+
+const std::string AddressParser::RESERVED = "\'\"{}[],:/";
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/Connection.cpp b/cpp/src/qpid/messaging/Connection.cpp
new file mode 100644
index 0000000000..64ca962317
--- /dev/null
+++ b/cpp/src/qpid/messaging/Connection.cpp
@@ -0,0 +1,96 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Connection.h"
+#include "qpid/messaging/ConnectionImpl.h"
+#include "qpid/messaging/Session.h"
+#include "qpid/messaging/SessionImpl.h"
+#include "qpid/client/PrivateImplRef.h"
+#include "qpid/client/amqp0_10/ConnectionImpl.h"
+#include "qpid/log/Statement.h"
+
+namespace qpid {
+namespace client {
+
+typedef PrivateImplRef<qpid::messaging::Connection> PI;
+
+}
+
+namespace messaging {
+
+using qpid::client::PI;
+
+Connection Connection::open(const std::string& url, const Variant::Map& options)
+{
+    //only support amqp 0-10 at present
+    Connection connection(new qpid::client::amqp0_10::ConnectionImpl(url, options));
+    return connection;
+}
+
+Connection::Connection(ConnectionImpl* impl) { PI::ctor(*this, impl); }
+Connection::Connection(const Connection& c) : qpid::client::Handle<ConnectionImpl>() { PI::copy(*this, c); }
+Connection& Connection::operator=(const Connection& c) { return PI::assign(*this, c); }
+Connection::~Connection() { PI::dtor(*this); }
+
+void Connection::close() { impl->close(); }
+Session Connection::newSession(const char* name) { return impl->newSession(false, name); }
+Session Connection::newSession(const std::string& name) { return impl->newSession(false, name); }
+Session Connection::newSession(bool transactional, const std::string& name)
+{ 
+    return impl->newSession(transactional, name);
+}
+Session Connection::getSession(const std::string& name) const { return impl->getSession(name); }
+
+InvalidOptionString::InvalidOptionString(const std::string& msg) : Exception(msg) {}
+
+void parseKeyValuePair(const std::string& in, Variant::Map& out)
+{
+    std::string::size_type i = in.find('=');
+    if (i == std::string::npos || i == in.size() || in.find('=', i+1) != std::string::npos) {
+        throw InvalidOptionString(QPID_MSG("Cannot parse name-value pair from " << in));
+    } else {
+        out[in.substr(0, i)] = in.substr(i+1);
+    }
+}
+
+void parseOptionString(const std::string& in, Variant::Map& out)
+{
+    std::string::size_type start = 0;
+    std::string::size_type i = in.find('&');
+    while (i != std::string::npos) {
+        parseKeyValuePair(in.substr(start, i-start), out);
+        if (i < in.size()) {
+            start = i+1;
+            i = in.find('&', start);
+        } else {
+            i = std::string::npos;
+        }
+    }
+    parseKeyValuePair(in.substr(start), out);
+}
+
+Variant::Map parseOptionString(const std::string& in)
+{
+    Variant::Map map;    
+    parseOptionString(in, map);
+    return map;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/ConnectionImpl.h b/cpp/src/qpid/messaging/ConnectionImpl.h
new file mode 100644
index 0000000000..4eff68ff9d
--- /dev/null
+++ b/cpp/src/qpid/messaging/ConnectionImpl.h
@@ -0,0 +1,46 @@
+#ifndef QPID_MESSAGING_CONNECTIONIMPL_H
+#define QPID_MESSAGING_CONNECTIONIMPL_H
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 <string>
+#include "qpid/RefCounted.h"
+
+namespace qpid {
+namespace client {
+}
+
+namespace messaging {
+
+class Session;
+
+class ConnectionImpl : public virtual qpid::RefCounted
+{
+  public:
+    virtual ~ConnectionImpl() {}
+    virtual void close() = 0;
+    virtual Session newSession(bool transactional, const std::string& name) = 0;
+    virtual Session getSession(const std::string& name) const = 0;
+  private:
+};
+}} // namespace qpid::messaging
+
+#endif  /*!QPID_MESSAGING_CONNECTIONIMPL_H*/
diff --git a/cpp/src/qpid/messaging/ListContent.cpp b/cpp/src/qpid/messaging/ListContent.cpp
new file mode 100644
index 0000000000..0c3ca5fc62
--- /dev/null
+++ b/cpp/src/qpid/messaging/ListContent.cpp
@@ -0,0 +1,98 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/ListContent.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/client/amqp0_10/Codecs.h"
+
+namespace qpid {
+namespace messaging {
+
+class ListContentImpl : public Variant
+{
+    Message* msg;
+  public:
+    ListContentImpl(Message& m) : Variant(Variant::List()), msg(&m)
+    {
+        if (msg->getContent().size()) {
+            qpid::client::amqp0_10::ListCodec codec;
+            codec.decode(msg->getContent(), *this);
+        }
+    }
+
+    void encode()
+    {
+        qpid::client::amqp0_10::ListCodec codec;
+        codec.encode(*this, msg->getContent());
+    }
+};
+
+ListContent::ListContent(Message& m) : impl(new ListContentImpl(m)) {}
+ListContent::~ListContent() { delete impl; }
+ListContent& ListContent::operator=(const ListContent& l) { *impl = *l.impl; return *this; }
+
+ListContent::const_iterator ListContent::begin() const { return impl->asList().begin(); }
+ListContent::const_iterator ListContent::end() const { return impl->asList().end(); }
+ListContent::const_reverse_iterator ListContent::rbegin() const { return impl->asList().rbegin(); }
+ListContent::const_reverse_iterator ListContent::rend() const { return impl->asList().rend(); }
+
+ListContent::iterator ListContent::begin() { return impl->asList().begin(); }
+ListContent::iterator ListContent::end() { return impl->asList().end(); }
+ListContent::reverse_iterator ListContent::rbegin() { return impl->asList().rbegin(); }
+ListContent::reverse_iterator ListContent::rend() { return impl->asList().rend(); }
+
+bool ListContent::empty() const { return impl->asList().empty(); }
+size_t ListContent::size() const { return impl->asList().size(); }
+
+const Variant& ListContent::front() const { return impl->asList().front(); }
+Variant& ListContent::front() { return impl->asList().front(); }
+const Variant& ListContent::back() const { return impl->asList().back(); }
+Variant& ListContent::back() { return impl->asList().back(); }
+
+void ListContent::push_front(const Variant& v) { impl->asList().push_front(v); }
+void ListContent::push_back(const Variant& v) { impl->asList().push_back(v); }
+
+void ListContent::pop_front() { impl->asList().pop_front(); }
+void ListContent::pop_back() { impl->asList().pop_back(); }
+
+ListContent::iterator ListContent::insert(iterator position, const Variant& v)
+{
+    return impl->asList().insert(position, v);
+}
+void ListContent::insert(iterator position, size_t n, const Variant& v)
+{
+    impl->asList().insert(position, n, v);
+}
+ListContent::iterator ListContent::erase(iterator position) { return impl->asList().erase(position); }
+ListContent::iterator ListContent::erase(iterator first, iterator last) { return impl->asList().erase(first, last); }
+void ListContent::clear() { impl->asList().clear(); }
+
+void ListContent::encode() { impl->encode(); }
+    
+const Variant::List& ListContent::asList() const { return impl->asList(); }
+Variant::List& ListContent::asList() { return impl->asList(); }
+
+std::ostream& operator<<(std::ostream& out, const ListContent& m)
+{
+    out << m.asList();
+    return out;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/ListView.cpp b/cpp/src/qpid/messaging/ListView.cpp
new file mode 100644
index 0000000000..b717d157fa
--- /dev/null
+++ b/cpp/src/qpid/messaging/ListView.cpp
@@ -0,0 +1,63 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/ListView.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/client/amqp0_10/Codecs.h"
+
+namespace qpid {
+namespace messaging {
+
+class ListViewImpl : public Variant
+{
+  public:
+    ListViewImpl(const Message& msg) : Variant(Variant::List())
+    {
+        if (msg.getContent().size()) {
+            qpid::client::amqp0_10::ListCodec codec;
+            codec.decode(msg.getContent(), *this);
+        }
+    }
+};
+
+ListView::ListView(const Message& m) :impl(new ListViewImpl(m)) {}
+ListView::~ListView() { delete impl; }
+ListView& ListView::operator=(const ListView& l) { *impl = *l.impl; return *this; }
+
+ListView::const_iterator ListView::begin() const { return impl->asList().begin(); }
+ListView::const_iterator ListView::end() const { return impl->asList().end(); }
+ListView::const_reverse_iterator ListView::rbegin() const { return impl->asList().rbegin(); }
+ListView::const_reverse_iterator ListView::rend() const { return impl->asList().rend(); }
+
+bool ListView::empty() const { return impl->asList().empty(); }
+size_t ListView::size() const { return impl->asList().size(); }
+
+const Variant& ListView::front() const { return impl->asList().front(); }
+const Variant& ListView::back() const { return impl->asList().back(); }
+    
+const Variant::List& ListView::asList() const { return impl->asList(); }
+
+std::ostream& operator<<(std::ostream& out, const ListView& m)
+{
+    out << m.asList();
+    return out;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/MapContent.cpp b/cpp/src/qpid/messaging/MapContent.cpp
new file mode 100644
index 0000000000..6dba22be99
--- /dev/null
+++ b/cpp/src/qpid/messaging/MapContent.cpp
@@ -0,0 +1,88 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/MapContent.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/client/amqp0_10/Codecs.h"
+
+namespace qpid {
+namespace messaging {
+
+class MapContentImpl : public Variant
+{
+    Message* msg;
+  public:
+    MapContentImpl(Message& m) : Variant(Variant::Map()), msg(&m)
+    {
+        if (msg->getContent().size()) {
+            qpid::client::amqp0_10::MapCodec codec;
+            codec.decode(msg->getContent(), *this);
+        }
+    }
+
+    void encode()
+    {
+        qpid::client::amqp0_10::MapCodec codec;
+        codec.encode(*this, msg->getContent());
+        msg->setContentType(qpid::client::amqp0_10::MapCodec::contentType);
+    }
+};
+
+MapContent::MapContent(Message& m) : impl(new MapContentImpl(m)) {}
+MapContent::~MapContent() { delete impl; }
+MapContent& MapContent::operator=(const MapContent& m) { *impl = *m.impl; return *this; }
+
+MapContent::const_iterator MapContent::begin() const { return impl->asMap().begin(); }
+MapContent::const_iterator MapContent::end() const { return impl->asMap().end(); }
+MapContent::const_reverse_iterator MapContent::rbegin() const { return impl->asMap().rbegin(); }
+MapContent::const_reverse_iterator MapContent::rend() const { return impl->asMap().rend(); }
+MapContent::iterator MapContent::begin() { return impl->asMap().begin(); }
+MapContent::iterator MapContent::end() { return impl->asMap().end(); }
+MapContent::reverse_iterator MapContent::rbegin() { return impl->asMap().rbegin(); }
+MapContent::reverse_iterator MapContent::rend() { return impl->asMap().rend(); }
+
+bool MapContent::empty() const { return impl->asMap().empty(); }
+size_t MapContent::size() const { return impl->asMap().size(); }
+
+MapContent::const_iterator MapContent::find(const key_type& key) const { return impl->asMap().find(key); }
+MapContent::iterator MapContent::find(const key_type& key) { return impl->asMap().find(key); }
+const Variant& MapContent::operator[](const key_type& key) const { return impl->asMap()[key]; }
+Variant& MapContent::operator[](const key_type& key) { return impl->asMap()[key]; }
+
+std::pair<MapContent::iterator,bool> MapContent::insert(const value_type& item) { return impl->asMap().insert(item); }
+MapContent::iterator MapContent::insert(iterator position, const value_type& item) { return impl->asMap().insert(position, item); }
+void MapContent::erase(iterator position) { impl->asMap().erase(position); }
+void MapContent::erase(iterator first, iterator last) { impl->asMap().erase(first, last); }
+size_t MapContent::erase(const key_type& key) { return impl->asMap().erase(key); }
+void MapContent::clear() { impl->asMap().clear(); }
+
+void MapContent::encode() { impl->encode(); }
+
+const std::map<MapContent::key_type, Variant>& MapContent::asMap() const { return impl->asMap(); }
+std::map<MapContent::key_type, Variant>& MapContent::asMap() { return impl->asMap(); }
+
+
+std::ostream& operator<<(std::ostream& out, const MapContent& m)
+{
+    out << m.asMap();
+    return out;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/MapView.cpp b/cpp/src/qpid/messaging/MapView.cpp
new file mode 100644
index 0000000000..ffa6e91a16
--- /dev/null
+++ b/cpp/src/qpid/messaging/MapView.cpp
@@ -0,0 +1,63 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/MapView.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/client/amqp0_10/Codecs.h"
+
+namespace qpid {
+namespace messaging {
+
+class MapViewImpl : public Variant
+{
+  public:
+    MapViewImpl(const Message& msg) : Variant(Variant::Map())
+    {
+        if (msg.getContent().size()) {
+            qpid::client::amqp0_10::MapCodec codec;
+            codec.decode(msg.getContent(), *this);
+        }
+    }
+};
+
+MapView::MapView(const Message& m) : impl(new MapViewImpl(m)) {}
+MapView::~MapView() { delete impl; }
+MapView& MapView::operator=(const MapView& m) { *impl = *m.impl; return *this; }
+
+MapView::const_iterator MapView::begin() const { return impl->asMap().begin(); }
+MapView::const_iterator MapView::end() const { return impl->asMap().end(); }
+MapView::const_reverse_iterator MapView::rbegin() const { return impl->asMap().rbegin(); }
+MapView::const_reverse_iterator MapView::rend() const { return impl->asMap().rend(); }
+
+bool MapView::empty() const { return impl->asMap().empty(); }
+size_t MapView::size() const { return impl->asMap().size(); }
+
+MapView::const_iterator MapView::find(const key_type& key) const { return impl->asMap().find(key); }
+const Variant& MapView::operator[](const key_type& key) const { return impl->asMap()[key]; }
+
+const std::map<MapView::key_type, Variant>& MapView::asMap() const { return impl->asMap(); }
+
+std::ostream& operator<<(std::ostream& out, const MapView& m)
+{
+    out << m.asMap();
+    return out;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/Message.cpp b/cpp/src/qpid/messaging/Message.cpp
new file mode 100644
index 0000000000..deb40b6aa3
--- /dev/null
+++ b/cpp/src/qpid/messaging/Message.cpp
@@ -0,0 +1,58 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Message.h"
+#include "qpid/messaging/MessageImpl.h"
+
+namespace qpid {
+namespace messaging {
+
+Message::Message(const std::string& bytes) : impl(new MessageImpl(bytes)) {}
+Message::Message(const char* bytes, size_t count) : impl(new MessageImpl(bytes, count)) {}
+
+Message::Message(const Message& m) : impl(new MessageImpl(*m.impl)) {}
+Message::~Message() { delete impl; }
+
+Message& Message::operator=(const Message& m) { *impl = *m.impl; return *this; }
+
+void Message::setReplyTo(const Address& d) { impl->setReplyTo(d); }
+const Address& Message::getReplyTo() const { return impl->getReplyTo(); }
+
+void Message::setSubject(const std::string& s) { impl->setSubject(s); }
+const std::string& Message::getSubject() const { return impl->getSubject(); }
+
+void Message::setContentType(const std::string& s) { impl->setContentType(s); }
+const std::string& Message::getContentType() const { return impl->getContentType(); }
+
+const VariantMap& Message::getHeaders() const { return impl->getHeaders(); }
+VariantMap& Message::getHeaders() { return impl->getHeaders(); }
+
+void Message::setContent(const std::string& c) { impl->setBytes(c); }
+void Message::setContent(const char* chars, size_t count) { impl->setBytes(chars, count); }
+const std::string& Message::getContent() const { return impl->getBytes(); }
+std::string& Message::getContent() { return impl->getBytes(); }
+
+void Message::getContent(std::pair<const char*, size_t>& content) const
+{
+    content.first = impl->getBytes().data();
+    content.second = impl->getBytes().size();
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/MessageImpl.cpp b/cpp/src/qpid/messaging/MessageImpl.cpp
new file mode 100644
index 0000000000..e17fccd64f
--- /dev/null
+++ b/cpp/src/qpid/messaging/MessageImpl.cpp
@@ -0,0 +1,64 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "MessageImpl.h"
+#include "qpid/messaging/Message.h"
+
+namespace qpid {
+namespace messaging {
+
+namespace {
+const std::string EMPTY_STRING = "";
+}
+
+MessageImpl::MessageImpl(const std::string& c) : bytes(c), internalId(0) {}
+MessageImpl::MessageImpl(const char* chars, size_t count) : bytes(chars, count), internalId(0) {}
+
+void MessageImpl::setReplyTo(const Address& d) { replyTo = d; }
+const Address& MessageImpl::getReplyTo() const { return replyTo; }
+
+void MessageImpl::setSubject(const std::string& s) { subject = s; }
+const std::string& MessageImpl::getSubject() const { return subject; }
+
+void MessageImpl::setContentType(const std::string& s) { contentType = s; }
+const std::string& MessageImpl::getContentType() const { return contentType; }
+
+const VariantMap& MessageImpl::getHeaders() const { return headers; }
+VariantMap& MessageImpl::getHeaders() { return headers; }
+
+//should these methods be on MessageContent?
+void MessageImpl::setBytes(const std::string& c) { bytes = c; }
+void MessageImpl::setBytes(const char* chars, size_t count) { bytes.assign(chars, count); }
+const std::string& MessageImpl::getBytes() const { return bytes; }
+std::string& MessageImpl::getBytes() { return bytes; }
+
+void MessageImpl::setInternalId(qpid::framing::SequenceNumber i) { internalId = i; }
+qpid::framing::SequenceNumber MessageImpl::getInternalId() { return internalId; }
+
+MessageImpl& MessageImplAccess::get(Message& msg)
+{
+    return *msg.impl;
+}
+const MessageImpl& MessageImplAccess::get(const Message& msg)
+{
+    return *msg.impl;
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/MessageImpl.h b/cpp/src/qpid/messaging/MessageImpl.h
new file mode 100644
index 0000000000..4939cdc5cc
--- /dev/null
+++ b/cpp/src/qpid/messaging/MessageImpl.h
@@ -0,0 +1,82 @@
+#ifndef QPID_MESSAGING_MESSAGEIMPL_H
+#define QPID_MESSAGING_MESSAGEIMPL_H
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Address.h"
+#include "qpid/messaging/Variant.h"
+#include "qpid/framing/SequenceNumber.h"
+
+namespace qpid {
+namespace messaging {
+
+struct MessageImpl
+{
+    Address replyTo;
+    std::string subject;
+    std::string contentType;
+    Variant::Map headers;
+
+    std::string bytes;
+
+    qpid::framing::SequenceNumber internalId;
+
+    MessageImpl(const std::string& c);
+    MessageImpl(const char* chars, size_t count);
+
+    void setReplyTo(const Address& d);
+    const Address& getReplyTo() const;
+    
+    void setSubject(const std::string& s);
+    const std::string& getSubject() const;
+    
+    void setContentType(const std::string& s);
+    const std::string& getContentType() const;
+    
+    const Variant::Map& getHeaders() const;
+    Variant::Map& getHeaders();
+    
+    void setBytes(const std::string& bytes);
+    void setBytes(const char* chars, size_t count);
+    const std::string& getBytes() const;
+    std::string& getBytes();
+
+    void setInternalId(qpid::framing::SequenceNumber id);
+    qpid::framing::SequenceNumber getInternalId();
+
+};
+
+class Message;
+
+/**
+ * Provides access to the internal MessageImpl for a message which is
+ * useful when accessing any message state not exposed directly
+ * through the public API.
+ */
+struct MessageImplAccess
+{
+    static MessageImpl& get(Message&);
+    static const MessageImpl& get(const Message&);
+};
+
+}} // namespace qpid::messaging
+
+#endif  /*!QPID_MESSAGING_MESSAGEIMPL_H*/
diff --git a/cpp/src/qpid/messaging/Receiver.cpp b/cpp/src/qpid/messaging/Receiver.cpp
new file mode 100644
index 0000000000..bf9c056db8
--- /dev/null
+++ b/cpp/src/qpid/messaging/Receiver.cpp
@@ -0,0 +1,53 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Receiver.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/messaging/ReceiverImpl.h"
+#include "qpid/messaging/Session.h"
+#include "qpid/client/PrivateImplRef.h"
+
+namespace qpid {
+namespace client {
+
+typedef PrivateImplRef<qpid::messaging::Receiver> PI;
+
+}
+
+namespace messaging {
+
+using qpid::client::PI;
+
+Receiver::Receiver(ReceiverImpl* impl) { PI::ctor(*this, impl); }
+Receiver::Receiver(const Receiver& s) : qpid::client::Handle<ReceiverImpl>() { PI::copy(*this, s); }
+Receiver::~Receiver() { PI::dtor(*this); }
+Receiver& Receiver::operator=(const Receiver& s) { return PI::assign(*this, s); }
+bool Receiver::get(Message& message, qpid::sys::Duration timeout) { return impl->get(message, timeout); }
+Message Receiver::get(qpid::sys::Duration timeout) { return impl->get(timeout); }
+bool Receiver::fetch(Message& message, qpid::sys::Duration timeout) { return impl->fetch(message, timeout); }
+Message Receiver::fetch(qpid::sys::Duration timeout) { return impl->fetch(timeout); }
+void Receiver::setCapacity(uint32_t c) { impl->setCapacity(c); }
+uint32_t Receiver::getCapacity() { return impl->getCapacity(); }
+uint32_t Receiver::available() { return impl->available(); }
+uint32_t Receiver::pendingAck() { return impl->pendingAck(); }
+void Receiver::cancel() { impl->cancel(); }
+const std::string& Receiver::getName() const { return impl->getName(); }
+Session Receiver::getSession() const { return impl->getSession(); }
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/ReceiverImpl.h b/cpp/src/qpid/messaging/ReceiverImpl.h
new file mode 100644
index 0000000000..447a505518
--- /dev/null
+++ b/cpp/src/qpid/messaging/ReceiverImpl.h
@@ -0,0 +1,55 @@
+#ifndef QPID_MESSAGING_RECEIVERIMPL_H
+#define QPID_MESSAGING_RECEIVERIMPL_H
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/RefCounted.h"
+#include "qpid/sys/Time.h"
+
+namespace qpid {
+namespace client {
+}
+
+namespace messaging {
+
+class Message;
+class MessageListener;
+class Session;
+
+class ReceiverImpl : public virtual qpid::RefCounted
+{
+  public:
+    virtual ~ReceiverImpl() {}
+    virtual bool get(Message& message, qpid::sys::Duration timeout) = 0;
+    virtual Message get(qpid::sys::Duration timeout) = 0;
+    virtual bool fetch(Message& message, qpid::sys::Duration timeout) = 0;
+    virtual Message fetch(qpid::sys::Duration timeout) = 0;
+    virtual void setCapacity(uint32_t) = 0;
+    virtual uint32_t getCapacity() = 0;
+    virtual uint32_t available() = 0;
+    virtual uint32_t pendingAck() = 0;
+    virtual void cancel() = 0;
+    virtual const std::string& getName() const = 0;
+    virtual Session getSession() const = 0;
+};
+}} // namespace qpid::messaging
+
+#endif  /*!QPID_MESSAGING_RECEIVERIMPL_H*/
diff --git a/cpp/src/qpid/messaging/Sender.cpp b/cpp/src/qpid/messaging/Sender.cpp
new file mode 100644
index 0000000000..f2303f4126
--- /dev/null
+++ b/cpp/src/qpid/messaging/Sender.cpp
@@ -0,0 +1,50 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Sender.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/messaging/SenderImpl.h"
+#include "qpid/messaging/Session.h"
+#include "qpid/client/PrivateImplRef.h"
+
+namespace qpid {
+namespace client {
+
+typedef PrivateImplRef<qpid::messaging::Sender> PI;
+
+}
+
+namespace messaging {
+
+using qpid::client::PI;
+
+Sender::Sender(SenderImpl* impl) { PI::ctor(*this, impl); }
+Sender::Sender(const Sender& s) : qpid::client::Handle<SenderImpl>() { PI::copy(*this, s); }
+Sender::~Sender() { PI::dtor(*this); }
+Sender& Sender::operator=(const Sender& s) { return PI::assign(*this, s); }
+void Sender::send(const Message& message) { impl->send(message); }
+void Sender::cancel() { impl->cancel(); }
+void Sender::setCapacity(uint32_t c) { impl->setCapacity(c); }
+uint32_t Sender::getCapacity() { return impl->getCapacity(); }
+uint32_t Sender::pending() { return impl->pending(); }
+const std::string& Sender::getName() const { return impl->getName(); }
+Session Sender::getSession() const { return impl->getSession(); }
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/SenderImpl.h b/cpp/src/qpid/messaging/SenderImpl.h
new file mode 100644
index 0000000000..5f30417f6a
--- /dev/null
+++ b/cpp/src/qpid/messaging/SenderImpl.h
@@ -0,0 +1,50 @@
+#ifndef QPID_MESSAGING_SENDERIMPL_H
+#define QPID_MESSAGING_SENDERIMPL_H
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/RefCounted.h"
+
+namespace qpid {
+namespace client {
+}
+
+namespace messaging {
+
+class Message;
+class Session;
+
+class SenderImpl : public virtual qpid::RefCounted
+{
+  public:
+    virtual ~SenderImpl() {}
+    virtual void send(const Message& message) = 0;
+    virtual void cancel() = 0;
+    virtual void setCapacity(uint32_t) = 0;
+    virtual uint32_t getCapacity() = 0;
+    virtual uint32_t pending() = 0;
+    virtual const std::string& getName() const = 0;
+    virtual Session getSession() const = 0;
+  private:
+};
+}} // namespace qpid::messaging
+
+#endif  /*!QPID_MESSAGING_SENDERIMPL_H*/
diff --git a/cpp/src/qpid/messaging/Session.cpp b/cpp/src/qpid/messaging/Session.cpp
new file mode 100644
index 0000000000..99896caad4
--- /dev/null
+++ b/cpp/src/qpid/messaging/Session.cpp
@@ -0,0 +1,109 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Session.h"
+#include "qpid/messaging/Address.h"
+#include "qpid/messaging/Connection.h"
+#include "qpid/messaging/Message.h"
+#include "qpid/messaging/Sender.h"
+#include "qpid/messaging/Receiver.h"
+#include "qpid/messaging/SessionImpl.h"
+#include "qpid/client/PrivateImplRef.h"
+
+namespace qpid {
+namespace client {
+
+typedef PrivateImplRef<qpid::messaging::Session> PI;
+
+}
+
+namespace messaging {
+
+using qpid::client::PI;
+
+Session::Session(SessionImpl* impl) { PI::ctor(*this, impl); }
+Session::Session(const Session& s) : qpid::client::Handle<SessionImpl>() { PI::copy(*this, s); }
+Session::~Session() { PI::dtor(*this); }
+Session& Session::operator=(const Session& s) { return PI::assign(*this, s); }
+void Session::commit() { impl->commit(); }
+void Session::rollback() { impl->rollback(); }
+void Session::acknowledge() { impl->acknowledge(); }
+void Session::reject(Message& m) { impl->reject(m); }
+void Session::close() { impl->close(); }
+
+Sender Session::createSender(const Address& address)
+{
+    return impl->createSender(address);
+}
+Receiver Session::createReceiver(const Address& address)
+{
+    return impl->createReceiver(address);
+}
+
+Sender Session::createSender(const std::string& address)
+{ 
+    return impl->createSender(Address(address)); 
+}
+Receiver Session::createReceiver(const std::string& address)
+{ 
+    return impl->createReceiver(Address(address)); 
+}
+
+void Session::sync()
+{
+    impl->sync();
+}
+
+void Session::flush()
+{
+    impl->flush();
+}
+
+bool Session::nextReceiver(Receiver& receiver, qpid::sys::Duration timeout)
+{
+    return impl->nextReceiver(receiver, timeout);
+}
+
+
+Receiver Session::nextReceiver(qpid::sys::Duration timeout)
+{
+    return impl->nextReceiver(timeout);
+}
+
+uint32_t Session::available() { return impl->available(); }
+uint32_t Session::pendingAck() { return impl->pendingAck(); }
+
+Sender Session::getSender(const std::string& name) const
+{ 
+    return impl->getSender(name); 
+}
+Receiver Session::getReceiver(const std::string& name) const
+{ 
+    return impl->getReceiver(name); 
+}
+
+Connection Session::getConnection() const
+{ 
+    return impl->getConnection(); 
+}
+
+KeyError::KeyError(const std::string& msg) : Exception(msg) {}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/SessionImpl.h b/cpp/src/qpid/messaging/SessionImpl.h
new file mode 100644
index 0000000000..164a6f6bc9
--- /dev/null
+++ b/cpp/src/qpid/messaging/SessionImpl.h
@@ -0,0 +1,64 @@
+#ifndef QPID_MESSAGING_SESSIONIMPL_H
+#define QPID_MESSAGING_SESSIONIMPL_H
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/RefCounted.h"
+#include <string>
+#include "qpid/sys/Time.h"
+
+namespace qpid {
+namespace client {
+}
+
+namespace messaging {
+
+class Address;
+class Connection;
+class Message;
+class Sender;
+class Receiver;
+
+class SessionImpl : public virtual qpid::RefCounted
+{
+  public:
+    virtual ~SessionImpl() {}
+    virtual void commit() = 0;
+    virtual void rollback() = 0;
+    virtual void acknowledge() = 0;
+    virtual void reject(Message&) = 0;
+    virtual void close() = 0;
+    virtual void sync() = 0;
+    virtual void flush() = 0;
+    virtual Sender createSender(const Address& address) = 0;
+    virtual Receiver createReceiver(const Address& address) = 0;
+    virtual bool nextReceiver(Receiver& receiver, qpid::sys::Duration timeout) = 0;
+    virtual Receiver nextReceiver(qpid::sys::Duration timeout) = 0;
+    virtual uint32_t available() = 0;
+    virtual uint32_t pendingAck() = 0;
+    virtual Sender getSender(const std::string& name) const = 0;
+    virtual Receiver getReceiver(const std::string& name) const = 0;
+    virtual Connection getConnection() const = 0;
+  private:
+};
+}} // namespace qpid::messaging
+
+#endif  /*!QPID_MESSAGING_SESSIONIMPL_H*/
diff --git a/cpp/src/qpid/messaging/Variant.cpp b/cpp/src/qpid/messaging/Variant.cpp
new file mode 100644
index 0000000000..9c2f92f47a
--- /dev/null
+++ b/cpp/src/qpid/messaging/Variant.cpp
@@ -0,0 +1,659 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qpid/messaging/Variant.h"
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <algorithm>
+#include <sstream>
+
+namespace qpid {
+namespace messaging {
+
+InvalidConversion::InvalidConversion(const std::string& msg) : Exception(msg) {}
+
+
+namespace {
+std::string EMPTY;
+}
+
+class VariantImpl
+{
+  public:
+    VariantImpl();
+    VariantImpl(bool);
+    VariantImpl(uint8_t);
+    VariantImpl(uint16_t);
+    VariantImpl(uint32_t);
+    VariantImpl(uint64_t);
+    VariantImpl(int8_t);
+    VariantImpl(int16_t);
+    VariantImpl(int32_t);
+    VariantImpl(int64_t);
+    VariantImpl(float);
+    VariantImpl(double);
+    VariantImpl(const std::string&);
+    VariantImpl(const Variant::Map&);
+    VariantImpl(const Variant::List&);
+    ~VariantImpl();
+
+    VariantType getType() const;
+
+    bool asBool() const;
+    uint8_t asUint8() const;
+    uint16_t asUint16() const;
+    uint32_t asUint32() const;
+    uint64_t asUint64() const;
+    int8_t asInt8() const;
+    int16_t asInt16() const;
+    int32_t asInt32() const;
+    int64_t asInt64() const;
+    float asFloat() const;
+    double asDouble() const;
+    std::string asString() const;
+
+    const Variant::Map& asMap() const;
+    Variant::Map& asMap();
+    const Variant::List& asList() const;
+    Variant::List& asList();
+
+    const std::string& getString() const;
+    std::string& getString();
+
+    void setEncoding(const std::string&);
+    const std::string& getEncoding() const;
+
+    bool isEqualTo(VariantImpl&) const;
+    bool isEquivalentTo(VariantImpl&) const;
+
+    static VariantImpl* create(const Variant&);    
+  private:
+    const VariantType type;
+    union {
+        bool b;
+        uint8_t ui8;
+        uint16_t ui16;
+        uint32_t ui32;
+        uint64_t ui64;
+        int8_t i8;
+        int16_t i16;
+        int32_t i32;
+        int64_t i64;
+        float f;
+        double d;
+        void* v;//variable width data
+    } value;
+    std::string encoding;//optional encoding for variable length data
+
+    std::string getTypeName(VariantType type) const;
+    template<class T> T convertFromString() const
+    {
+        std::string* s = reinterpret_cast<std::string*>(value.v);
+        try {
+            return boost::lexical_cast<T>(*s);
+        } catch(const boost::bad_lexical_cast&) {
+            throw InvalidConversion(QPID_MSG("Cannot convert " << *s));
+        }
+    }
+};
+
+
+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 VAR_STRING:
+        delete reinterpret_cast<std::string*>(value.v);
+        break;
+      case VAR_MAP:
+        delete reinterpret_cast<Variant::Map*>(value.v);
+        break;
+      case VAR_LIST:
+        delete reinterpret_cast<Variant::List*>(value.v);
+        break;
+      default:
+        break;
+    }
+}
+
+VariantType VariantImpl::getType() const { return type; }
+
+namespace {
+
+bool same_char(char a, char b) 
+{
+    return toupper(a) == toupper(b);
+}
+
+bool caseInsensitiveMatch(const std::string& a, const std::string& b)
+{
+    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), &same_char);
+}
+
+const std::string TRUE("True");
+const std::string FALSE("False");
+
+bool toBool(const std::string& s)
+{
+    if (caseInsensitiveMatch(s, TRUE)) return true;
+    if (caseInsensitiveMatch(s, FALSE)) return false;
+    try { return boost::lexical_cast<int>(s); } catch(const boost::bad_lexical_cast&) {}
+    throw InvalidConversion(QPID_MSG("Cannot convert " << s << " to bool"));    
+}
+
+template <class T> std::string toString(const T& t)
+{
+    std::stringstream out;
+    out << t;
+    return out.str();
+}
+
+template <class T> bool equal(const T& a, const T& b)
+{
+    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
+}
+
+}
+
+bool VariantImpl::asBool() const
+{
+    switch(type) {
+      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 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 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 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 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 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 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 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 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 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 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 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);
+      case VAR_LIST: return toString(asList());
+      case VAR_MAP: return toString(asMap());
+      default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_STRING)));
+    }
+}
+
+bool VariantImpl::isEqualTo(VariantImpl& other) const
+{
+    if (type == other.type) {
+        switch(type) {
+          case VAR_VOID: return true;
+          case VAR_BOOL: return value.b == other.value.b;
+          case VAR_UINT8: return value.ui8 == other.value.ui8;
+          case VAR_UINT16: return value.ui16 == other.value.ui16;
+          case VAR_UINT32: return value.ui32 == other.value.ui32;
+          case VAR_UINT64: return value.ui64 == other.value.ui64;
+          case VAR_INT8: return value.i8 == other.value.i8;
+          case VAR_INT16: return value.i16 == other.value.i16;
+          case VAR_INT32: return value.i32 == other.value.i32;
+          case VAR_INT64: return value.i64 == other.value.i64;
+          case VAR_DOUBLE: return value.d == other.value.d;
+          case VAR_FLOAT: return value.f == other.value.f;
+          case VAR_STRING: return *reinterpret_cast<std::string*>(value.v) 
+                == *reinterpret_cast<std::string*>(other.value.v);
+          case VAR_LIST: return equal(asList(), other.asList());
+          case VAR_MAP: return equal(asMap(), other.asMap());
+        }
+    }
+    return false;
+}
+
+const Variant::Map& VariantImpl::asMap() const
+{
+    switch(type) {
+      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 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 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 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 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."));
+    }
+}
+
+const std::string& VariantImpl::getString() const
+{
+    switch(type) {
+      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."));
+    }
+}
+
+void VariantImpl::setEncoding(const std::string& s) { encoding = s; }
+const std::string& VariantImpl::getEncoding() const { return encoding; }
+
+std::string VariantImpl::getTypeName(VariantType type) const
+{
+    switch (type) {
+      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
+}
+
+VariantImpl* VariantImpl::create(const Variant& v) 
+{
+    switch (v.getType()) {
+      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();
+    }
+}
+
+Variant::Variant() : impl(new VariantImpl()) {}
+Variant::Variant(bool b) : impl(new VariantImpl(b)) {}
+Variant::Variant(uint8_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(uint16_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(uint32_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(uint64_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(int8_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(int16_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(int32_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(int64_t i) : impl(new VariantImpl(i)) {}
+Variant::Variant(float f) : impl(new VariantImpl(f)) {}
+Variant::Variant(double d) : impl(new VariantImpl(d)) {}
+Variant::Variant(const std::string& s) : impl(new VariantImpl(s)) {}
+Variant::Variant(const char* s) : impl(new VariantImpl(std::string(s))) {}
+Variant::Variant(const Map& m) : impl(new VariantImpl(m)) {}
+Variant::Variant(const List& l) : impl(new VariantImpl(l)) {}
+Variant::Variant(const Variant& v) : impl(VariantImpl::create(v)) {}
+
+Variant::~Variant() { if (impl) delete impl; }
+
+void Variant::reset()
+{
+    if (impl) delete impl;
+    impl = new VariantImpl();
+}
+
+
+Variant& Variant::operator=(bool b)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(b);
+    return *this;
+}
+
+Variant& Variant::operator=(uint8_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(uint16_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(uint32_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(uint64_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+
+Variant& Variant::operator=(int8_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(int16_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(int32_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+Variant& Variant::operator=(int64_t i)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(i);
+    return *this;
+}
+
+Variant& Variant::operator=(float f)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(f);
+    return *this;
+}
+Variant& Variant::operator=(double d)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(d);
+    return *this;
+}
+
+Variant& Variant::operator=(const std::string& s)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(s);
+    return *this;
+}
+
+Variant& Variant::operator=(const char* s)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(std::string(s));
+    return *this;
+}
+
+Variant& Variant::operator=(const Map& m)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(m);
+    return *this;
+}
+
+Variant& Variant::operator=(const List& l)
+{
+    if (impl) delete impl;
+    impl = new VariantImpl(l);
+    return *this;
+}
+
+Variant& Variant::operator=(const Variant& v)
+{
+    if (impl) delete impl;
+    impl = VariantImpl::create(v);
+    return *this;
+}
+
+VariantType Variant::getType() const { return impl->getType(); }
+bool Variant::isVoid() const { return impl->getType() == VAR_VOID; }
+bool Variant::asBool() const { return impl->asBool(); }
+uint8_t Variant::asUint8() const { return impl->asUint8(); }
+uint16_t Variant::asUint16() const { return impl->asUint16(); }
+uint32_t Variant::asUint32() const { return impl->asUint32(); }
+uint64_t Variant::asUint64() const { return impl->asUint64(); }
+int8_t Variant::asInt8() const { return impl->asInt8(); }
+int16_t Variant::asInt16() const { return impl->asInt16(); }
+int32_t Variant::asInt32() const { return impl->asInt32(); }
+int64_t Variant::asInt64() const { return impl->asInt64(); }
+float Variant::asFloat() const { return impl->asFloat(); }
+double Variant::asDouble() const { return impl->asDouble(); }
+std::string Variant::asString() const { return impl->asString(); }
+const Variant::Map& Variant::asMap() const { return impl->asMap(); }
+Variant::Map& Variant::asMap() { return impl->asMap(); }
+const Variant::List& Variant::asList() const { return impl->asList(); }
+Variant::List& Variant::asList() { return impl->asList(); }
+const std::string& Variant::getString() const { return impl->getString(); }
+std::string& Variant::getString() { return impl->getString(); }
+void Variant::setEncoding(const std::string& s) { impl->setEncoding(s); }
+const std::string& Variant::getEncoding() const { return impl->getEncoding(); }
+
+Variant::operator bool() const { return asBool(); }
+Variant::operator uint8_t() const { return asUint8(); }
+Variant::operator uint16_t() const { return asUint16(); }
+Variant::operator uint32_t() const { return asUint32(); }
+Variant::operator uint64_t() const { return asUint64(); }
+Variant::operator int8_t() const { return asInt8(); }
+Variant::operator int16_t() const { return asInt16(); }
+Variant::operator int32_t() const { return asInt32(); }
+Variant::operator int64_t() const { return asInt64(); }
+Variant::operator float() const { return asFloat(); }
+Variant::operator double() const { return asDouble(); }
+Variant::operator const char*() const { return asString().c_str(); }
+
+std::ostream& operator<<(std::ostream& out, const Variant::Map& map)
+{
+    out << "{";
+    for (Variant::Map::const_iterator i = map.begin(); i != map.end(); ++i) {
+        if (i != map.begin()) out << ", ";
+        out << i->first << ":" << i->second;
+    }
+    out << "}";
+    return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const Variant::List& list)
+{
+    out << "[";
+    for (Variant::List::const_iterator i = list.begin(); i != list.end(); ++i) {
+        if (i != list.begin()) out << ", ";
+        out << *i;
+    }
+    out << "]";
+    return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const Variant& value)
+{
+    switch (value.getType()) {
+      case VAR_MAP:
+        out << value.asMap();
+        break;
+      case VAR_LIST:
+        out << value.asList();
+        break;
+      case VAR_VOID:
+        out << "<void>";
+        break;
+      default:
+        out << value.asString();
+        break;
+    }
+    return out;    
+}
+
+bool operator==(const Variant& a, const Variant& b)
+{
+    return a.isEqualTo(b);
+}
+
+bool Variant::isEqualTo(const Variant& other) const
+{
+    return impl->isEqualTo(*other.impl);
+}
+
+}} // namespace qpid::messaging