KSG-Framework/InitDatei.cpp

#include "InitDatei.h"
#include "Text.h"
#include "Datei.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 );
}

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;
}