eventpp/doc/eventmaker.md

# Event maker macros reference

## Overview

`eventpp/eventmaker.h` contains several macros to generate event classes.  
Without the macros, we may need to repeat the same code structure on lots of event classes.  
For example,  

```c++
// The base event
class Event
{
};

class EventMouseDown : public Event
{
public:
	int getX() const;
	int getY() const;
	int getButton() const;
	
private:
	int x;
	int y;
	int button;
};

class EventKeyDown : public Event
{
public:
	int getKey() const;
	
private:
	int key;
};

```

It's not rare that there are dozens of or even hundreds of event classes in a system, and we need to repeat the same code structure many times, which is boring and error prone.  

The macros in eventmaker.h can reduce the work significantly.

## Header

eventpp/eventmaker.h

## Macro EVENTPP_MAKE_EVENT
```c++
#define EVENTPP_MAKE_EVENT(className, baseClassName, baseClassArgs, ...)
```

EVENTPP_MAKE_EVENT declares an event class.  

**className**: the event class name.  
**baseClassName**: the class name that the event inherits from. The macro requires a base class. If the class name contains comma (,), such as a template class, it should be enclosed within parenthesis. Examples, `Event`, `(AnotherEvent<int, char>)`.  
**baseClassArgs**: the arguments passed to the base class. If the arguments contain comma (,), it should be enclosed within parenthesis. If there is no arguments for the base class, `()` can be used.  
**The variadic arguments (...)**: the tuples of member data type and getter/setter function name. A tuple is elements in a pair of parenthesis. A tuple can contain 2 or 3 elements, the first element is the data type, the second element is the getter function name, and the optional third element is the setter function name. Some tuples examples: `(int, getX)`, `(std::string, getText, setText)`.  
Note: the variadic arguments can't be empty. If the even class doesn't have data member, use `EVENTPP_MAKE_EMPTY_EVENT` instead.

The macro always generates a default constructor and a constructor that takes all data members and initialize them.  

Code examples:  
```c++
EVENTPP_MAKE_EVENT(
	EventDraw, Event, EventType::draw,
	(std::string, getText, setText), (int, getX), (double, getSize)
);
```
Generates class like (in pseudo code),
```c++
class EventDraw : public Event
{
public:
	EventDraw(const std::string & text, const int x, const double size)
		: Event(EventType::draw), text(text), x(x), size(size)
	{
	}
	
	const std::string & getText() const {
		return text;
	}
	
	void setText(const std::string & value) {
		text = value;
	}
	
	const int getX() const {
		return x;
	}
	
	const double getSize() const {
		return size;
	}

private:
	std::string text;
	int x;
	double size;
};

```

```c++
EVENTPP_MAKE_EVENT(EventDraw, (Event<int, char>), EventType::draw,
	(std::string, getText, setText), (int, getX), (double, getSize)
);
```
Similar to above example, except the base class is `Event<int, char>`.  

```c++
EVENTPP_MAKE_EVENT(EventDraw, (Event<int, char>), (EventType::draw, 5),
	(std::string, getText, setText), (int, getX), (double, getSize)
);
```
Similar to above example, except the base class is constructed with `(EventType::draw, 5)` instead of `(EventType::draw)`.  


## Macro EVENTPP_MAKE_EMPTY_EVENT
```c++
#define EVENTPP_MAKE_EMPTY_EVENT(className, baseClassName, baseClassArgs)
```

Similar with `EVENTPP_MAKE_EVENT`, but EVENTPP_MAKE_EMPTY_EVENT declares event class which doesn't have any data member.