Add polymorphic lua object type

sol.hpp

@@ -23,5 +23,6 @@
 #define SOL_HPP
 
 #include "sol/state.hpp"
+#include "sol/object.hpp"
 
 #endif // SOL_HPP

sol/object.hpp

@@ -0,0 +1,50 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013 Danny Y., Rapptz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SOL_OBJECT_HPP
+#define SOL_OBJECT_HPP
+
+#include "table.hpp"
+
+namespace sol {
+class object : public table {
+public:
+    object(lua_State* L, int index = -1): reference(L, index) {}
+    object() = default;
+
+    template<typename T>
+    T as() {
+        push();
+        type_assert(state(), -1, type_of<T>());
+        return stack::get<T>(state());
+    }
+
+    template<typename T>
+    bool is() {
+        push();
+        auto expected = type_of<T>();
+        auto actual = lua_type(state(), -1);
+        return (static_cast<int>(expected) == actual) || (expected == type::poly);
+    }
+};
+} // sol
+
+#endif // SOL_OBJECT_HPP

sol/stack.hpp

@@ -54,7 +54,7 @@ inline T get_arithmetic(lua_State* L, std::false_type, int index = -1) {
 template<typename T>
 inline T get_arithmetic(lua_State* L, std::true_type, int index = -1) {
     // T is an integral
-    return get_unsigned<T>(L, std::is_unsigned<T>{});
+    return get_unsigned<T>(L, std::is_unsigned<T>{}, index);
 }
 
 template<typename T>

sol/types.hpp

@@ -40,7 +40,9 @@ enum class type : int {
     function = LUA_TFUNCTION,
     userdata = LUA_TUSERDATA,
     lightuserdata = LUA_TLIGHTUSERDATA,
-    table = LUA_TTABLE
+    table = LUA_TTABLE,
+    poly = none | nil | string | number | thread | boolean | 
+           function | userdata | lightuserdata | table
 };
 
 inline void type_error(lua_State* L, int expected, int actual) {
@@ -49,13 +51,14 @@ inline void type_error(lua_State* L, int expected, int actual) {
 
 inline void type_assert(lua_State* L, int index, type expected) {
     int actual = lua_type(L, index);
-    if(static_cast<int>(expected) != actual) {
+    if(expected != type::poly && static_cast<int>(expected) != actual) {
         type_error(L, static_cast<int>(expected), actual);
     }
 }
 
 class table;
 class function;
+class object;
 
 namespace detail {
 template<typename T>
@@ -84,6 +87,11 @@ inline type type_of<function>() {
     return type::function;
 }
 
+template<>
+inline type type_of<object>() {
+    return type::poly;
+}
+
 template<>
 inline type type_of<const char*>() {
     return type::string;