/*
 * Was wir unter C tun müssen ist separate definition von Interface und
 * und Daten sowie Methoden....das Interface ist dabei immer verantwortlich
 * dafür die zur Klasse gehörende Implementation einer Methode aufzurufen.
 *
 * In anderen Worten... eine Klasse ist eine konkretisierung eines
 * Interface. Ebenso wie es viele Objekte einer Klasse geben kann, kann es
 * auch viele Konkretisierungen eines Interfaces geben.
 *
 * Alle Klassen die das gleiche Interface konkretisieren reagieren auf
 * die gleichen Messages und Objekte dieser Klassen sind daher grundsätzlich
 * austauschbar.
 *
 * Ein Interface kann ebenso wie Klassen andere Interfaces erweitern.
 * Objekte von Klassen die ein solches erweitertes Interface konkretisieren
 * koennen auch überall dort eingesetzt werden wo Objekte des Basisinterface
 * eingesetzt wurden.
 *
 * Alles Interfaces müssen wenigstens von dem Basisinterface struct _CCLASS
 * abgeleitet sein, welches __construct und __destruct sowie class detection
 * Magic und die Klassengroesse enthält.
 *
 * Die Interfaces können zur compilezeit statisch initialisiert werden da
 * sie sich zur laufzeit nie ändern.
 *
 * Über die implementierung multipler interfaces muss ich noch nachdenken.
 * Denkbar waere den Interfaces reservierte namen zu geben über die dann immer
 * auf sie zugegriffen werden muss...hat eine Interfacedefinition dann ein
 * memder dieses reservierten namens hat er auch das Interface.
 *
 * === was folgt ist noch nicht in unten stehendem pseudo code ===
 * 
 * Die interfaces sollten sich evtl nicht extenden....stattdessen
 * sollte die Klassenimplementation ihr interface mit den existierenden
 * Interface definitionen und ihren implementationen initialisieren.
 *
 * Das soll heissen zu jeder Klasse (A) wird auch eine Interfaces structur
 * angelegt die dann konkrete Interface Instanzen initialisiert und mit
 * einem unique name versieht.
 *
 * Dabei ist dann verprflichtend das zumindest das CCLASS interface
 * eingebunden wird, damit es wirklich eine Klasse wird. :)
 */

// === INTERFACE DEFINITION =======

typedef void (*fptr_draw)(void *);

typedef struct __SHAPE {
	struct _CCLASS cclass;
	struct {
		fptr_draw draw;
	} shape;
} * __SHAPE_PTR;

struct _SHAPE;
typedef struct _SHAPE * SHAPE;

// === INTERFACE IMPLEMENTIERUNG (for dynamic binding) =======

void * draw(const __SHAPE_PTR shape)
{
	const __SHAPE_PTR class = _object - sizeof(void *);

	if (shape && class && class->draw) {
		class->draw(shape);
	}
}

// === KLASSEN IMPLEMENTATION ========

static void draw(CIRCLE * this);

static
const
struct __SHAPE _circle = {
	{
		CCLASS_MAGIC;
		sizeof(struct __SHAPE);
		__construct;
		NULL;
		__destruct;
		NULL;
		NULL;
	};
	{
		draw;
	}
};

static
void
draw(CIRCLE * this)
{
	/* draw the shape */
}

// vim: set ts=4 sw=4: