SWIG for Lua: Reflection

For this blog entry, we show that it is possible for Lua to know about the fields and methods of a C++ struct. This ability for inspection is known as reflection in the programming world. Only basic reflection is demonstrated here; that is, only basic information is extracted from the C++ struct.

First, we define the C++ struct in the header file, example.hpp:

	struct Point
	{
	int x;
	int y;
	void greet();
	};

view raw example.hpp hosted with ❤ by GitHub

The struct implementation is defined in example.cpp:

	#include "example.hpp"
	#include <cstdio>
	void Point::greet()
	{
	printf("x=%d, y=%d\n", x, y);
	}

view raw example.cpp hosted with ❤ by GitHub

We then define the interface file, example.i, to be used by SWIG:

	%module example
	%{
	/* Includes the header in the wrapper code */
	#include "example.hpp"
	%}
	/* Parse the header file to generate wrappers */
	%include "example.hpp"

view raw example.i hosted with ❤ by GitHub

After which, we use SWIG to generate the wrapper file:

% swig -lua -c++ example.i

We then compile the C++ source files and create the shared object to be used by our Lua script:

% g++ -fPIC -I/usr/include/lua5.2 -c example_wrap.cxx -o example_wrap.o
% g++ -fPIC -c example.cpp -o example.o
% g++ -shared -I/usr/include/lua5.2 example.o example_wrap.o -o example.so

We then write a Lua script, test.lua, for testing:

	#!/usr/bin/lua
	package.loadlib('./example.so', 'luaopen_example')()
	A = example.Point()
	A.x = 101
	A.y = 202
	print(A.x)
	print(A.y)
	A:greet()
	print(swig_type(A.x))
	print(swig_type(A.y))
	print(swig_type(A.greet))
	m = getmetatable(A)
	print('/***** struct metatable *****/')
	for k, v in pairs(m) do
	print(k, v)
	end
	g = m['.get']
	print('/***** struct fields *****/')
	for k, v in pairs(g) do
	print(k, v)
	end
	fn = m['.fn']
	print('/***** struct methods *****/')
	for k, v in pairs(fn) do
	print(k, v)
	end

view raw test.lua hosted with ❤ by GitHub

When run:

	% ./test.lua
	101
	202
	x=101, y=202
	number
	number
	function
	/***** struct metatable *****/
	.type Point
	__gc function: 0x7fced2eaf0a1
	.get table: 0xf14c60
	__tostring function: 0x7fced2eaf140
	__newindex function: 0x7fced2eaef9f
	.static table: 0xf15010
	__eq function: 0x7fced2eaf29b
	__index function: 0x7fced2eaeb93
	.set table: 0xf15060
	.fn table: 0xf150a0
	.bases table: 0xf14c20
	/***** struct fields *****/
	y function: 0x7fced2eb1f9b
	x function: 0x7fced2eb1b2f
	/***** struct methods *****/
	__disown function: 0x7fced2eaf234
	greet function: 0x7fced2eb219a

view raw output.txt hosted with ❤ by GitHub

Lines 20-24 of test.lua print the names of the fields of the struct. Note that the order of the printing of the field names (lines 21-22 of output.txt) may not be the same as the order of declaration of the fields in the C++ struct definition in example.hpp (lines 3-4).

Lines 26-30 print the names of the methods of the struct.

Hope this helps the world.

SWIG for Lua: Class demonstration

In this entry, we demonstrate how to expose a C++ class to Lua using SWIG. The environment I use is Ubuntu 16.04.

First, we define the C++ class in example.hpp:

	class MyClass
	{
	public:
	MyClass(int a, int b);
	void greet();
	private:
	int x;
	int y;
	};

view raw example.hpp hosted with ❤ by GitHub

The class implementation is defined in example.cpp:

	#include <example.hpp>
	#include <ctime>
	#include <cstdio>
	MyClass::MyClass(int a, int b): x(a), y(b) {}
	void MyClass::greet()
	{
	printf("Hello, world: x=%d y=%d\n", x, y);
	}

view raw example.cpp hosted with ❤ by GitHub

Then, we define the interface file, example.i, to be used by SWIG:

	%module example
	%{
	/* Includes the header in the wrapper code */
	#include "example.hpp"
	%}
	/* Parse the header file to generate wrappers */
	%include "example.hpp"

