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()
    : pfad( new Text() ),
    feldAnzahl( 0 ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() ),
    ref( 1 )
{}

InitDatei::InitDatei( Text *pfad )
    : pfad( new Text() ),
    feldAnzahl( 0 ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() ),
    ref( 1 )
{
    setPfad( pfad );
}

InitDatei::InitDatei( const char *pfad )
    : pfad( new Text() ),
    feldAnzahl( 0 ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() ),
    ref( 1 )
{
    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->öffnen( Datei::Style::lesen ) )
    {
        dat->release();
        return 0;
    }
    löscheAlle();
    Text *zeile = dat->leseZeile();
    for( int i = 0; zeile; ++i )
    {
        zeile->löschen( "\r\n" );
        zeile->löschen( "\n" );
        Text *n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
        Text *w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
        name->set( n, i );
        wert->set( w, i );
        zeile->release();
        zeile = dat->leseZeile();
        feldAnzahl = i + 1;
    }
    dat->schließen();
    dat->release();
    return 1;
}

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

bool InitDatei::addWert( const char *name, const char *wert )
{
    if( !wertExistiert( name ) )
    {
        this->name->set( new Text( name ), feldAnzahl );
        this->wert->set( new Text( wert ), feldAnzahl );
        ++feldAnzahl;
        return 1;
    }
    return 0;
}

bool InitDatei::setWert( Text *name, Text *wert )
{
    if( !wertExistiert( name->getText() ) )
    {
        name->release();
        wert->release();
        return 0;
    }
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            this->wert->z( i )->setText( wert->getText() );
            name->release();
            wert->release();
            return 1;
        }
    }
    name->release();
    wert->release();
    return 0;
}

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

bool InitDatei::setWert( int num, Text *wert )
{
    if( num >= feldAnzahl )
    {
        wert->release();
        return 0;
    }
    this->wert->z( num )->setText( wert->getText() );
    wert->release();
    return 1;
}

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

bool InitDatei::löscheWert( Text *name )
{
    if( !wertExistiert( name->getText() ) )
    {
        name->release();
        return 0;
    }
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            this->name->lösche( i );
            this->wert->lösche( i );
            --feldAnzahl;
            name->release();
            return 1;
        }
    }
    name->release();
    return 0;
}

bool InitDatei::löscheWert( const char *name )
{
    if( !wertExistiert( name ) )
        return 0;
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name ) )
        {
            this->name->lösche( i );
            this->wert->lösche( i );
            --feldAnzahl;
            return 1;
        }
    }
    return 0;
}

bool InitDatei::löscheWert( int num )
{
    if( num >= feldAnzahl )
        return 0;
    this->name->lösche( num );
    this->wert->lösche( num );
    --feldAnzahl;
    return 1;
}

void InitDatei::löscheAlle()
{
    for( ; feldAnzahl > 0; --feldAnzahl )
    {
        this->name->lösche( 0 );
        this->wert->lösche( 0 );
    }
}

bool InitDatei::speichern()
{
    Datei *dat = new Datei();
    dat->setDatei( pfad->getText() );
    if( !dat->existiert() )
        dat->erstellen();
    if( !dat->öffnen( Datei::Style::schreiben ) )
    {
        dat->release();
        return 0;
    }
    for( int i = 0; i < feldAnzahl; ++i )
    {
        Text *zeile = new Text( "" );
        zeile->anhängen( name->z( i )->getText() );
        zeile->anhängen( "=" );
        zeile->anhängen( wert->z( i )->getText() );
        zeile->anhängen( "\n" );
        dat->schreibe( zeile->getText(), zeile->getLänge() );
        zeile->release();
    }
    dat->schließen();
    dat->release();
    return 1;
}

// constant
int InitDatei::getWertAnzahl() const
{
    return feldAnzahl;
}

bool InitDatei::wertExistiert( Text *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            name->release();
            return 1;
        }
    }
    name->release();
    return 0;
}

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

int InitDatei::getWertNummer( Text *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            name->release();
            return i;
        }
    }
    name->release();
    return -1;
}

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

Text *InitDatei::getWert( Text *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            name->release();
            return wert->get( i );
        }
    }
    name->release();
    return 0;
}

Text *InitDatei::getWert( const char *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name ) )
            return wert->get( i );
    }
    return 0;
}

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

Text *InitDatei::zWert( Text *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name->getText() ) )
        {
            name->release();
            return wert->z( i );
        }
    }
    name->release();
    return 0;
}

Text *InitDatei::zWert( const char *name )
{
    for( int i = 0; i < feldAnzahl; ++i )
    {
        if( this->name->z( i )->istGleich( name ) )
            return wert->z( i );
    }
    return 0;
}

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

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

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

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

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

// reference Counting
InitDatei *InitDatei::getThis()
{
    ++ref;
    return this;
}

InitDatei *InitDatei::release()
{
    --ref;
    if( !ref )
        delete this;
    return 0;
}