diff --git a/shims/qpid-proton-cpp/src/qpidit/amqp_large_content_test/Receiver.cpp b/shims/qpid-proton-cpp/src/qpidit/amqp_large_content_test/Receiver.cpp
index 615894a..b5beac6 100644
--- a/shims/qpid-proton-cpp/src/qpidit/amqp_large_content_test/Receiver.cpp
+++ b/shims/qpid-proton-cpp/src/qpidit/amqp_large_content_test/Receiver.cpp
@@ -101,39 +101,39 @@
 
         std::pair<uint32_t, uint32_t> Receiver::getTestListSizeMb(const proton::value& pvTestList) {
             // Uniform elt size assumed
-            const std::vector<proton::value>& testList(pvTestList.get<std::vector<proton::value> >());
+            const std::vector<proton::value>& testList(proton::get<std::vector<proton::value> >(pvTestList));
             if (testList.empty()) {
                 std::ostringstream oss;
                 oss << _testName << "::Receiver::getTestListSizeMb: List empty";
                 throw qpidit::ArgumentError(oss.str());
             }
-            std::string elt = testList[0].get<std::string>();
+            std::string elt = proton::get<std::string>(testList[0]);
             uint32_t numElements = testList.size();
             return std::pair<uint32_t, uint32_t>(numElements * elt.size() / 1024 / 1024, numElements);
         }
 
         std::pair<uint32_t, uint32_t> Receiver::getTestMapSizeMb(const proton::value& pvTestMap) {
             // Uniform elt size assumed
-            const std::map<std::string, proton::value>& testMap(pvTestMap.get<std::map<std::string, proton::value> >());
+            const std::map<std::string, proton::value>& testMap(proton::get<std::map<std::string, proton::value> >(pvTestMap));
             if (testMap.empty()) {
                 std::ostringstream oss;
                 oss << _testName << "::Receiver::getTestMapSizeMb: Map empty";
                 throw qpidit::ArgumentError(oss.str());
             }
-            std::string elt = testMap.begin()->second.get<std::string>();
+            std::string elt = proton::get<std::string>(testMap.begin()->second);
             uint32_t numElements = testMap.size();
             return std::pair<uint32_t, uint32_t>(numElements * elt.size() / 1024 / 1024, numElements);
         }
 
         uint32_t Receiver::getTestStringSizeMb(const proton::value& testString) {
             if (_amqpType.compare("binary") == 0) {
-                return testString.get<proton::binary>().size() / 1024 / 1024;
+                return proton::get<proton::binary>(testString).size() / 1024 / 1024;
             }
             if (_amqpType.compare("string") == 0) {
-                return testString.get<std::string>().size() / 1024 / 1024;
+                return proton::get<std::string>(testString).size() / 1024 / 1024;
             }
             if (_amqpType.compare("symbol") == 0) {
-                return testString.get<proton::symbol>().size() / 1024 / 1024;
+                return proton::get<proton::symbol>(testString).size() / 1024 / 1024;
             }
         }
 
diff --git a/shims/qpid-proton-cpp/src/qpidit/amqp_types_test/Receiver.cpp b/shims/qpid-proton-cpp/src/qpidit/amqp_types_test/Receiver.cpp
index d16e0eb..075a2f7 100644
--- a/shims/qpid-proton-cpp/src/qpidit/amqp_types_test/Receiver.cpp
+++ b/shims/qpid-proton-cpp/src/qpidit/amqp_types_test/Receiver.cpp
@@ -71,51 +71,51 @@
                         _receivedValueList.append("None");
                     } else if (_amqpType.compare("boolean") == 0) {
                         checkMessageType(m, proton::BOOLEAN);
-                        _receivedValueList.append(m.body().get<bool>() ? "True": "False");
+                        _receivedValueList.append(proton::get<bool>(m.body()) ? "True": "False");
                     } else if (_amqpType.compare("ubyte") == 0) {
                         checkMessageType(m, proton::UBYTE);
-                        _receivedValueList.append(toHexStr<uint8_t>(m.body().get<uint8_t>()));
+                        _receivedValueList.append(toHexStr<uint8_t>(proton::get<uint8_t>(m.body())));
                     } else if (_amqpType.compare("ushort") == 0) {
                         checkMessageType(m, proton::USHORT);
-                        _receivedValueList.append(toHexStr<uint16_t>(m.body().get<uint16_t>()));
+                        _receivedValueList.append(toHexStr<uint16_t>(proton::get<uint16_t>(m.body())));
                     } else if (_amqpType.compare("uint") == 0) {
                         checkMessageType(m, proton::UINT);
-                        _receivedValueList.append(toHexStr<uint32_t>(m.body().get<uint32_t>()));
+                        _receivedValueList.append(toHexStr<uint32_t>(proton::get<uint32_t>(m.body())));
                     } else if (_amqpType.compare("ulong") == 0) {
                         checkMessageType(m, proton::ULONG);
-                        _receivedValueList.append(toHexStr<uint64_t>(m.body().get<uint64_t>()));
+                        _receivedValueList.append(toHexStr<uint64_t>(proton::get<uint64_t>(m.body())));
                     } else if (_amqpType.compare("byte") == 0) {
                         checkMessageType(m, proton::BYTE);
-                        _receivedValueList.append(toHexStr<int8_t>(m.body().get<int8_t>()));
+                        _receivedValueList.append(toHexStr<int8_t>(proton::get<int8_t>(m.body())));
                     } else if (_amqpType.compare("short") == 0) {
                         checkMessageType(m, proton::SHORT);
-                        _receivedValueList.append(toHexStr<int16_t>(m.body().get<int16_t>()));
+                        _receivedValueList.append(toHexStr<int16_t>(proton::get<int16_t>(m.body())));
                     } else if (_amqpType.compare("int") == 0) {
                         checkMessageType(m, proton::INT);
-                        _receivedValueList.append(toHexStr<int32_t>(m.body().get<int32_t>()));
+                        _receivedValueList.append(toHexStr<int32_t>(proton::get<int32_t>(m.body())));
                     } else if (_amqpType.compare("long") == 0) {
                         checkMessageType(m, proton::LONG);
-                        _receivedValueList.append(toHexStr<int64_t>(m.body().get<int64_t>()));
+                        _receivedValueList.append(toHexStr<int64_t>(proton::get<int64_t>(m.body())));
                     } else if (_amqpType.compare("float") == 0) {
                         checkMessageType(m, proton::FLOAT);
-                        float f = m.body().get<float>();
+                        float f = proton::get<float>(m.body());
                         _receivedValueList.append(toHexStr<uint32_t>(*((uint32_t*)&f), true));
                     } else if (_amqpType.compare("double") == 0) {
                         checkMessageType(m, proton::DOUBLE);
-                        double d = m.body().get<double>();
+                        double d = proton::get<double>(m.body());
                         _receivedValueList.append(toHexStr<uint64_t>(*((uint64_t*)&d), true));
                     } else if (_amqpType.compare("decimal32") == 0) {
                         checkMessageType(m, proton::DECIMAL32);
-                        _receivedValueList.append(byteArrayToHexStr(m.body().get<proton::decimal32>()));
+                        _receivedValueList.append(byteArrayToHexStr(proton::get<proton::decimal32>(m.body())));
                     } else if (_amqpType.compare("decimal64") == 0) {
                         checkMessageType(m, proton::DECIMAL64);
-                        _receivedValueList.append(byteArrayToHexStr(m.body().get<proton::decimal64>()));
+                        _receivedValueList.append(byteArrayToHexStr(proton::get<proton::decimal64>(m.body())));
                     } else if (_amqpType.compare("decimal128") == 0) {
                         checkMessageType(m, proton::DECIMAL128);
-                        _receivedValueList.append(byteArrayToHexStr(m.body().get<proton::decimal128>()));
+                        _receivedValueList.append(byteArrayToHexStr(proton::get<proton::decimal128>(m.body())));
                     } else if (_amqpType.compare("char") == 0) {
                         checkMessageType(m, proton::CHAR);
-                        wchar_t c = m.body().get<wchar_t>();
+                        wchar_t c = proton::get<wchar_t>(m.body());
                         std::stringstream oss;
                         if (c < 0x7f && std::iswprint(c)) {
                             oss << (char)c;
@@ -126,22 +126,22 @@
                     } else if (_amqpType.compare("timestamp") == 0) {
                         checkMessageType(m, proton::TIMESTAMP);
                         std::ostringstream oss;
-                        oss << "0x" << std::hex << m.body().get<proton::timestamp>().milliseconds();
+                        oss << "0x" << std::hex << proton::get<proton::timestamp>(m.body()).milliseconds();
                         _receivedValueList.append(oss.str());
                     } else if (_amqpType.compare("uuid") == 0) {
                         checkMessageType(m, proton::UUID);
                         std::ostringstream oss;
-                        oss << m.body().get<proton::uuid>();
+                        oss << proton::get<proton::uuid>(m.body());
                         _receivedValueList.append(oss.str());
                     } else if (_amqpType.compare("binary") == 0) {
                         checkMessageType(m, proton::BINARY);
-                        _receivedValueList.append(std::string(m.body().get<proton::binary>()));
+                        _receivedValueList.append(std::string(proton::get<proton::binary>(m.body())));
                     } else if (_amqpType.compare("string") == 0) {
                         checkMessageType(m, proton::STRING);
-                        _receivedValueList.append(m.body().get<std::string>());
+                        _receivedValueList.append(proton::get<std::string>(m.body()));
                     } else if (_amqpType.compare("symbol") == 0) {
                         checkMessageType(m, proton::SYMBOL);
-                        _receivedValueList.append(m.body().get<proton::symbol>());
+                        _receivedValueList.append(proton::get<proton::symbol>(m.body()));
                     } else if (_amqpType.compare("list") == 0) {
                         checkMessageType(m, proton::LIST);
                         Json::Value jsonList(Json::arrayValue);
@@ -200,25 +200,25 @@
         //static
         Json::Value& Receiver::getMap(Json::Value& jsonMap, const proton::value& val) {
             std::map<proton::value, proton::value> msgMap;
-            val.get(msgMap);
+            proton::get(val, msgMap);
             for (std::map<proton::value, proton::value>::const_iterator i = msgMap.begin(); i != msgMap.end(); ++i) {
                 switch (i->second.type()) {
                 case proton::LIST:
                 {
                     Json::Value jsonSubList(Json::arrayValue);
-                    jsonMap[i->first.get<std::string>()] = getSequence(jsonSubList, i->second);
+                    jsonMap[proton::get<std::string>(i->first)] = getSequence(jsonSubList, i->second);
                     break;
                 }
                 case proton::MAP:
                 {
                     Json::Value jsonSubMap(Json::objectValue);
-                    jsonMap[i->first.get<std::string>()] = getMap(jsonSubMap, i->second);
+                    jsonMap[proton::get<std::string>(i->first)] = getMap(jsonSubMap, i->second);
                     break;
                 }
                 case proton::ARRAY:
                     break;
                 case proton::STRING:
-                    jsonMap[i->first.get<std::string>()] = Json::Value(i->second.get<std::string>());
+                    jsonMap[proton::get<std::string>(i->first)] = Json::Value(proton::get<std::string>(i->second));
                     break;
                 default:
                     throw qpidit::IncorrectValueTypeError(i->second);
@@ -230,7 +230,7 @@
         //static
         Json::Value& Receiver::getSequence(Json::Value& jsonList, const proton::value& val) {
             std::vector<proton::value> msgList;
-            val.get(msgList);
+            proton::get(val, msgList);
             for (std::vector<proton::value>::const_iterator i=msgList.begin(); i!=msgList.end(); ++i) {
                 switch ((*i).type()) {
                 case proton::LIST:
@@ -248,7 +248,7 @@
                 case proton::ARRAY:
                     break;
                 case proton::STRING:
-                    jsonList.append(Json::Value((*i).get<std::string>()));
+                    jsonList.append(Json::Value(proton::get<std::string>(*i)));
                     break;
                 default:
                     throw qpidit::IncorrectValueTypeError(*i);
diff --git a/shims/qpid-proton-cpp/src/qpidit/jms_hdrs_props_test/Receiver.cpp b/shims/qpid-proton-cpp/src/qpidit/jms_hdrs_props_test/Receiver.cpp
index 269a47e..3581b0f 100644
--- a/shims/qpid-proton-cpp/src/qpidit/jms_hdrs_props_test/Receiver.cpp
+++ b/shims/qpid-proton-cpp/src/qpidit/jms_hdrs_props_test/Receiver.cpp
@@ -82,7 +82,7 @@
                 if (_received < _expected) {
                     int8_t t = qpidit::JMS_MESSAGE_TYPE; // qpidit::JMS_MESSAGE_TYPE has value 0
                     try {
-                        t = m.message_annotations().get(proton::symbol("x-opt-jms-msg-type")).get<int8_t>();
+                        t = proton::get<int8_t>(m.message_annotations().get(proton::symbol("x-opt-jms-msg-type")));
                     } catch (const proton::conversion_error& e) {
                         std::cout << "JmsReceiver::on_message(): Error converting value for annotation \"x-opt-jms-msg-type\": " << e.what() << std::endl;
                         throw;
@@ -163,7 +163,7 @@
             }
             std::string subType(_subTypeList[_subTypeIndex]);
             std::map<std::string, proton::value> m;
-            msg.body().get(m);
+            proton::get(msg.body(), m);
             for (std::map<std::string, proton::value>::const_iterator i=m.begin(); i!=m.end(); ++i) {
                 std::string key = i->first;
                 if (subType.compare(key.substr(0, key.size()-3)) != 0) {
@@ -171,29 +171,29 @@
                 }
                 proton::value val = i->second;
                 if (subType.compare("boolean") == 0) {
-                    _receivedSubTypeList.append(val.get<bool>() ? Json::Value("True") : Json::Value("False"));
+                    _receivedSubTypeList.append(proton::get<bool>(val) ? Json::Value("True") : Json::Value("False"));
                 } else if (subType.compare("byte") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(val.get<int8_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(proton::get<int8_t>(val))));
                 } else if (subType.compare("bytes") == 0) {
-                    _receivedSubTypeList.append(Json::Value(std::string(val.get<proton::binary>())));
+                    _receivedSubTypeList.append(Json::Value(std::string(proton::get<proton::binary>(val))));
                 } else if (subType.compare("char") == 0) {
                     std::ostringstream oss;
-                    oss << (char)val.get<wchar_t>();
+                    oss << (char)proton::get<wchar_t>(val);
                     _receivedSubTypeList.append(Json::Value(oss.str()));
                 } else if (subType.compare("double") == 0) {
-                    double d = val.get<double>();
+                    double d = proton::get<double>(val);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(*((int64_t*)&d), true, false)));
                 } else if (subType.compare("float") == 0) {
-                    float f = val.get<float>();
+                    float f = proton::get<float>(val);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(*((int32_t*)&f), true, false)));
                 } else if (subType.compare("int") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(val.get<int32_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(proton::get<int32_t>(val))));
                 } else if (subType.compare("long") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(val.get<int64_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(proton::get<int64_t>(val))));
                 } else if (subType.compare("short") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(val.get<int16_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(proton::get<int16_t>(val))));
                 } else if (subType.compare("string") == 0) {
-                    _receivedSubTypeList.append(Json::Value(val.get<std::string>()));
+                    _receivedSubTypeList.append(Json::Value(proton::get<std::string>(val)));
                 } else {
                     throw qpidit::UnknownJmsMessageSubTypeError(subType);
                 }
@@ -205,7 +205,7 @@
                 throw qpidit::IncorrectMessageBodyTypeError(_jmsMessageType, "JMS_BYTESMESSAGE_TYPE");
             }
             std::string subType(_subTypeList[_subTypeIndex]);
-            proton::binary body = msg.body().get<proton::binary>();
+            proton::binary body = proton::get<proton::binary>(msg.body());
             if (subType.compare("boolean") == 0) {
                 if (body.size() != 1) throw IncorrectMessageBodyLengthError("JmsReceiver::receiveJmsBytesMessage, subType=boolean", 1, body.size());
                 _receivedSubTypeList.append(body[0] ? Json::Value("True") : Json::Value("False"));
@@ -256,32 +256,32 @@
             }
             std::string subType(_subTypeList[_subTypeIndex]);
             std::vector<proton::value> l;
-            msg.body().get(l);
+            proton::get(msg.body(), l);
             for (std::vector<proton::value>::const_iterator i=l.begin(); i!=l.end(); ++i) {
                 if (subType.compare("boolean") == 0) {
-                    _receivedSubTypeList.append(i->get<bool>() ? Json::Value("True") : Json::Value("False"));
+                    _receivedSubTypeList.append(proton::get<bool>(*i) ? Json::Value("True") : Json::Value("False"));
                 } else if (subType.compare("byte") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(i->get<int8_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(proton::get<int8_t>(*i))));
                 } else if (subType.compare("bytes") == 0) {
-                    _receivedSubTypeList.append(Json::Value(std::string(i->get<proton::binary>())));
+                    _receivedSubTypeList.append(Json::Value(std::string(proton::get<proton::binary>(*i))));
                 } else if (subType.compare("char") == 0) {
                     std::ostringstream oss;
-                    oss << (char)i->get<wchar_t>();
+                    oss << (char)proton::get<wchar_t>(*i);
                     _receivedSubTypeList.append(Json::Value(oss.str()));
                 } else if (subType.compare("double") == 0) {
-                    double d = i->get<double>();
+                    double d = proton::get<double>(*i);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(*((int64_t*)&d), true, false)));
                 } else if (subType.compare("float") == 0) {
-                    float f = i->get<float>();
+                    float f = proton::get<float>(*i);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(*((int32_t*)&f), true, false)));
                 } else if (subType.compare("int") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(i->get<int32_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(proton::get<int32_t>(*i))));
                 } else if (subType.compare("long") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(i->get<int64_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(proton::get<int64_t>(*i))));
                 } else if (subType.compare("short") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(i->get<int16_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(proton::get<int16_t>(*i))));
                 } else if (subType.compare("string") == 0) {
-                    _receivedSubTypeList.append(Json::Value(i->get<std::string>()));
+                    _receivedSubTypeList.append(Json::Value(proton::get<std::string>(*i)));
                 } else {
                     throw qpidit::UnknownJmsMessageSubTypeError(subType);
                 }