view raw example.i hosted with ❤ by GitHub

We then use SWIG to generate the wrapper file, example_wrap.cxx:

% swig -lua -c++ example.i

Next, we compile the C++ source files:

% g++ -fPIC -I/usr/include/lua5.2 -c example_wrap.cxx -o example_wrap.o
% g++ -fPIC -I. -c example.cpp -o example.o

Then, we create the shared object, example.so:

% g++ -shared -I/usr/include/lua5.2 example_wrap.o example.o -o example.so

We write a Lua script to test if SWIG works:

	#!/usr/bin/lua
	package.loadlib('./example.so', 'luaopen_example')()
	A = example.MyClass(6, 7)
	A:greet()

view raw test.lua hosted with ❤ by GitHub

When run:

% ./test.lua
Hello, world: x=6 y=7

Hope this helps the world.

Compiling and running SWIG for Lua in Ubuntu 16.04 using C++

This blog entry is quite similar to my previous entry. The difference is that this entry uses C++ source files instead of C.

We first start with the C++ header file:

	extern double My_variable;
	int fact(int n);
	int my_mod(int x, int y);
	char *get_time();

view raw example.hpp hosted with ❤ by GitHub

Notice the use of extern for the declaration of the global variable, since we are dealing with C++ here and not C.

We then create the C++ implementation file:

	#include <example.hpp>
	#include <ctime>
	double My_variable = 3.0;
	int fact(int n) {
	if (n <= 1) return 1;
	else return n*fact(n-1);
	}
	int my_mod(int x, int y) {
	return (x%y);
	}
	char *get_time()
	{
	time_t ltime;
	time(&ltime);
	return ctime(&ltime);
	}

view raw example.cpp hosted with ❤ by GitHub

Then we create the interface file for SWIG:

	%module example
	%{
	/* Includes the header in the wrapper code */
	#include "example.hpp"
	%}
	/* Parse the header file to generate wrappers */
	%include "example.hpp"

view raw example.i hosted with ❤ by GitHub

We then call SWIG to generate the wrapper file:

% swig -lua -c++ example.i

Notice the use of the -c++ argument.

Next, we compile the wrapper file:

% g++ -fPIC -I/usr/include/lua5.2 -c example_wrap.cxx -o example_wrap.o

Notice that the generated wrapper file has the file suffice .cxx

We then compile the C++ implementation file:

% g++ -fPIC -I. -c example.cpp -o example.o

Finally, we create the shared object to be used by our Lua script:

% g++ -shared -I/usr/include/lua5.2 example_wrap.o example.o -o example.so

We write a Lua script for testing:

	package.loadlib('./example.so', 'luaopen_example')()
	print(example.My_variable)
	print(example.fact(5))
	print(example.my_mod(5, 3))
	print(example.get_time())

view raw test.lua hosted with ❤ by GitHub

When run:

% lua test.lua
3
120
2
Wed Jun 14 16:41:11 2017

Hope this helps the world. :)

Compiling and running SWIG for Lua in Ubuntu 16.04 for the truly lazy

Previously, we were able to compile and run SWIG for Lua in Ubuntu 16.04 using a C source file. In this blog entry, we want to do something very similar except that we use a C header file.

We begin with the files needed starting with the header file, example.h:

	double My_variable;
	int fact(int n);
	int my_mod(int x, int y);
	char *get_time();

view raw example.h hosted with ❤ by GitHub

Then, we create the C implementation file, example.c:

	#include <example.h>
	#include <time.h>
	double My_variable = 3.0;
	int fact(int n)
	{
	if (n <= 1) return 1;
	else return n*fact(n-1);
	}
	int my_mod(int x, int y)
	{
	return (x%y);
	}
	char *get_time()
	{
	time_t ltime;
	time(&ltime);
	return ctime(&ltime);
	}

view raw example.c hosted with ❤ by GitHub

Finally, we create the interface file, example.i, which is needed by SWIG:

	%module example
	%{
	/* Includes the header in the wrapper code */
	#include "example.h"
	%}
	/* Parse the header file to generate wrappers */
	%include "example.h"

view raw example.i hosted with ❤ by GitHub

Notice how much simpler this interface file is compared to the previous one. This is why this entry has a subclause "for the truly lazy".

We then call SWIG to create the wrapper file, example_wrap.c:

% swig -lua example.i

Then we compile the generated wrapper file:

