KSG-Framework/KSGTDatei.cpp

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

using namespace Framework;

// Inhalt der KSGTDatei Klasse aus KSGTDatei.h
// Konstruktor
KSGTDatei::KSGTDatei()
    : pfad( new Text() ),
    data( new RCArray< RCArray< Text > >() ),
    ref( 1 )
{}

KSGTDatei::KSGTDatei( const char *pfad )
    : pfad( new Text() ),
    data( new RCArray< RCArray< Text > >() ),
    ref( 1 )
{
    setPfad( pfad );
}

KSGTDatei::KSGTDatei( Text *pfad )
    : pfad( new Text() ),
    data( new RCArray< RCArray< Text > >() ),
    ref( 1 )
{
    setPfad( pfad );
}

// Destruktor
KSGTDatei::~KSGTDatei()
{
    pfad->release();
    data->release();
}

// nicht constant
void KSGTDatei::setPfad( const char *pfad )
{
    this->pfad->setText( pfad );
}

void KSGTDatei::setPfad( Text *pfad )
{
    this->pfad->setText( pfad );
}

bool KSGTDatei::laden()
{
    std::ifstream inf;
    inf.open( pfad->getText(), std::ios::binary );
    if( !inf.good() || !inf.is_open() )
        return 0;
    data->leeren();
    inf.seekg( 0, std::ios::end );
    __int64 gr = inf.tellg();
    __int64 pos = 0;
    int zeilenPos = 0;
    int feldPos = 0;
    while( pos < gr )
    {
        inf.seekg( pos, std::ios::beg );
        char c = 1;
        int län = 0;
        do
        {
            inf.read( &c, 1 );
            ++län;
        } while( c != 0 && c != '\n' && pos + län < gr );
        if( pos + län == gr )
            ++län;
        inf.seekg( pos, std::ios::beg );
        char *v = new char[ län ];
        v[ län - 1 ] = 0;
        if( län > 1 )
            inf.read( v, län - 1 );
        pos += län;
        if( län > 1 && !data->z( zeilenPos ) )
            data->set( new RCArray< Text >, zeilenPos );
        if( !data->z( zeilenPos )->z( feldPos ) )
            data->z( zeilenPos )->set( new Text(), feldPos );
        data->z( zeilenPos )->z( feldPos )->setText( v );
        delete[] v;
        if( c == 0 )
            ++feldPos;
        else if( c == '\n' )
        {
            ++zeilenPos;
            feldPos = 0;
        }
        else
            break;
    }
    inf.close();
    return 1;
}

bool KSGTDatei::addZeile( int feldAnzahl, RCArray< Text > *zWert )
{
    int pos = getZeilenAnzahl();
    data->set( new RCArray< Text >(), pos );
    for( int i = 0; i < feldAnzahl; ++i )
        data->z( pos )->set( new Text( zWert->z( i )->getText() ), i );
    return 1;
}

bool KSGTDatei::setZeile( int zeile, int feldAnzahl, RCArray< Text > *zWert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    data->set( new RCArray< Text >(), zeile );
    for( int i = 0; i < feldAnzahl; ++i )
        data->z( zeile )->set( new Text( zWert->z( i )->getText() ), i );
    return 1;
}

bool KSGTDatei::löscheZeile( int zeile )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    data->lösche( zeile );
    return 1;
}

bool KSGTDatei::addFeld( int zeile, int pos, Text *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
    {
        wert->release();
        return 0;
    }
    int fA = getFeldAnzahl( zeile );
    if( pos > fA )
    {
        wert->release();
        return 0;
    }
    data->z( zeile )->add( new Text( wert->getText() ), pos );
    wert->release();
    return 1;
}

bool KSGTDatei::addFeld( int zeile, int pos, const char *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    if( pos > fA )
        return 0;
    data->z( zeile )->add( new Text( wert ), pos );
    return 1;
}

bool KSGTDatei::addFeld( int zeile, Text *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
    {
        wert->release();
        return 0;
    }
    int fA = getFeldAnzahl( zeile );
    data->z( zeile )->set( new Text( wert->getText() ), fA );
    wert->release();
    return 1;
}

bool KSGTDatei::addFeld( int zeile, const char *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    data->z( zeile )->set( new Text( wert ), fA );
    return 1;
}

bool KSGTDatei::setFeld( int zeile, int feld, Text *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
    {
        wert->release();
        return 0;
    }
    int fA = getFeldAnzahl( zeile );
    if( feld >= fA )
    {
        wert->release();
        return 0;
    }
    data->z( zeile )->set( new Text( wert->getText() ), feld );
    wert->release();
    return 1;
}

bool KSGTDatei::setFeld( int zeile, int feld, const char *wert )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    if( feld >= fA )
        return 0;
    data->z( zeile )->set( new Text( wert ), feld );
    return 1;
}

bool KSGTDatei::löscheFeld( int zeile, int feld )
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    if( feld >= fA )
        return 0;
    data->z( zeile )->lösche( feld );
    return 1;
}

bool KSGTDatei::speichern()
{
    if( !pfad->getLänge() )
        return 0;
    if( !DateiExistiert( pfad->getText() ) )
        DateiPfadErstellen( pfad->getText() );
    std::ofstream of( pfad->getText(), std::ios::binary );
    if( !of.good() || !of.is_open() )
        return 0;
    int zA = getZeilenAnzahl();
    for( int z = 0; z < zA; ++z )
    {
        if( z )
            of.write( "\n", 1 );
        int fA = getFeldAnzahl( z );
        for( int f = 0; f < fA; ++f )
        {
            if( f )
                of.write( "\0", 1 );
            if( data->z( z ) && data->z( z )->z( f ) )
                of.write( data->z( z )->z( f )->getText(), data->z( z )->z( f )->getLänge() );
        }
    }
    of.close();
    return 1;
}

// constant
int KSGTDatei::getZeilenAnzahl() const
{
    int ret = 0;
    while( data->z( ret ) )
        ++ret;
    return ret;
}

int KSGTDatei::getFeldAnzahl( int zeile ) const
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int ret = 0;
    while( data->z( zeile )->z( ret ) )
        ++ret;
    return ret;
}

Text *KSGTDatei::getFeld( int zeile, int feld ) const
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    if( feld >= fA )
        return 0;
    return data->z( zeile )->get( feld );
}

Text *KSGTDatei::zFeld( int zeile, int feld ) const
{
    int zA = getZeilenAnzahl();
    if( zeile >= zA )
        return 0;
    int fA = getFeldAnzahl( zeile );
    if( feld >= fA )
        return 0;
    return data->z( zeile )->z( feld );
}

// Reference Counting
KSGTDatei *KSGTDatei::getThis()
{
    ++ref;
    return this;
}

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