Sluift: Add support for Lua 5.3

This patch adds support for Lua 5.3, while keeping support for Lua 5.1 (a build with the bundled Lua succeeds) Test-information: Builds cleanly on Lua 5.1, 5.2 and Lua 5.3. Tests that make use of Sluift work with both Lua 5.2 and Lua 5.3 Change-Id: I4cbe2eb09ec8c753d8624047f5456be1de72c679
author: Roger Planas <roger.planas@isode.com> 2017-07-04 11:03:55 (GMT)
committer: Roger Planas <roger.planas@isode.com> 2017-10-30 12:25:43 (GMT)
commit: c29df10f0ab47db63509634fb1661ff55b8b47b3 (patch)
tree: ebf7486b653b554e3122c3509da17e17ef25f312 /Sluift/ElementConvertors
parent: ed25c7d2fe46dca4edecd359755b15e16620056e (diff)
download: swift-c29df10f0ab47db63509634fb1661ff55b8b47b3.zip
swift-c29df10f0ab47db63509634fb1661ff55b8b47b3.tar.bz2
13 files changed, 15 insertions, 15 deletions
diff --git a/Sluift/ElementConvertors/FormConvertor.cpp b/Sluift/ElementConvertors/FormConvertor.cpp
index 90fd9fe..245e0f9 100644
--- a/Sluift/ElementConvertors/FormConvertor.cpp
+++ b/Sluift/ElementConvertors/FormConvertor.cpp
@@ -2,76 +2,76 @@
  * Copyright (c) 2013-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/FormConvertor.h>
 
 #include <memory>
 #include <sstream>
 
 #include <boost/assign/list_of.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/Lua/Check.h>
 #include <Sluift/Lua/Value.h>
 
 using namespace Swift;
 
 namespace {
     int formIndex(lua_State* L) {
         lua_getfield(L, 1, "fields");
         if (lua_type(L, -1) != LUA_TTABLE) {
             return 0;
         }
         int index = Lua::absoluteOffset(L, -1);
         lua_pushnil(L);
         for (lua_pushnil(L); lua_next(L, index) != 0; ) {
             lua_getfield(L, -1, "name");
-            if (lua_equal(L, -1, 2)) {
+            if (lua_compare(L, -1, 2, LUA_OPEQ)) {
                 lua_pop(L, 1);
                 return 1;
             }
             lua_pop(L, 2);
         }
         return 0;
     }
 
     int formNewIndex(lua_State* L) {
         lua_getfield(L, 1, "fields");
         bool foundField = false;
         if (lua_type(L, -1) == LUA_TTABLE) {
             for (lua_pushnil(L); lua_next(L, -2) != 0; ) {
                 lua_getfield(L, -1, "name");
-                if (lua_equal(L, -1, 2)) {
+                if (lua_compare(L, -1, 2, LUA_OPEQ)) {
                     lua_pushvalue(L, 3);
                     lua_setfield(L, -3, "value");
                     foundField = true;
                     lua_pop(L, 3);
                     break;
                 }
                 lua_pop(L, 2);
             }
         }
         lua_pop(L, 1);
 
         if (!foundField) {
             lua_pushvalue(L, 2);
             lua_pushvalue(L, 3);
             lua_rawset(L, 1);
         }
         return 0;
     }
 
     Lua::Table convertFieldToLua(std::shared_ptr<FormField> field) {
         Lua::Table luaField = boost::assign::map_list_of("name", Lua::valueRef(field->getName()));
         std::string type;
         switch (field->getType()) {
             case FormField::UnknownType: type = ""; break;
             case FormField::BooleanType: type = "boolean"; break;
             case FormField::FixedType: type = "fixed"; break;
             case FormField::HiddenType: type = "hidden"; break;
             case FormField::ListSingleType: type = "list-single"; break;
             case FormField::TextMultiType: type = "text-multi"; break;
             case FormField::TextPrivateType: type = "text-private"; break;
diff --git a/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp b/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
index c6ba09e..8f8a660 100644
--- a/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubAffiliationsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubAffiliationsConvertor::PubSubAffiliationsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubAffiliations>("pubsub_affiliations"),
         convertors(convertors) {
 }
 
 PubSubAffiliationsConvertor::~PubSubAffiliationsConvertor() {
 }
 
 std::shared_ptr<PubSubAffiliations> PubSubAffiliationsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubAffiliations> result = std::make_shared<PubSubAffiliations>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubAffiliation> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubAffiliation> payload = std::dynamic_pointer_cast<PubSubAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_affiliation"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setAffiliations(items);
     }
     return result;
 }
 
 void PubSubAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubAffiliations> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (!payload->getAffiliations().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getAffiliations()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp b/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
index ac86024..19ab09a 100644
--- a/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
@@ -12,61 +12,61 @@
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubEventItemConvertor::PubSubEventItemConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubEventItem>("pubsub_event_item"),
         convertors(convertors) {
 }
 
 PubSubEventItemConvertor::~PubSubEventItemConvertor() {
 }
 
 std::shared_ptr<PubSubEventItem> PubSubEventItemConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubEventItem> result = std::make_shared<PubSubEventItem>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "publisher");
     if (lua_isstring(L, -1)) {
         result->setPublisher(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "data");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<Payload> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setData(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "id");
     if (lua_isstring(L, -1)) {
         result->setID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubEventItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItem> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (payload->getPublisher()) {
         lua_pushstring(L, (*payload->getPublisher()).c_str());
         lua_setfield(L, -2, "publisher");
diff --git a/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp b/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
index 7a3cde1..66f798e 100644
--- a/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
@@ -7,78 +7,78 @@
 #include <Sluift/ElementConvertors/PubSubEventItemsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubEventItemsConvertor::PubSubEventItemsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubEventItems>("pubsub_event_items"),
         convertors(convertors) {
 }
 
 PubSubEventItemsConvertor::~PubSubEventItemsConvertor() {
 }
 
 std::shared_ptr<PubSubEventItems> PubSubEventItemsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubEventItems> result = std::make_shared<PubSubEventItems>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubEventItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubEventItem> payload = std::dynamic_pointer_cast<PubSubEventItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "retracts");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubEventRetract> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubEventRetract> payload = std::dynamic_pointer_cast<PubSubEventRetract>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_retract"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setRetracts(items);
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubEventItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItems> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubItemConvertor.cpp b/Sluift/ElementConvertors/PubSubItemConvertor.cpp
index 27fd4a3..b46419a 100644
--- a/Sluift/ElementConvertors/PubSubItemConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubItemConvertor.cpp
@@ -2,61 +2,61 @@
  * Copyright (c) 2013-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/PubSubItemConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubItemConvertor::PubSubItemConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubItem>("pubsub_item"),
         convertors(convertors) {
 }
 
 PubSubItemConvertor::~PubSubItemConvertor() {
 }
 
 std::shared_ptr<PubSubItem> PubSubItemConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubItem> result = std::make_shared<PubSubItem>();
     lua_getfield(L, -1, "data");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<Payload> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setData(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "id");
     if (lua_isstring(L, -1)) {
         result->setID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItem> payload) {
     lua_createtable(L, 0, 0);
     if (!payload->getData().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getData()) {
                 if (convertors->convertToLua(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
diff --git a/Sluift/ElementConvertors/PubSubItemsConvertor.cpp b/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
index 5fa1bd3..0bb8eb9 100644
--- a/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubItemsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubItemsConvertor::PubSubItemsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubItems>("pubsub_items"),
         convertors(convertors) {
 }
 
 PubSubItemsConvertor::~PubSubItemsConvertor() {
 }
 
 std::shared_ptr<PubSubItems> PubSubItemsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubItems> result = std::make_shared<PubSubItems>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_getfield(L, -1, "maximum_items");
     if (lua_isnumber(L, -1)) {
         result->setMaximumItems(boost::numeric_cast<unsigned int>(lua_tonumber(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "subscription_id");
     if (lua_isstring(L, -1)) {
         result->setSubscriptionID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItems> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
diff --git a/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp b/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
index ee8a8cb..9ca76fc 100644
--- a/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubOwnerAffiliationsConvertor::PubSubOwnerAffiliationsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubOwnerAffiliations>("pubsub_owner_affiliations"),
         convertors(convertors) {
 }
 
 PubSubOwnerAffiliationsConvertor::~PubSubOwnerAffiliationsConvertor() {
 }
 
 std::shared_ptr<PubSubOwnerAffiliations> PubSubOwnerAffiliationsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubOwnerAffiliations> result = std::make_shared<PubSubOwnerAffiliations>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubOwnerAffiliation> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubOwnerAffiliation> payload = std::dynamic_pointer_cast<PubSubOwnerAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_affiliation"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setAffiliations(items);
     }
     return result;
 }
 
 void PubSubOwnerAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerAffiliations> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getAffiliations().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getAffiliations()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
         }
     }
diff --git a/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp b/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
index 88085b5..3530efe 100644
--- a/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubOwnerSubscriptionsConvertor::PubSubOwnerSubscriptionsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubOwnerSubscriptions>("pubsub_owner_subscriptions"),
         convertors(convertors) {
 }
 
 PubSubOwnerSubscriptionsConvertor::~PubSubOwnerSubscriptionsConvertor() {
 }
 
 std::shared_ptr<PubSubOwnerSubscriptions> PubSubOwnerSubscriptionsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubOwnerSubscriptions> result = std::make_shared<PubSubOwnerSubscriptions>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubOwnerSubscription> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubOwnerSubscription> payload = std::dynamic_pointer_cast<PubSubOwnerSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_subscription"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setSubscriptions(items);
     }
     return result;
 }
 
 void PubSubOwnerSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerSubscriptions> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getSubscriptions().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getSubscriptions()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
         }
     }
diff --git a/Sluift/ElementConvertors/PubSubPublishConvertor.cpp b/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
index 63c97bc..d8a2742 100644
--- a/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
@@ -7,61 +7,61 @@
 #include <Sluift/ElementConvertors/PubSubPublishConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubPublishConvertor::PubSubPublishConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubPublish>("pubsub_publish"),
         convertors(convertors) {
 }
 
 PubSubPublishConvertor::~PubSubPublishConvertor() {
 }
 
 std::shared_ptr<PubSubPublish> PubSubPublishConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubPublish> result = std::make_shared<PubSubPublish>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubPublishConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubPublish> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubRetractConvertor.cpp b/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
index c070ad6..c27ad7d 100644
--- a/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
@@ -7,61 +7,61 @@
 #include <Sluift/ElementConvertors/PubSubRetractConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubRetractConvertor::PubSubRetractConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubRetract>("pubsub_retract"),
         convertors(convertors) {
 }
 
 PubSubRetractConvertor::~PubSubRetractConvertor() {
 }
 
 std::shared_ptr<PubSubRetract> PubSubRetractConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubRetract> result = std::make_shared<PubSubRetract>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "notify");
     if (lua_isboolean(L, -1)) {
         result->setNotify(lua_toboolean(L, -1));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubRetractConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubRetract> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
diff --git a/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp b/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
index 3712192..2325181 100644
--- a/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubSubscriptionsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubSubscriptionsConvertor::PubSubSubscriptionsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubSubscriptions>("pubsub_subscriptions"),
         convertors(convertors) {
 }
 
 PubSubSubscriptionsConvertor::~PubSubSubscriptionsConvertor() {
 }
 
 std::shared_ptr<PubSubSubscriptions> PubSubSubscriptionsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubSubscriptions> result = std::make_shared<PubSubSubscriptions>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubSubscription> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubSubscription> payload = std::dynamic_pointer_cast<PubSubSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_subscription"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setSubscriptions(items);
     }
     return result;
 }
 
 void PubSubSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubSubscriptions> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (!payload->getSubscriptions().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getSubscriptions()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/SecurityLabelConvertor.cpp b/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
index 21d9a8f..8bc323a 100644
--- a/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
+++ b/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
@@ -1,59 +1,59 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/SecurityLabelConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 using namespace Swift;
 
 SecurityLabelConvertor::SecurityLabelConvertor() :
         GenericLuaElementConvertor<SecurityLabel>("security_label") {
 }
 
 SecurityLabelConvertor::~SecurityLabelConvertor() {
 }
 
 std::shared_ptr<SecurityLabel> SecurityLabelConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<SecurityLabel> result = std::make_shared<SecurityLabel>();
     lua_getfield(L, -1, "equivalent_labels");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::string > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (lua_isstring(L, -1)) {
                 items.push_back(std::string(lua_tostring(L, -1)));
             }
             lua_pop(L, 1);
         }
 
         result->setEquivalentLabels(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "foreground_color");
     if (lua_isstring(L, -1)) {
         result->setForegroundColor(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "display_marking");
     if (lua_isstring(L, -1)) {
         result->setDisplayMarking(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "background_color");
     if (lua_isstring(L, -1)) {
         result->setBackgroundColor(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "label");
     if (lua_isstring(L, -1)) {
         result->setLabel(std::string(lua_tostring(L, -1)));
     }
diff --git a/Sluift/ElementConvertors/StanzaConvertor.h b/Sluift/ElementConvertors/StanzaConvertor.h
index bdaaad3..a7b4e4e 100644
--- a/Sluift/ElementConvertors/StanzaConvertor.h
+++ b/Sluift/ElementConvertors/StanzaConvertor.h
@@ -19,61 +19,61 @@
 
 namespace Swift {
     template <typename T> class StanzaConvertor : public GenericLuaElementConvertor<T> {
         public:
             StanzaConvertor(const std::string& tag)
             : GenericLuaElementConvertor<T>(tag) {
             }
 
             virtual ~StanzaConvertor() {
             }
 
             std::shared_ptr<T> getStanza(lua_State* L, LuaElementConvertors* convertors) {
                 std::shared_ptr<T> result = std::make_shared<T>();
                 lua_getfield(L, -1, "id");
                 if (lua_isstring(L, -1)) {
                     result->setID(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "from");
                 if (lua_isstring(L, -1)) {
                     result->setFrom(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "to");
                 if (lua_isstring(L, -1)) {
                     result->setTo(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "payloads");
                 if (lua_type(L, -1) == LUA_TTABLE) {
-                    for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+                    for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
                         lua_pushnumber(L, i + 1);
                         lua_gettable(L, -2);
                         if (!lua_isnil(L, -1)) {
                             std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1));
                             if (!!payload) {
                                 result->addPayload(payload);
                             }
                         }
                         lua_pop(L, 1);
                     }
                 }
                 lua_pop(L, 1);
                 return result;
             }
 
             void pushStanza(lua_State* L, const std::shared_ptr<T> stanza, LuaElementConvertors* convertors) {
                 lua_createtable(L, 0, 0);
                 lua_pushstring(L, stanza->getID().c_str());
                 lua_setfield(L, -2, "id");
                 lua_pushstring(L, stanza->getFrom().toString().c_str());
                 lua_setfield(L, -2, "from");
                 lua_pushstring(L, stanza->getTo().toString().c_str());
                 lua_setfield(L, -2, "to");
                 if (!stanza->getPayloads().empty()) {
                     lua_createtable(L, boost::numeric_cast<int>(stanza->getPayloads().size()), 0);
                     {
                         int i = 0;
                         for (const auto& item : stanza->getPayloads()) {
                             if (convertors->convertToLua(L, item) > 0) {
                                 lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
author	Roger Planas <roger.planas@isode.com>	2017-07-04 11:03:55 (GMT)
committer	Roger Planas <roger.planas@isode.com>	2017-10-30 12:25:43 (GMT)
commit	c29df10f0ab47db63509634fb1661ff55b8b47b3 (patch)
tree	ebf7486b653b554e3122c3509da17e17ef25f312 /Sluift/ElementConvertors
parent	ed25c7d2fe46dca4edecd359755b15e16620056e (diff)
download	swift-c29df10f0ab47db63509634fb1661ff55b8b47b3.zip swift-c29df10f0ab47db63509634fb1661ff55b8b47b3.tar.bz2