% gcc -fPIC -I/usr/include/lua5.2 -c example_wrap.c -o example_wrap.o

We also compile the C source file, example.c:

% gcc -fPIC -I. -c example.c -o example.o

Finally, we create the shared object which is to be used by our Lua script:

% gcc -shared -I/usr/include/lua5.2 example_wrap.o example.o -o example.so

The Lua script is just the same as our previous blog entry. For convenience:

	package.loadlib('./example.so', 'luaopen_example')()
	print(example.My_variable)
	print(example.fact(5))
	print(example.my_mod(5, 3))
	print(example.get_time())

view raw test.lua hosted with ❤ by GitHub

When run:

% lua test.lua
3
120
2
Wed Jun 14 14:56:54 2017

Hope this helps the world. :)

Compiling and running SWIG for Lua in Ubuntu 16.04

As a disclaimer, this blog entry is adapted from:

http://www.swig.org/tutorial.html
http://www.swig.org/Doc2.0/Lua.html#Lua_nn5

Let's begin. first, you need to have SWIG installed:

% sudo apt-get install swig

You also need to have Lua installed. Say, Lua 5.2:

% sudo apt-get install lua5.2

Let us consider the following file, example.c, whose functions and variable we wish to use in Lua:

	#include <time.h>
	double My_variable = 3.0;
	int fact(int n) {
	if (n <= 1) return 1;
	else return n*fact(n-1);
	}
	int my_mod(int x, int y) {
	return (x%y);
	}
	char *get_time()
	{
	time_t ltime;
	time(&ltime);
	return ctime(&ltime);
	}

view raw example.c hosted with ❤ by GitHub

Then, we need to create an interface file, say, example.i:

	%module example
	%{
	/* Put header files here or function declarations like below */
	extern double My_variable;
	extern int fact(int n);
	extern int my_mod(int x, int y);
	extern char *get_time();
	%}
	extern double My_variable;
	extern int fact(int n);
	extern int my_mod(int x, int y);
	extern char *get_time();

view raw example.i hosted with ❤ by GitHub

After creating the files, we use SWIG to create a wrapper file:

% swig -lua example.i

This creates a wrapper file named example_wrap.c.

Now it is time to compile the C files:

% gcc -fPIC -I/usr/include/lua5.2 -c example_wrap.c -o example_wrap.o
% gcc -fPIC -c example.c -o example.o

Then we create the shared object which shall be used by our Lua script:

% gcc -shared -I/usr/include/lua5.2 example_wrap.o example.o -o example.so

This creates the shared object, example.so.

Finally, we create our Lua script to test if Lua can call the C functions and variable:

	package.loadlib('./example.so', 'luaopen_example')()
	print(example.My_variable)
	print(example.fact(5))
	print(example.my_mod(5, 3))
	print(example.get_time())

view raw test.lua hosted with ❤ by GitHub

When run, this is the output:

% lua test.lua
3
120
2
Wed Jun 14 14:56:54 2017

Hope this helps the world. :)

Calling C++ function from Lua

I tried to follow this example, but compiling failed.

The example was for Lua 5.1, while I was using Lua 5.2, so some changes had to be made.

First I changed the compile command to as follows:

% g++ luaavg.cpp -llua5.2 -I/usr/include/lua5.2 -o luaavg

Then, in the luaavg.cpp file, I changed "L = lua_open()" to "L = luaL_newstate()".

(To install Lua 5.2 in ubuntu, try this.)

boost mpl if demonstration

