KSG-Script/ksgScript/Befehl/KSGSKlasse.cpp

#include "KSGSKlasse.h"
#include "../Error/Error.h"
#include "../Main/KSGScriptObj.h"
#include "../Klassen/KSGSTyp.h"
#include "../Klassen/KSGSBool.h"
#include "../Klassen/KSGSInt.h"
#include "../Klassen/KSGSDouble.h"
#include "../Klassen/KSGSText.h"
#include "../Klassen/KSGSBild.h"
#include "../Klassen/KSGSMausEreignis.h"
#include "../Klassen/KSGSTastaturEreignis.h"
#include "../Klassen/KSGSTextFeld.h"
#include "../Klassen/KSGSKnopf.h"
#include "../Klassen/KSGSFenster.h"
#include "../Klassen/KSGSBildZ.h"
#include "../Klassen/KSGSAnimation2DData.h"
#include "../Klassen/KSGSAnimation2D.h"
#include "../Klassen/KSGSArray.h"

using namespace KSGScript;

// Inhalt der KSGSKlasseInstanz Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasseInstanz::KSGSKlasseInstanz(int typ, Array< KSGSVariableDef* >* zVars, RCArray< KSGSFunktion >* funcs, KSGScriptProcessor* zObj)
	: ReferenceCounter()
{
	lokaleVariablen = new RCArray< KSGSVariable >();
	varPublic = new Array< bool >();
	funktionen = funcs;
	obj = zObj;
	lokaleVariablen->add(dynamic_cast<KSGSKlasseInstanz*>(getThis()), 0);
	varPublic->set(0, 0);
	int anz = zVars ? zVars->getEintragAnzahl() : 0;
	for (int i = 0; i < anz; i++)
	{
		lokaleVariablen->set(KSGSKlasseInstanz::erstellVariable(zObj, zVars->get(i)), zVars->get(i)->id + 1);
		varPublic->set(zVars->get(i)->sichtbar == 1, zVars->get(i)->id + 1);
	}
	this->typ = typ;
}

// Destruktor
KSGSKlasseInstanz::~KSGSKlasseInstanz()
{
	lokaleVariablen->release();
	if (funktionen)
		funktionen->release();
	varPublic->release();
}

// nicht constant
KSGSVariable* KSGSKlasseInstanz::startFunktion(int id, bool zugriff, RCArray< KSGSVariable >* parameter)
{
	if (!funktionen || (!zugriff && (!funktionen->z(id) || funktionen->z(id)->getSichtbarkeit() != 1)))
	{
		error(18, {}, obj);
		parameter->release();
		return 0;
	}
	if (!funktionen->z(id))
	{
		parameter->release();
		return 0;
	}
	KSGSFunktionInstanz* inst = funktionen->z(id)->erstellInstanz(obj, dynamic_cast<KSGSKlasseInstanz*>(getThis()), parameter);
	KSGSVariable* ret = inst->startFunktion();
	inst->release();
	return ret;
}

KSGSVariable* KSGSKlasseInstanz::doOperator(int id, KSGSVariable* rechts)
{
	error(21, {}, obj);
	if (rechts)
		rechts->release();
	return 0;
}

void KSGSKlasseInstanz::setVariable(int id, KSGSVariable* var)
{
	lokaleVariablen->set(var, id);
}

// constant
KSGSVariable* KSGSKlasseInstanz::getVariable(int id, bool zugriff) const
{
	if (!zugriff && (!varPublic->hat(id) || !varPublic->get(id)))
	{
		error(17, {}, obj);
		return 0;
	}
	return lokaleVariablen->get(id);
}

KSGSVariable* KSGSKlasseInstanz::umwandelnIn(int typ) const
{
	error(16, {}, obj);
	return 0;
}

int KSGSKlasseInstanz::getTyp() const
{
	return typ;
}

