KSG-Framework/InitDatei.cpp

#include "InitDatei.h"

#include "Datei.h"
#include "Text.h"

using namespace Framework;

// Inhalt der InitDatei Klasse aus InitDatei.h
// Konstruktor
InitDatei::InitDatei()
    : ReferenceCounter(),
      pfad(new Text()),
      name(new RCArray<Text>()),
      wert(new RCArray<Text>())
{}

InitDatei::InitDatei(Text* pfad)
    : ReferenceCounter(),
      pfad(new Text()),
      name(new RCArray<Text>()),
      wert(new RCArray<Text>())
{
    setPfad(pfad);
}

InitDatei::InitDatei(const char* pfad)
    : ReferenceCounter(),
      pfad(new Text()),
      name(new RCArray<Text>()),
      wert(new RCArray<Text>())
{
    setPfad(pfad);
}

// Destruktor
InitDatei::~InitDatei()
{
    pfad->release();
    name->release();
    wert->release();
}

// nicht constant
void InitDatei::setPfad(Text* pfad)
{
    this->pfad->setText(*pfad);
    pfad->release();
}

void InitDatei::setPfad(const char* pfad)
{
    this->pfad->setText(pfad);
}

bool InitDatei::laden()
{
    Datei* dat = new Datei();
    dat->setDatei(pfad->getText());
    if (!dat->open(Datei::Style::lesen))
    {
        dat->release();
        return 0;
    }
    removeAlle();
    Text* zeile = dat->leseZeile();
    while (zeile)
    {
        zeile->remove("\r\n");
        zeile->remove("\n");
        Text* n = zeile->getTeilText(0, zeile->positionVon('='));
        Text* w = zeile->getTeilText(zeile->positionVon('=') + 1);
        name->add(n);
        wert->add(w);
        zeile->release();
        zeile = dat->leseZeile();
    }
    dat->close();
    dat->release();
    return 1;
}

bool InitDatei::addWert(Text* name, Text* wert)
{
    if (!wertExistiert(name->getText()))
    {
        this->name->add(new Text(name->getText()));
        this->wert->add(new Text(wert->getText()));
        name->release();
        wert->release();
        return 1;
    }
    name->release();
    wert->release();
    return 0;
}

bool InitDatei::addWert(const char* name, const char* wert)
{
    return addWert(new Text(name), new Text(wert));
}

bool InitDatei::setWert(Text* name, Text* wert)
{
    if (!wertExistiert(name->getText()))
    {
        name->release();
        wert->release();
        return 0;
    }
    auto n = this->name->begin();
    for (auto v = this->wert->begin(); v; v++, n++)
    {
        if (n->istGleich(name->getText()))
        {
            v->setText(wert->getText());
            name->release();
            wert->release();
            return 1;
        }
    }
    name->release();
    wert->release();
    return 0;
}

bool InitDatei::setWert(const char* name, const char* wert)
{
    return setWert(new Text(name), new Text(wert));
}

bool InitDatei::setWert(int num, Text* wert)
{
    bool result = setWert(num, wert->getText());
    wert->release();
    return result;
}

bool InitDatei::setWert(int num, const char* wert)
{
    if (num >= name->getEintragAnzahl()) return 0;
    this->wert->z(num)->setText(wert);
    return 1;
}

bool InitDatei::removeWert(Text* name)
{
    bool result = removeWert(name->getText());
    name->release();
    return result;
}

bool InitDatei::removeWert(const char* name)
{
    if (!wertExistiert(name)) return 0;
    for (int i = 0; i < wert->getEintragAnzahl(); ++i)
    {
        if (this->name->z(i)->istGleich(name))
        {
            this->name->remove(i);
            this->wert->remove(i);
            return 1;
        }
    }
    return 0;
}

bool InitDatei::removeWert(int num)
{
    if (num >= wert->getEintragAnzahl()) return 0;
    this->name->remove(num);
    this->wert->remove(num);
    return 1;
}

void InitDatei::removeAlle()
{
    while (wert->getEintragAnzahl() > 0)
    {
        this->name->remove(0);
        this->wert->remove(0);
    }
}

bool InitDatei::speichern()
{
    Datei* dat = new Datei();
    dat->setDatei(pfad->getText());
    if (!dat->existiert()) dat->erstellen();
    if (!dat->open(Datei::Style::schreiben))
    {
        dat->release();
        return 0;
    }
    auto n = name->begin();
    for (auto v = wert->begin(); v; v++, n++)
    {
        Text* zeile = new Text("");
        zeile->append(n->getText());
        zeile->append("=");
        zeile->append(v->getText());
        zeile->append("\n");
        dat->schreibe(zeile->getText(), zeile->getLength());
        zeile->release();
    }
    dat->close();
    dat->release();
    return 1;
}

// constant
int InitDatei::getWertAnzahl() const
{
    return name->getEintragAnzahl();
}

bool InitDatei::wertExistiert(Text* name)
{
    bool result = wertExistiert(name->getText());
    name->release();
    return result;
}

bool InitDatei::wertExistiert(const char* name)
{
    for (Text* n : *this->name)
    {
        if (n->istGleich(name)) return 1;
    }
    return 0;
}

int InitDatei::getWertNummer(Text* name)
{
    int result = getWertNummer(name->getText());
    name->release();
    return result;
}

int InitDatei::getWertNummer(const char* name)
{
    int i = 0;
    for (Text* n : *this->name)
    {
        if (n->istGleich(name)) return i;
    }
    return -1;
}

Text* InitDatei::getWert(Text* name)
{
    Text* result = getWert(name->getText());
    name->release();
    return result;
}

Text* InitDatei::getWert(const char* name)
{
    auto v = wert->begin();
    for (auto n = this->name->begin(); n; n++, v++)
    {
        if (n->istGleich(name)) return dynamic_cast<Text*>(v->getThis());
    }
    return 0;
}

Text* InitDatei::getWert(int num)
{
    if (num >= name->getEintragAnzahl()) return 0;
    return wert->get(num);
}

Text* InitDatei::zWert(Text* name)
{
    Text* result = zWert(name->getText());
    name->release();
    return result;
}

Text* InitDatei::zWert(const char* name)
{
    auto v = wert->begin();
    for (auto n = this->name->begin(); n; n++, v++)
    {
        if (n->istGleich(name)) return v;
    }
    return 0;
}

Text* InitDatei::zWert(int num)
{
    if (num >= wert->getEintragAnzahl()) return 0;
    return wert->z(num);
}

Text* InitDatei::getName(int num)
{
    if (num >= name->getEintragAnzahl()) return 0;
    return name->get(num);
}

Text* InitDatei::zName(int num)
{
    if (num >= name->getEintragAnzahl()) return 0;
    return name->z(num);
}

Text* InitDatei::getPfad() const
{
    return dynamic_cast<Text*>(pfad->getThis());
}

Text* InitDatei::zPfad() const
{
    return pfad;
}