bool isData() const { return (bool)lua_isuserdata(state, index); }
bool isLightData() const { return (bool)lua_islightuserdata(state, index); }
+ /**
+ * Check the value and throw and error if its the wrong type. This
+ * method never returns because it does a long jump. Consequently,
+ * constructed C++ objects which exist on the stack between the current
+ * frame and some lua function will not be destructed. That's not a
+ * problem for objects that only exist on the stack, but any objects
+ * that allocate memory on the heap (such as containers or strings) will
+ * leak. Therefore, you should only call this method after cleaning up
+ * such objects.
+ */
+
+ void requireType(TYPE type) const
+ {
+ if (type != getType())
+ {
+ luaL_typerror(state, index, lua_typename(state, type));
+ }
+ }
+
+ void throwError(const char* error)
+ {
+ luaL_argerror(state, index, error);
+ }
+
+
+ Value& requireBoolean()
+ {
+ if (!isBoolean()) luaL_typerror(state, index, "boolean");
+ return *this;
+ }
+ Value& requireNumber()
+ {
+ if (!isNumber()) luaL_typerror(state, index, "number");
+ return *this;
+ }
+ Value& requireString()
+ {
+ if (!isString()) luaL_typerror(state, index, "string");
+ return *this;
+ }
+ Value& requireTable()
+ {
+ if (!isTable()) luaL_typerror(state, index, "table");
+ return *this;
+ }
+ Value& requireFunction()
+ {
+ if (!isFunction()) luaL_typerror(state, index, "function");
+ return *this;
+ }
+ Value& requireData()
+ {
+ if (!isData()) luaL_typerror(state, index, "data");
+ return *this;
+ }
+ Value& requireNil()
+ {
+ if (!isNil()) luaL_typerror(state, index, "nil");
+ return *this;
+ }
+ Value& requireThread()
+ {
+ if (!isThread()) luaL_typerror(state, index, "thread");
+ return *this;
+ }
+
+
/**
* Get the type of the value.
*/
std::string getTypeName() const
{
- return std::string(lua_typename(state, (int)getType()));
+ return std::string(luaL_typename(state, index));
}
}
+ /**
+ * Throw an error with the value at the top of the stack. This method never
+ * returns because it does a long jump. Consequently, constructed C++
+ * objects which exist on the stack between the current frame and some lua
+ * function will not be destructed. That's not a problem for objects that
+ * only exist on the stack, but any objects that allocate memory on the heap
+ * (such as containers or strings) will leak. Therefore, you should only
+ * call this method after cleaning up such objects.
+ */
+
+ void throwError()
+ {
+ lua_error(state_);
+ }
+
+
/**
* Get significant values.
*/
{
lua_pushlstring(state_, value.c_str(), value.length());
}
+ void push(const char* value)
+ {
+ lua_pushstring(state_, value);
+ }
void push(const char* value, size_t length)
{
lua_pushlstring(state_, value, length);