code: C++/Luae.h comparison

comparison C++/Luae.h @ 200:617459270743

Add XML parser

author	David Demelier <markand@malikania.fr>
date	Sat, 28 Dec 2013 11:16:11 +0100
parents	9fc5f917872b
children	8ee4a34e166c

comparison

equal deleted inserted replaced

-:08eb7b00b950
+:617459270743
 /*
-* Lua.h -- Lua helpers and such
+* Luae.h -- Lua helpers and such
 *
 * Copyright (c) 2013 David Demelier <markand@malikania.fr>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 #include <cassert>
 #include <functional>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 #include <lua.hpp>
+namespace malikania {
 /* {{{ LuaeState */
 /**
 * @class LuaeState
 	using Ptr = std::unique_ptr<lua_State, Deleter>;
 	Ptr m_state;
+	void initRegistry();
 public:
 	LuaeState(const LuaeState &) = delete;
 	LuaeState &operator=(const LuaeState &) = delete;
 	/**
 		       const std::string &name);
 };
 /* }}} */
-/* {{{ Luae */
+/* {{{ LuaeClass */
 /**
-* @class Luae
+* @class LuaeClass
-* @brief Add lot of convenience for Lua
+* @brief Support for object oriented programming between C++ and Lua
 *
-* This class adds lot of functions for Lua and C++.
+* This class provides functions for passing and retrieving objects from C++ and
-*/
+* Lua.
-class Luae {
+*/
-public:
+class LuaeClass {
-	/**
+public:
-	 * Preload a library, it will be added to package.preload so the
+	using Methods	= std::vector<luaL_Reg>;
-	 * user can successfully call require "name". In order to work, you need
-	 * to open luaopen_package and luaopen_base first.
+	template <typename T>
-	 *
+	using Ptr	= std::shared_ptr<T>;
-	 * @param L the Lua state
-	 * @param name the module name
+	struct Def {
-	 * @param func the opening library
+		std::string	name;		//! metatable name
-	 * @see require
+		Methods		methods;	//! methods
-	 */
+		Methods		metamethods;	//! metamethods
-	static void preload(lua_State *L,
+		const Def	*parent;	//! optional parent class
-			    const std::string &name,
+	};
-			    lua_CFunction func);
+	static void create(lua_State *L, const Def &def);
-	/**
-	 * Load a library just like it was loaded with require.
-	 *
-	 * @param L the Lua state
-	 * @param name the module name
-	 * @param func the function
-	 * @param global store as global
-	 */
-	static void require(lua_State *L,
-			    const std::string &name,
-			    lua_CFunction func,
-			    bool global);
-	/**
-	 * Initialize the registry for shared objects.
-	 *
-	 * @param L the Lua state
-	 */
-	static void initRegistry(lua_State *L);
 	/**
 	 * Push a shared object to Lua, it also push it to the "refs"
 	 * table with __mode = "v". That is if we need to push the object
 	 * again we use the same reference so Lua get always the same
 	 * @param L the Lua state
 	 * @param o the object to push
 	 * @param name the object metatable name
 	 */
 	template <typename T>
-	static void pushShared(lua_State *L,
+	static void push(lua_State *L, Ptr<T> o, const std::string &name)
-			std::shared_ptr<T> o,
-			const std::string &name)
 	{
 		lua_getfield(L, LUA_REGISTRYINDEX, "refs");
 		assert(lua_type(L, -1) == LUA_TTABLE);
 		lua_rawgetp(L, -1, o.get());
 	 * @param index the object index
 	 * @param meta the object metatable name
 	 * @return the object
 	 */
 	template <typename T>
-	static std::shared_ptr<T> getShared(lua_State *L, int index, const char *meta)
+	static Ptr<T> get(lua_State *L, int index, const char *meta)
 	{
-		using Ptr = std::shared_ptr<T>;
+		Ptr<T> *ptr = static_cast<Ptr<T> *>(luaL_checkudata(L, index, meta));
-		Ptr *ptr = static_cast<Ptr *>(luaL_checkudata(L, index, meta));
 		return *ptr;
 	}
+};
+/* }}} */
+/* {{{ LuaeEnum */
+/**
+* @class LuaeEnum
+* @brief Binds and get enumeration
+*
+* Bind C/C++ enumeration as tables to Lua in the key-value form. Two
+* methods push and get are also available for enumeration flags.
+*/
+class LuaeEnum {
+public:
+	/**
+	 * The definition of the enumeration
+	 */
+	using Def = std::unordered_map<std::string, int>;
+	/**
+	 * Bind the enumeration as a table into an existing table.
+	 *
+	 * @param L the Lua state
+	 * @param def the definition
+	 * @param index the table index
+	 * @param name the field name to store the enumeration
+	 */
+	static void create(lua_State *L,
+			   const Def &def,
+			   int index,
+			   const std::string &name);
+	/**
+	 * Push the value enumeration as a table to Lua. This is used
+	 * as the OR replacement.
+	 *
+	 * @param L the Lua state
+	 * @param def the definition
+	 * @param value the value
+	 */
+	static void push(lua_State *L, const Def &def, int value);
+	/**
+	 * Get the enumeration from Lua. Raises an error if the
+	 * value at the index is not a table.
+	 *
+	 * This is used as the OR replacement.
+	 *
+	 * @param L the Lua state
+	 * @param index the value index
+	 * @return the value
+	 */
+	static int get(lua_State *L, int index);
+};
+/* }}} */
+/* {{{ Luae */
+/**
+* @class Luae
+* @brief Add lot of convenience for Lua
+*
+* This class adds lot of functions for Lua and C++.
+*/
+class Luae {
+public:
+	/**
+	 * Preload a library, it will be added to package.preload so the
+	 * user can successfully call require "name". In order to work, you need
+	 * to open luaopen_package and luaopen_base first.
+	 *
+	 * @param L the Lua state
+	 * @param name the module name
+	 * @param func the opening library
+	 * @see require
+	 */
+	static void preload(lua_State *L,
+			    const std::string &name,
+			    lua_CFunction func);
+	/**
+	 * Load a library just like it was loaded with require.
+	 *
+	 * @param L the Lua state
+	 * @param name the module name
+	 * @param func the function
+	 * @param global store as global
+	 */
+	static void require(lua_State *L,
+			    const std::string &name,
+			    lua_CFunction func,
+			    bool global);
 	/**
 	 * Convert a new placement made object, without testing if its a real
 	 * object.
 	 *
 	template<class T>
 	static T toType(lua_State *L, int idx)
 	{
 		return reinterpret_cast<T>(lua_touserdata(L, idx));
 	}
-	/**
-	 * Convert a class created with new placement.
-	 *
-	 * @param L the Lua state
-	 * @param idx the value index
-	 * @param metaname the metatable name
-	 * @return the converted object
-	 */
-	template <typename T>
-	static T toType(lua_State *L, int idx, const char *metaname)
-	{
-		return reinterpret_cast<T>(luaL_checkudata(L, idx, metaname));
-	}
 };
 /* }}} */
 #if !defined(NDEBUG)
 #define LUAE_STACK_CHECKEQUALS(L)
 #define LUAE_STACK_CHECKEND(L, cond)
 #endif
+} // !malikania
 void *operator new(size_t size, lua_State *L);
 void *operator new(size_t size, lua_State *L, const char *metaname);
 void operator delete(void *ptr, lua_State *L);

Mercurial > code

comparison C++/Luae.h @ 200:617459270743