Consider the following code adapted from Polukhin:

	#include <boost/mpl/if.hpp>
	#include <boost/type_traits/has_plus_assign.hpp>
	#include <boost/type_traits/has_plus.hpp>
	#include <boost/type_traits/has_post_increment.hpp>
	#include <boost/type_traits/has_pre_increment.hpp>
	#include <cstdio>
	namespace detail {
	struct pre_inc_functor {
	template <class T>
	void operator()(T& value) const {
	printf("%s\n", __FUNCTION__);
	++value;
	}
	};
	struct post_inc_functor {
	template <class T>
	void operator()(T& value) const {
	printf("%s\n", __FUNCTION__);
	value++;
	}
	};
	struct plus_assignable_functor {
	template <class T>
	void operator()(T& value) const {
	printf("%s\n", __FUNCTION__);
	value += T(1);
	}
	};
	struct plus_functor {
	template <class T>
	void operator()(T& value) const {
	printf("%s\n", __FUNCTION__);
	value = value + T(1);
	}
	};
	}
	template <class T>
	void inc(T& value) {
	typedef detail::plus_functor step_0_t;
	typedef typename boost::mpl::if_<
	boost::has_plus_assign<T>,
	detail::plus_assignable_functor,
	step_0_t
	>::type step_1_t;
	typedef typename boost::mpl::if_<
	boost::has_post_increment<T>,
	detail::post_inc_functor,
	step_1_t
	>::type step_2_t;
	typedef typename boost::mpl::if_<
	boost::has_pre_increment<T>,
	detail::pre_inc_functor,
	step_2_t
	>::type step_3_t;
	step_3_t() // default constructing functor
	(value); // calling operator() of a functor
	}
	class cls
	{
	public:
	cls(int val): m_int(val) {}
	cls operator+=(cls const& rhs)
	{
	printf("%s\n", __FUNCTION__);
	m_int += rhs.m_int;
	return *this;
	}
	int get()
	{
	return m_int;
	}
	private:
	int m_int;
	};
	class post
	{
	public:
	post(int val): m_int(val) {}
	post operator++(int)
	{
	printf("%s\n", __FUNCTION__);
	post tmp(m_int);
	++m_int;
	return tmp;
	}
	int get()
	{
	return m_int;
	}
	private:
	int m_int;
	};
	int main()
	{
	int x = 5;
	inc(x);
	printf("x = %d\n", x);
	cls y(89);
	inc(y);
	printf("y = %d\n", y.get());
	post z(140);
	inc(z);
	printf("z = %d\n", z.get());
	post alpha = z++;
	printf("alpha = %d\n", alpha.get());
	printf("z = %d\n", z.get());
	return 0;
	}

view raw b.cpp hosted with ❤ by GitHub

When run:

detail::pre_inc_functor::operator ()
x = 6
detail::plus_assignable_functor::operator ()
cls::operator +=
y = 90
detail::post_inc_functor::operator ()
post::operator ++
z = 141
post::operator ++
alpha = 141
z = 142

boost mpl manipulating a vector

Consider the following code copied from Polukhin:

	#include <iostream>
	#include <boost/mpl/size.hpp>
	#include <boost/type_traits/is_same.hpp>
	#include <boost/static_assert.hpp>
	#include <boost/mpl/if.hpp>
	#include <boost/type_traits/make_unsigned.hpp>
	#include <boost/type_traits/add_const.hpp>
	#include <boost/mpl/transform.hpp>
	#include <boost/mpl/vector.hpp>
	#include <boost/mpl/at.hpp>
	// Make unsigned
	struct unsigne; // No typo: 'unsigned' is a keyword, we cannot use it.
	// Make constant
	struct constant;
	// Otherwise we do not change type
	struct no_change;
	template <class Types, class Modifiers>
	struct do_modifications
	{
	BOOST_STATIC_ASSERT((boost::is_same<
	typename boost::mpl::size<Types>::type,
	typename boost::mpl::size<Modifiers>::type
	>::value));
	typedef boost::mpl::if_<
	boost::is_same<boost::mpl::_2, unsigne>,
	boost::make_unsigned<boost::mpl::_1>,
	boost::mpl::if_<
	boost::is_same<boost::mpl::_2, constant>,
	boost::add_const<boost::mpl::_1>,
	boost::mpl::_1
	>
	> binary_operator_t;
	typedef typename boost::mpl::transform<
	Types,
	Modifiers,
	binary_operator_t
	>::type type;
	};
	typedef boost::mpl::vector<unsigne, no_change, constant, unsigne> modifiers;
	typedef boost::mpl::vector<int, char, short, long> types;
	typedef do_modifications<types, modifiers>::type result_type;
	BOOST_STATIC_ASSERT((boost::is_same<
	boost::mpl::at_c<result_type, 0>::type,
	unsigned int
	>::value));
	BOOST_STATIC_ASSERT((boost::is_same<
	boost::mpl::at_c<result_type, 1>::type,
	char
	>::value));
	BOOST_STATIC_ASSERT((boost::is_same<
	boost::mpl::at_c<result_type, 2>::type,
	const short
	>::value));
	BOOST_STATIC_ASSERT((boost::is_same<
	boost::mpl::at_c<result_type, 3>::type,
	unsigned long
	>::value));
	int main(int argc, char *argv[])
	{
	auto x = 78;
	std::cout << "Hello World! " << x << std::endl;
	return 0;
	}

