1

/* $Id$ */

     2

     3

/** @file squirrel_class.cpp defines templates for converting C++ classes to Squirrel classes */

     4

     5

#ifndef SQUIRREL_CLASS_HPP

     6

#define SQUIRREL_CLASS_HPP

     7

     8

#if (__GNUC__ == 2)

     9

/* GCC 2.95 doesn't like to have SQConvert::DefSQStaticCallback inside a

    10

 *  template (it gives an internal error 373). Above that, it doesn't listen

    11

 *  to 'using namespace' inside a function of a template. So for GCC 2.95 we

    12

 *  do it in the global space to avoid compiler errors. */

    13

using namespace SQConvert;

    14

#endif /* __GNUC__ == 2 */

    15

    16

/**

    17

 * The template to define classes in Squirrel. It takes care of the creation

    18

 *  and calling of such classes, to make the AI Layer cleaner while having a

    19

 *  powerful script as possible AI language.

    20

 */

    21

template <class CL>

    22

class DefSQClass {

    23

private:

    24

	const char *classname;

    25

    26

public:

    27

	DefSQClass(const char *_classname) :

    28

		classname(_classname)

    29

	{}

    30

    31

	/**

    32

	 * This defines a method inside a class for Squirrel.

    33

	 */

    34

	template <typename Func>

    35

	void DefSQMethod(Squirrel *engine, Func function_proc, const char *function_name)

    36

	{

    37

		using namespace SQConvert;

    38

		engine->AddMethod(function_name, DefSQNonStaticCallback<CL, Func>, 0, NULL, &function_proc, sizeof(function_proc));

    39

	}

    40

    41

	/**

    42

	 * This defines a method inside a class for Squirrel, which has access to the 'engine' (experts only!).

    43

	 */

    44

	template <typename Func>

    45

	void DefSQAdvancedMethod(Squirrel *engine, Func function_proc, const char *function_name)

    46

	{

    47

		using namespace SQConvert;

    48

		engine->AddMethod(function_name, DefSQAdvancedNonStaticCallback<CL, Func>, 0, NULL, &function_proc, sizeof(function_proc));

    49

	}

    50

    51

	/**

    52

	 * This defines a method inside a class for Squirrel with defined params.

    53

	 * @note If you define nparam, make sure that he first param is always 'x',

    54

	 *  which is the 'this' inside the function. This is hidden from the rest

    55

	 *  of the code, but without it calling your function will fail!

    56

	 */

    57

	template <typename Func>

    58

	void DefSQMethod(Squirrel *engine, Func function_proc, const char *function_name, int nparam, const char *params)

    59

	{

    60

		using namespace SQConvert;

    61

		engine->AddMethod(function_name, DefSQNonStaticCallback<CL, Func>, nparam, params, &function_proc, sizeof(function_proc));

    62

	}

    63

    64

	/**

    65

	 * This defines a static method inside a class for Squirrel.

    66

	 */

    67

	template <typename Func>

    68

	void DefSQStaticMethod(Squirrel *engine, Func function_proc, const char *function_name)

    69

	{

    70

		using namespace SQConvert;

    71

		engine->AddMethod(function_name, DefSQStaticCallback<CL, Func>, 0, NULL, &function_proc, sizeof(function_proc));

    72

	}

    73

    74

	/**

    75

	 * This defines a static method inside a class for Squirrel with defined params.

    76

	 * @note If you define nparam, make sure that he first param is always 'x',

    77

	 *  which is the 'this' inside the function. This is hidden from the rest

    78

	 *  of the code, but without it calling your function will fail!

    79

	 */

    80

	template <typename Func>

    81

	void DefSQStaticMethod(Squirrel *engine, Func function_proc, const char *function_name, int nparam, const char *params)

    82

	{

    83

		using namespace SQConvert;

    84

		engine->AddMethod(function_name, DefSQStaticCallback<CL, Func>, nparam, params, &function_proc, sizeof(function_proc));

    85

	}

    86

    87

	template <typename Var>

    88

	void DefSQConst(Squirrel *engine, Var value, const char *var_name)

    89

	{

    90

		engine->AddConst(var_name, value);

    91

	}

    92

    93

	void PreRegister(Squirrel *engine)

    94

	{

    95

		engine->AddClassBegin(this->classname);

    96

	}

    97

    98

	void PreRegister(Squirrel *engine, const char *parent_class)

    99

	{

   100

		engine->AddClassBegin(this->classname, parent_class);

   101

	}

   102

   103

	template <typename Func, int Tnparam>

   104

	void AddConstructor(Squirrel *engine, const char *params)

   105

	{

   106

		using namespace SQConvert;

   107

		engine->AddMethod("constructor", DefSQConstructorCallback<CL, Func, Tnparam>, Tnparam, params);

   108

	}

   109

   110

	void PostRegister(Squirrel *engine)

   111

	{

   112

		engine->AddClassEnd();

   113

	}

   114

};

   115

   116

#endif /* SQUIRREL_CLASS_HPP */