// verarbeiten
bool KSGSKlasseInstanz::getBool() const
{
	if (typ == KSGS_BOOL)
		return ((KSGSBoolKlasse*)this)->getVal();
	else
	{
		KSGSBoolKlasse* tmp = (KSGSBoolKlasse*)umwandelnIn(KSGS_BOOL);
		if (tmp)
		{
			bool ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

int KSGSKlasseInstanz::getInt() const
{
	if (typ == KSGS_INT)
		return ((KSGSIntKlasse*)this)->getVal();
	else
	{
		KSGSIntKlasse* tmp = (KSGSIntKlasse*)umwandelnIn(KSGS_INT);
		if (tmp)
		{
			int ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

double KSGSKlasseInstanz::getDouble() const
{
	if (typ == KSGS_DOUBLE)
		return ((KSGSDoubleKlasse*)this)->getVal();
	else
	{
		KSGSDoubleKlasse* tmp = (KSGSDoubleKlasse*)umwandelnIn(KSGS_DOUBLE);
		if (tmp)
		{
			double ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

Text* KSGSKlasseInstanz::getText() const
{
	if (typ == KSGS_TEXT)
		return ((KSGSTextKlasse*)this)->getVal();
	else
	{
		KSGSTextKlasse* tmp = (KSGSTextKlasse*)umwandelnIn(KSGS_TEXT);
		if (tmp)
		{
			Text* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Text("");
	}
}

Bild* KSGSKlasseInstanz::getBild() const
{
	if (typ == KSGS_BILD)
		return ((KSGSBildKlasse*)this)->getVal();
	else
	{
		KSGSBildKlasse* tmp = (KSGSBildKlasse*)umwandelnIn(KSGS_BILD);
		if (tmp)
		{
			Bild* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Bild();
	}
}

MausEreignis KSGSKlasseInstanz::getMausEreignis() const
{
	if (typ == KSGS_MAUSEREIGNIS)
		return ((KSGSMausEreignisKlasse*)this)->getVal();
	else
	{
		KSGSMausEreignisKlasse* tmp = (KSGSMausEreignisKlasse*)umwandelnIn(KSGS_MAUSEREIGNIS);
		if (tmp)
		{
			MausEreignis ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return MausEreignis{ 0, 0, 0, 0, 1, 0, 0 };
	}
}

TastaturEreignis KSGSKlasseInstanz::getTastaturEreignis() const
{
	if (typ == KSGS_TASTATUREREIGNIS)
		return ((KSGSTastaturEreignisKlasse*)this)->getVal();
	else
	{
		KSGSTastaturEreignisKlasse* tmp = (KSGSTastaturEreignisKlasse*)umwandelnIn(KSGS_TASTATUREREIGNIS);
		if (tmp)
		{
			TastaturEreignis ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return TastaturEreignis{ 0, 0, 0 };
	}
}

TextFeld* KSGSKlasseInstanz::getTextFeld() const
{
	if (typ == KSGS_TEXTFELD)
		return ((KSGSTextFeldKlasse*)this)->getVal();
	else
	{
		KSGSTextFeldKlasse* tmp = (KSGSTextFeldKlasse*)umwandelnIn(KSGS_TEXTFELD);
		if (tmp)
		{
			TextFeld* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new TextFeld();
	}
}

Knopf* KSGSKlasseInstanz::getKnopf() const
{
	if (typ == KSGS_KNOPF)
		return ((KSGSKnopfKlasse*)this)->getVal();
	else
	{
		KSGSKnopfKlasse* tmp = (KSGSKnopfKlasse*)umwandelnIn(KSGS_KNOPF);
		if (tmp)
		{
			Knopf* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Knopf();
	}
}

Fenster* KSGSKlasseInstanz::getFenster() const
{
	if (typ == KSGS_FENSTER)
		return ((KSGSFensterKlasse*)this)->getVal();
	else
	{
		KSGSFensterKlasse* tmp = (KSGSFensterKlasse*)umwandelnIn(KSGS_FENSTER);
		if (tmp)
		{
			Fenster* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Fenster();
	}
}

BildZ* KSGSKlasseInstanz::getBildZ() const
{
	if (typ == KSGS_BILDO)
		return ((KSGSBildZKlasse*)this)->getVal();
	else
	{
		KSGSBildZKlasse* tmp = (KSGSBildZKlasse*)umwandelnIn(KSGS_BILDO);
		if (tmp)
		{
			BildZ* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new BildZ();
	}
}

Animation2DData* KSGSKlasseInstanz::getAnimation2DData() const
{
	if (typ == KSGS_ANIMATION2DDATA)
		return ((KSGSAnimation2DDataKlasse*)this)->getVal();
	else
	{
		KSGSAnimation2DDataKlasse* tmp = (KSGSAnimation2DDataKlasse*)umwandelnIn(KSGS_ANIMATION2DDATA);
		if (tmp)
		{
			Animation2DData* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Animation2DData();
	}
}

Animation2D* KSGSKlasseInstanz::getAnimation2D() const
{
	if (typ == KSGS_ANIMATION2D)
		return ((KSGSAnimation2DKlasse*)this)->getVal();
	else
	{
		KSGSAnimation2DKlasse* tmp = (KSGSAnimation2DKlasse*)umwandelnIn(KSGS_ANIMATION2D);
		if (tmp)
		{
			Animation2D* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Animation2D();
	}
}

Zeichnung* KSGSKlasseInstanz::getZeichnung() const
{
	switch (typ)
	{
	case KSGS_TEXTFELD:
		return ((KSGSTextFeldKlasse*)this)->zVal();
	case KSGS_KNOPF:
		return ((KSGSKnopfKlasse*)this)->zVal();
	case KSGS_FENSTER:
		return ((KSGSFensterKlasse*)this)->zVal();
	case KSGS_BILDO:
		return ((KSGSBildZKlasse*)this)->zVal();
	case KSGS_ANIMATION2D:
		return ((KSGSAnimation2DKlasse*)this)->zVal();
	}
	return 0;
}

RCArray< KSGSVariable >* KSGSKlasseInstanz::getArray() const
{
	if (typ == KSGS_ARRAY)
		return ((KSGSArrayKlasse*)this)->getVal();
	else
	{
		KSGSArrayKlasse* tmp = (KSGSArrayKlasse*)umwandelnIn(KSGS_ARRAY);
		if (tmp)
		{
			RCArray< KSGSVariable >* ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new RCArray< KSGSVariable >();
	}
}

// static
KSGSVariable* KSGSKlasseInstanz::erstellVariable(KSGScriptProcessor* zObj, KSGSVariableDef* def)
{
	if (!def)
	{
		error(0, {}, zObj);
		return 0;
	}
	if (def->typId < KSGS_TYP_MIN)
	{
		error(0, {}, zObj);
		return 0;
	}
	if (def->typId <= KSGS_TYP_MAX)
	{ // Vordefinierter Typ
		switch (def->typId)
		{
		case KSGS_BOOL:
			if (def->wert.istGleich("true"))
				return new KSGSBoolKlasse(zObj, 1);
			if (def->wert.istGleich("false"))
				return new KSGSBoolKlasse(zObj, 0);
			if (def->wert.getLength())
				return new KSGSBoolKlasse(zObj, (int)def->wert != 0);
			return new KSGSBoolKlasse(zObj);
		case KSGS_INT:
			if (def->wert.getLength())
				return new KSGSIntKlasse(zObj, (int)def->wert);
			return new KSGSIntKlasse(zObj);
		case KSGS_DOUBLE:
			if (def->wert.getLength())
				return new KSGSDoubleKlasse(zObj, (double)def->wert);
			return new KSGSDoubleKlasse(zObj);
		case KSGS_TEXT:
			if (def->wert.getLength())
				return new KSGSTextKlasse(zObj, def->wert);
			return new KSGSTextKlasse(zObj);
		case KSGS_BILD:
			return new KSGSBildKlasse(zObj);
		case KSGS_MAUSEREIGNIS:
			return new KSGSMausEreignisKlasse(zObj);
		case KSGS_TASTATUREREIGNIS:
			return new KSGSTastaturEreignisKlasse(zObj);
		case KSGS_TEXTFELD:
			return new KSGSTextFeldKlasse(zObj);
		case KSGS_KNOPF:
			return new KSGSKnopfKlasse(zObj);
		case KSGS_FENSTER:
			return new KSGSFensterKlasse(zObj);
		case KSGS_BILDO:
			return new KSGSBildZKlasse(zObj);
		case KSGS_ANIMATION2DDATA:
			return new KSGSAnimation2DDataKlasse(zObj);
		case KSGS_ANIMATION2D:
			return new KSGSAnimation2DKlasse(zObj);
		default:
			error(1, {}, zObj);
			break;
		}
		return 0;
	}
	else if (zObj) // Im Script Definierter Typ
		return zObj->erstellKlassenInstanz(def->typId);
	error(0, {}, zObj);
	return 0;
}


// Inhalt der KSGSKlasse Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasse::KSGSKlasse(int id)
	: ReferenceCounter()
{
	var = new Array< KSGSVariableDef* >();
	funktionen = new RCArray< KSGSFunktion >();
	this->id = id;
}

// Destruktor
KSGSKlasse::~KSGSKlasse()
{
	int anz = var->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
		delete var->get(i);
	var->release();
	funktionen->release();
}

// nicht constant
void KSGSKlasse::addVariable(KSGSVariableDef* var)
{
	this->var->add(var);
}

void KSGSKlasse::addFunktion(KSGSFunktion* func)
{
	funktionen->add(func);
}

KSGSKlasseInstanz* KSGSKlasse::erstellInstanz(KSGScriptProcessor* zObj)
{
	return new KSGSKlasseInstanz(id, var, dynamic_cast<RCArray<KSGSFunktion>*>(funktionen->getThis()), zObj);
}

// constant
int KSGSKlasse::getId() const
{
	return id;
}