view raw main.cpp hosted with ❤ by GitHub

When run, this code simply prints "Hello World! 78"

Luabind tostring demonstration

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	#include <luabind/operator.hpp>
	class testclass
	{
	public:
	testclass(int val) : m_int(val) {}
	friend std::ostream& operator<<(std::ostream& os, testclass const& tc);
	private:
	int m_int;
	};
	std::ostream& operator<<(std::ostream& os, testclass const& tc)
	{
	os << tc.m_int;
	return os;
	}
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<testclass>("testclass")
	.def(constructor<int>())
	.def(tostring(self))
	];
	return 0;
	}

view raw tostring.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/tostring$ cat test.lua
package.loadlib('./testclass.so', 'init')()
a = testclass(101)
print(tostring(a))
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/tostring$ cat commands.bash
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/tostring$ ./commands.bash
101
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/tostring$

Luabind operator other() demonstration

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	#include <luabind/operator.hpp>
	class testclass
	{
	public:
	testclass(int val) : m_int(val) {}
	void print()
	{
	std::cout << m_int << std::endl;
	}
	testclass operator+(testclass const& rhs)
	{
	testclass tmp(m_int + rhs.m_int);
	return tmp;
	}
	private:
	int m_int;
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<testclass>("testclass")
	.def(constructor<int>())
	.def("print", &testclass::print)
	.def(self + other<testclass>())
	];
	return 0;
	}

view raw operator_other.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator_other$ cat test.lua
package.loadlib('./testclass.so', 'init')()
a = testclass(5)
b = testclass(9)
c = a + b
a:print()
b:print()
c:print()
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator_other$ cat commands.bash
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator_other$ ./commands.bash
5
9
14
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator_other$

Luabind operator demonstration

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	#include <luabind/operator.hpp>
	class testclass
	{
	public:
	testclass(int val) : m_int(val) {}
	void print()
	{
	std::cout << m_int << std::endl;
	}
	testclass operator+(int rhs)
	{
	testclass tmp(m_int + rhs);
	return tmp;
	}
	private:
	int m_int;
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<testclass>("testclass")
	.def(constructor<int>())
	.def("print", &testclass::print)
	.def(self + int())
	];
	return 0;
	}

view raw operator.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator$ cat test.lua
package.loadlib('./testclass.so', 'init')()
a = testclass(5)
a:print()
c = a + 6
c:print()
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator$ cat commands.bash 
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator$ ./commands.bash 
5
11
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/operator$ 

Luabind: enums demonstration

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	struct A
	{
	A() {}
	enum
	{
	first = 1
	, second = 2
	, thirds = 3
	};
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<A>("A")
	.def(constructor<>())
	.enum_("constants")
	[
	value("first", 1),
	value("second", 2),
	value("third", 3)
	]
	];
	return 0;
	}

view raw enums.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/enums$ cat test.lua 
package.loadlib('./testclass.so', 'init')()
print(A.first)
print(A.second)
print(A.third)
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/enums$ cat ./commands.bash 
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/enums$ ./commands.bash 
1
2
3
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/enums$ 

You actually don't have to define the enum in the C++ struct A. Try removing it and the test.lua will still work.

boost mpl vector demonstration