@@ -293,7 +293,7 @@
             if(_jmsMessageType.compare("JMS_TEXTMESSAGE_TYPE") != 0) {
                 throw qpidit::IncorrectMessageBodyTypeError(_jmsMessageType, "JMS_TEXTMESSAGE_TYPE");
             }
-            _receivedSubTypeList.append(Json::Value(msg.body().get<std::string>()));
+            _receivedSubTypeList.append(Json::Value(proton::get<std::string>(msg.body())));
         }
 
         void Receiver::processMessageHeaders(const proton::message& msg) {
diff --git a/shims/qpid-proton-cpp/src/qpidit/jms_messages_test/Receiver.cpp b/shims/qpid-proton-cpp/src/qpidit/jms_messages_test/Receiver.cpp
index 7b2f058..2fdc526 100644
--- a/shims/qpid-proton-cpp/src/qpidit/jms_messages_test/Receiver.cpp
+++ b/shims/qpid-proton-cpp/src/qpidit/jms_messages_test/Receiver.cpp
@@ -67,7 +67,7 @@
                 if (_received < _expected) {
                     int8_t t = qpidit::JMS_MESSAGE_TYPE; // qpidit::JMS_MESSAGE_TYPE has value 0
                     try {
-                        t = m.message_annotations().get(proton::symbol("x-opt-jms-msg-type")).get<int8_t>();
+                        t = proton::get<int8_t>(m.message_annotations().get(proton::symbol("x-opt-jms-msg-type")));
                     } catch (const proton::conversion_error& e) {
                         std::cout << "JmsReceiver::on_message(): Error converting value for annotation \"x-opt-jms-msg-type\": " << e.what() << std::endl;
                         throw;
@@ -145,7 +145,7 @@
             }
             std::string subType(_subTypeList[_subTypeIndex]);
             std::map<std::string, proton::value> m;
-            msg.body().get(m);
+            proton::get(msg.body(), m);
             for (std::map<std::string, proton::value>::const_iterator i=m.begin(); i!=m.end(); ++i) {
                 std::string key = i->first;
                 if (subType.compare(key.substr(0, key.size()-3)) != 0) {
@@ -153,29 +153,29 @@
                 }
                 proton::value val = i->second;
                 if (subType.compare("boolean") == 0) {
-                    _receivedSubTypeList.append(val.get<bool>() ? Json::Value("True") : Json::Value("False"));
+                    _receivedSubTypeList.append(proton::get<bool>(val) ? Json::Value("True") : Json::Value("False"));
                 } else if (subType.compare("byte") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(val.get<int8_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(proton::get<int8_t>(val))));
                 } else if (subType.compare("bytes") == 0) {
-                    _receivedSubTypeList.append(Json::Value(std::string(val.get<proton::binary>())));
+                    _receivedSubTypeList.append(Json::Value(std::string(proton::get<proton::binary>(val))));
                 } else if (subType.compare("char") == 0) {
                     std::ostringstream oss;
-                    oss << (char)val.get<wchar_t>();
+                    oss << (char)proton::get<wchar_t>(val);
                     _receivedSubTypeList.append(Json::Value(oss.str()));
                 } else if (subType.compare("double") == 0) {
-                    double d = val.get<double>();
+                    double d = proton::get<double>(val);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(*((int64_t*)&d), true, false)));
                 } else if (subType.compare("float") == 0) {
-                    float f = val.get<float>();
+                    float f = proton::get<float>(val);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(*((int32_t*)&f), true, false)));
                 } else if (subType.compare("int") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(val.get<int32_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(proton::get<int32_t>(val))));
                 } else if (subType.compare("long") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(val.get<int64_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(proton::get<int64_t>(val))));
                 } else if (subType.compare("short") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(val.get<int16_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(proton::get<int16_t>(val))));
                 } else if (subType.compare("string") == 0) {
-                    _receivedSubTypeList.append(Json::Value(val.get<std::string>()));
+                    _receivedSubTypeList.append(Json::Value(proton::get<std::string>(val)));
                 } else {
                     throw qpidit::UnknownJmsMessageSubTypeError(subType);
                 }
@@ -187,7 +187,7 @@
                 throw qpidit::IncorrectMessageBodyTypeError(_jmsMessageType, "JMS_BYTESMESSAGE_TYPE");
             }
             std::string subType(_subTypeList[_subTypeIndex]);
-            proton::binary body = msg.body().get<proton::binary>();
+            proton::binary body = proton::get<proton::binary>(msg.body());
             if (subType.compare("boolean") == 0) {
                 if (body.size() != 1) throw IncorrectMessageBodyLengthError("JmsReceiver::receiveJmsBytesMessage, subType=boolean", 1, body.size());
                 _receivedSubTypeList.append(body[0] ? Json::Value("True") : Json::Value("False"));
@@ -238,32 +238,32 @@
             }
             std::string subType(_subTypeList[_subTypeIndex]);
             std::vector<proton::value> l;
-            msg.body().get(l);
+            proton::get(msg.body(), l);
             for (std::vector<proton::value>::const_iterator i=l.begin(); i!=l.end(); ++i) {
                 if (subType.compare("boolean") == 0) {
-                    _receivedSubTypeList.append(i->get<bool>() ? Json::Value("True") : Json::Value("False"));
+                    _receivedSubTypeList.append(proton::get<bool>(*i) ? Json::Value("True") : Json::Value("False"));
                 } else if (subType.compare("byte") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(i->get<int8_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int8_t>(proton::get<int8_t>(*i))));
                 } else if (subType.compare("bytes") == 0) {
-                    _receivedSubTypeList.append(Json::Value(std::string(i->get<proton::binary>())));
+                    _receivedSubTypeList.append(Json::Value(std::string(proton::get<proton::binary>(*i))));
                 } else if (subType.compare("char") == 0) {
                     std::ostringstream oss;
-                    oss << (char)i->get<wchar_t>();
+                    oss << (char)proton::get<wchar_t>(*i);
                     _receivedSubTypeList.append(Json::Value(oss.str()));
                 } else if (subType.compare("double") == 0) {
-                    double d = i->get<double>();
+                    double d = proton::get<double>(*i);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(*((int64_t*)&d), true, false)));
                 } else if (subType.compare("float") == 0) {
-                    float f = i->get<float>();
+                    float f = proton::get<float>(*i);
                     _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(*((int32_t*)&f), true, false)));
                 } else if (subType.compare("int") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(i->get<int32_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int32_t>(proton::get<int32_t>(*i))));
                 } else if (subType.compare("long") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(i->get<int64_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int64_t>(proton::get<int64_t>(*i))));
                 } else if (subType.compare("short") == 0) {
-                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(i->get<int16_t>())));
+                    _receivedSubTypeList.append(Json::Value(toHexStr<int16_t>(proton::get<int16_t>(*i))));
                 } else if (subType.compare("string") == 0) {
-                    _receivedSubTypeList.append(Json::Value(i->get<std::string>()));
+                    _receivedSubTypeList.append(Json::Value(proton::get<std::string>(*i)));
                 } else {
                     throw qpidit::UnknownJmsMessageSubTypeError(subType);
                 }
@@ -275,7 +275,7 @@
             if(_jmsMessageType.compare("JMS_TEXTMESSAGE_TYPE") != 0) {
                 throw qpidit::IncorrectMessageBodyTypeError(_jmsMessageType, "JMS_TEXTMESSAGE_TYPE");
             }
-            _receivedSubTypeList.append(Json::Value(msg.body().get<std::string>()));
+            _receivedSubTypeList.append(Json::Value(proton::get<std::string>(msg.body())));
         }
 
     } /* namespace jms_messages_test */