Consider the following code copied from Polukhin's book:

	#include <boost/mpl/aux_/na.hpp>
	// boost::mpl::na == n.a. == not available
	template <
	class T0 = boost::mpl::na,
	class T1 = boost::mpl::na,
	class T2 = boost::mpl::na,
	class T3 = boost::mpl::na,
	class T4 = boost::mpl::na,
	class T5 = boost::mpl::na,
	class T6 = boost::mpl::na,
	class T7 = boost::mpl::na,
	class T8 = boost::mpl::na,
	class T9 = boost::mpl::na
	>
	struct variant;
	#include <boost/mpl/vector.hpp>
	template <
	class T0
	, class T1
	, class T2
	, class T3
	, class T4
	, class T5
	, class T6
	, class T7
	, class T8
	, class T9
	>
	struct variant {
	typedef boost::mpl::vector<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> types;
	};
	#include <string>
	struct declared{ unsigned char data[4096]; };
	struct non_defined;
	typedef variant<
	volatile int,
	const int,
	const long,
	declared,
	non_defined,
	std::string
	>::types types;
	#include <boost/static_assert.hpp>
	#include <boost/mpl/empty.hpp>
	BOOST_STATIC_ASSERT((!boost::mpl::empty<types>::value));
	#include <boost/mpl/at.hpp>
	#include <boost/type_traits/is_same.hpp>
	BOOST_STATIC_ASSERT((boost::is_same<
	non_defined
	, boost::mpl::at_c<types, 4>::type>::value));
	#include <boost/mpl/back.hpp>
	BOOST_STATIC_ASSERT((boost::is_same<
	std::string
	, boost::mpl::back<types>::type>::value));
	#include <boost/mpl/transform.hpp>
	#include <boost/type_traits/remove_cv.hpp>
	typedef boost::mpl::transform<
	types,
	boost::remove_cv<boost::mpl::_1>
	>::type noncv_types;
	#include <boost/mpl/unique.hpp>
	typedef boost::mpl::unique<
	noncv_types,
	boost::is_same<boost::mpl::_1, boost::mpl::_2>
	>::type unique_types;
	#include <boost/mpl/size.hpp>
	BOOST_STATIC_ASSERT((boost::mpl::size<unique_types>::value == 5));
	// Without this we'll get an error:
	// use of undefined type 'non_defined'
	struct non_defined{};
	#include <boost/mpl/sizeof.hpp>
	typedef boost::mpl::transform<
	unique_types,
	boost::mpl::sizeof_<boost::mpl::_1>
	>::type sizes_types;
	#include <boost/mpl/max_element.hpp>
	typedef boost::mpl::max_element<sizes_types>::type max_size_type;
	BOOST_STATIC_ASSERT(max_size_type::type::value == sizeof(declared));
	int main()
	{
	return 0;
	}

view raw d.cpp hosted with ❤ by GitHub

When run, this code prints nothing. All checking is done at compile time.

boost enable_if_c example

Consider the following code adapted from Polukhin's book:

	#include <iostream>
	#include <boost/utility/enable_if.hpp>
	#include <boost/type_traits/is_integral.hpp>
	#include <boost/type_traits/is_float.hpp>
	// Generic implementation
	template <class T, class enable = void>
	class data_processor {
	public:
	double process(const T& v1, const T& v2, const T& v3)
	{
	std::cout << __PRETTY_FUNCTION__ << std::endl;
	}
	};
	// Integral types optimized version
	template <class T>
	class data_processor<T, typename boost::enable_if_c<boost::is_integral<T>::value>::type>
	{
	public:
	double process(const T& v1, const T& v2, const T& v3)
	{
	std::cout << __PRETTY_FUNCTION__ << std::endl;
	}
	};
	// SSE optimized version for float types
	template <class T>
	class data_processor<T, typename boost::enable_if_c<boost::is_float<T>::value>::type>
	{
	public:
	double process(const T& v1, const T& v2, const T& v3)
	{
	std::cout << __PRETTY_FUNCTION__ << std::endl;
	}
	};
	template <class T>
	double example_func(T v1, T v2, T v3) {
	data_processor<T> proc;
	return proc.process(v1, v2, v3);
	}
	int main () {
	// Integral types optimized version will be called
	example_func(1, 2, 3);
	short s = 0;
	example_func(s, s, s);
	// Real types version will be called
	example_func(1.0, 2.0, 3.0);
	example_func(1.0f, 2.0f, 3.0f);
	// Generic version will be called
	example_func("Hello", "word", "processing");
	return 0;
	}

view raw c.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/cpp/boost/polukhin/ch04/enable_if_c$ g++ -I~/dkuyu/bin/boost_1_60_0 c.cpp && ./a.out
double data_processor<T, typename boost::enable_if_c<boost::is_integral<T>::value>::type>::process(const T&, const T&, const T&) [with T = int; typename boost::enable_if_c<boost::is_integral<T>::value>::type = void]
double data_processor<T, typename boost::enable_if_c<boost::is_integral<T>::value>::type>::process(const T&, const T&, const T&) [with T = short int; typename boost::enable_if_c<boost::is_integral<T>::value>::type = void]
double data_processor<T, typename boost::enable_if_c<boost::is_float<T>::value>::type>::process(const T&, const T&, const T&) [with T = double; typename boost::enable_if_c<boost::is_float<T>::value>::type = void]
double data_processor<T, typename boost::enable_if_c<boost::is_float<T>::value>::type>::process(const T&, const T&, const T&) [with T = float; typename boost::enable_if_c<boost::is_float<T>::value>::type = void]
double data_processor<T, enable>::process(const T&, const T&, const T&) [with T = const char*; enable = void]

Luabind: properties demonstration

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	struct A
	{
	A(int val): a(val), b(5) {}
	int a;
	int b;
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<A>("A")
	.def(constructor<int>())
	.def_readwrite("a", &A::a)
	.def_readonly("b", &A::b)
	];
	return 0;
	}

view raw properties.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/properties$ cat commands.bash 
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/properties$ ./commands.bash 
7
89
5
lua: property 'b' is read only
stack traceback:
[C]: in function '__newindex'
test.lua:7: in main chunk
[C]: in ?
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/properties$ 

Luabind: Binding an overloaded class function

Consider the following code:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	class overloaded_function
	{
	public:
	overloaded_function() {}
	void print_string() { std::cout << __FUNCTION__ << std::endl; }
	void print_string(int x) { std::cout << __FUNCTION__ << ": " << x << std::endl; }
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<overloaded_function>("overloaded_function")
	.def(constructor<>())
	.def("print_string", (void(overloaded_function::*)(int))&overloaded_function::print_string)
	];
	return 0;
	}

view raw overloaded_function.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/overloaded_function$ cat test.lua 
package.loadlib('./overloaded_function.so', 'init')()
a = overloaded_function()
a:print_string(6)
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/overloaded_function$ cat commands.bash 
#!/bin/bash
g++ overloaded_function.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o overloaded_function.so overloaded_function.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/overloaded_function$ ./commands.bash 
print_string: 6

Consider the following code which registers a free function (plus()) as a member function of class A:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	struct A
	{
	A(int val): a(val) {}
	int a;
	};
	int plus(A* o, int v)
	{
	return o->a + v;
	}
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<A>("A")
	.def(constructor<int>())
	.def("plus", &plus)
	];
	return 0;
	}

view raw register_free.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/register_free$ cat test.lua
package.loadlib('./register_free.so', 'init')()
x = A(3)
print(x:plus(5))
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/register_free$ cat commands.bash
#!/bin/bash
g++ register_free.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o register_free.so register_free.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/register_free$ ./commands.bash
8
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/register_free$

Luabind class demonstration

Consider this code that exposes a C++ class to Lua:

	#include <string>
	#include <iostream>
	#include <luabind/luabind.hpp>
	class testclass
	{
	public:
	testclass(const std::string& s): m_string(s) {}
	void print_string() { std::cout << m_string << "\n"; }
	private:
	std::string m_string;
	};
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	class_<testclass>("testclass")
	.def(constructor<const std::string&>())
	.def("print_string", &testclass::print_string)
	];
	return 0;
	}

view raw testclass.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/testclass$ cat test.lua 
package.loadlib('./testclass.so', 'init')()
a = testclass('a string')
a:print_string()
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/testclass$ cat commands.bash 
#!/bin/bash
g++ testclass.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o testclass.so testclass.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/testclass$ ./commands.bash 
a string

Implementing a type trait

I copied/adapted this code from Polukhin's Boost book:

	#include <vector>
	#include <boost/type_traits/integral_constant.hpp>
	#include <cstdio>
	template <class T>
	struct is_stdvector: boost::false_type {};
	template <class T, class Allocator>
	struct is_stdvector<std::vector<T, Allocator> >: boost::true_type
	{};
	int main()
	{
	printf("int=%s\n", is_stdvector<int>::value ? "true" : "false");
	printf("vector<int>=%s\n", is_stdvector<std::vector<int>>::value ? "true" : "false");
	printf("vector<char*>=%s\n", is_stdvector<std::vector<char*>>::value ? "true" : "false");
	return 0;
	}

view raw polukhin_4p1.cpp hosted with ❤ by GitHub

When run:

kuyu@ub16:~/dkuyu/Dropbox/practice/cpp/polukhin/ch04/implement_type_trait$ g++ -std=c++11 -I/home/kuyu/dkuyu/bin/boost_1_60_0 1.cpp && ./a.out
int=false
vector<int>=true
vector<char*>=true

How to make a Windows folder always available in Ubuntu in Oracle Virtualbox

First share your Windows folder to your Ubuntu virtual machine in Oracle Virtualbox:

In your Ubuntu machine, add a similar line to your /etc/fstab file:

dkuyu   /home/kuyu/dkuyu    vboxsf  uid=kuyu,gid=kuyu,rw,dmode=700,fmode=700,_netdev      0 0

(Be sure to create the Linux folder afterwards. You can do this via mkdir command. In this example, make sure that /home/kuyu/dkuyu exists. If not, create it.)

Reboot your Ubuntu virtual machine.

After reboot, the Windows folder should be available in the Ubuntu folder /home/kuyu/dkuyu (for this example).

Luabind for sin math function

First we register the cmath sin() function as a function named sin() in Lua:

	#include <iostream>
	#include <luabind/luabind.hpp>
	#include <cmath>
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	def("sin", (float(*)(float)) &std::sin)
	];
	return 0;
	}

view raw sin.cpp hosted with ❤ by GitHub

We write a simple script to test the Lua sin() function:

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/sin$ cat test.lua 
package.loadlib('./c.so', 'init')()
print(sin(1.57))

We compile and test it as follows:

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/sin$ cat commands.bash 

#!/bin/bash

g++ c.cpp -I/usr/include/lua5.2/ -c -fPIC

g++ -shared -Wl,--whole-archive -o c.so c.o -lluabind -Wl,--no-whole-archive

lua test.lua

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/sin$ ./commands.bash 

0.99999970197678

(1.57 is very close to pi/2 and the sin of pi/2 is 1.)

Making luabind work in ubuntu

To be able to run Luabind in Ubuntu, you need to install libluabind-dev and lua:
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ sudo apt-get install libluabind-dev
kuyu@ub16:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ sudo apt-get install lua

Consider this hellobind.cpp code:

	#include <iostream>
	#include <luabind/luabind.hpp>
	void greet()
	{
	std::cout << "hello world!\n";
	}
	extern "C" int init(lua_State* L)
	{
	using namespace luabind;
	open(L);
	module(L)
	[
	def("greet", &greet)
	];
	return 0;
	}

view raw hellobind.cpp hosted with ❤ by GitHub

Then consider this test.lua code:

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ cat test.lua
package.loadlib('./hellobind.so', 'init')()
greet()

To run the test.lua code:

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ cat commands.bash 
#!/bin/bash
g++ hellobind.cpp -I/usr/include/lua5.2/ -c -fPIC
g++ -shared -Wl,--whole-archive -o hellobind.so hellobind.o -lluabind -Wl,--no-whole-archive
lua test.lua
kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ ./commands.bash 
hello world!

Sometimes, loading the C++ library in Lua can be problematic. To see what the problems are when loading the library, you can execute this lua file (execute "lua test1.lua"):

kuyu@castor-ub:~/dkuyu/Dropbox/practice/lua/luabind/hellobind$ cat test1.lua
local initfunction, errormessage = package.loadlib('/home/kuyu/dkuyu/Dropbox/practice/lua/luabind/hellobind.so','init')
if errormessage then
    print('Error loading hello_world:', errormessage)
end

boost::mpl::map demonstration

	#include <boost/mpl/map.hpp>
	#include <boost/mpl/pair.hpp>
	#include <boost/mpl/at.hpp>
	#include <boost/type_traits/is_same.hpp>
	#include <boost/mpl/assert.hpp>
	#include <cstdio>
	typedef boost::mpl::map<
	boost::mpl::pair<int,unsigned>
	, boost::mpl::pair<char,unsigned char>
	, boost::mpl::pair<int[42],bool>
	> m;
	int main()
	{
	BOOST_MPL_ASSERT(( boost::is_same< boost::mpl::at<m,int>::type, unsigned > ));
	boost::mpl::at<m,int>::type x;
	x = 5;
	printf("x=%u\n", x);
	return 0;
	}

view raw map.cpp hosted with ❤ by GitHub

When run:

kuyu@castor-ub:~/dkuyu/Dropbox/practice/cpp/boost/mpl$ g++ -I/home/kuyu/dkuyu/bin/boost_1_60_0 map.cpp && ./a.out

x=5