source: projects/punch-card/punch-card-editor/src/text/codec.cc @ 52

#include <QDebug>
#include <QHash>
#include <QMap>
#include <QSharedPointer>

#include "codec.h"
#include "text/cardcodes.h"

using namespace QPunchCard;

QString Codec::toAscii(const Card* target_card) const {
        QString ret;
        for(int x = 0; x < target_card->length(); x++) {
                ret += toAscii( &target_card->get(x) );
        }
        return ret;
}

void Codec::fromAscii(const QString& string, Card* target_card) const {
        if(string.count() > 80) {
                qDebug() << "Codec: String has "<< string.count() << " chars, will translate 80: "
                         << string << "<<END";
        }
        Q_ASSERT(target_card != 0);
        for(int x = 0; x < qMin(target_card->length(), string.count()); x++) {
                target_card->get(x) = fromAscii( string[x].toAscii() );
        }
}

bool Codec::canEncode(const QString& string) const {
        for(int x = 0; x < string.count(); x++) {
                if(!canEncode( string[x].toAscii() ))
                        return false;
        }
        return true;
}

int Codec::countIllegalColumns(const Card* card) const {
        int fail;
        for(int x = 0; x < card->length(); x++) {
                if( !canEncode(card->get(x)) )
                        fail++;
        }
        return fail;
}

int Codec::countIllegalColumns(const Deck* deck) const {
        int fail;
        for(int x = 0; x < deck->count(); x++) {
                fail += countIllegalColumns(&deck->at(x));
        }
        return fail;
}

CharArrayCodec::CharArrayCodec(const int* table, char illegal) : Codec(illegal), table(table) {
        // Inverse Tabelle (ASCII -> Column-Tabelle) erstellen
        if(!table) {
                // uhh... miserable failure. Sehr schlecht.
                qDebug() << "CharArrayCodec: Table is NULL! This will *CRASH* application!";
                //this->table = o29_code;
        }

        for(int i = 0; i < 4096; i++) {
                // Illegal characters setzen
                inverse_table[i] = illegal;
        }

        for(char c = ' '; c < '`'; c++) {
                inverse_table[ this->table[c] ] = c;
        }
}

QList<QString> CodecFactory::availableCodecs() {
        QList<QString> list;
        list << "o29_code" << "o29_ftn_code" << "o26_comm_code";
        return list;
}

const Codec* CodecFactory::createCodec(const QString& name, char illegal) {
        if("o29_code" == name)
                return new CharArrayCodec(o29_code, illegal);
        else if("o26_ftn_code" == name)
                return new CharArrayCodec(o26_ftn_code, illegal);
        else if("o26_comm_code" == name)
                return new CharArrayCodec(o26_comm_code, illegal);
        else {
                qDebug() << QString("Codec '%s' not supported!").arg(name);
                return NULL;
        }
}

static const QString autoDetectCodec(const Card* card) {
        QMap<int, QString> bad_chars;

        // alle moeglichen Codec-Namen kriegen
        QList<QString> codec_names = CodecFactory::availableCodecs();
        // ueber alle Codecnamen iterieren
        for(QList<QString>::iterator name = codec_names.begin(); name != codec_names.end(); ++name) {
                // dieser Pointer loescht das Objekt nach dem Scope:
                QSharedPointer<const Codec> codec( CodecFactory::createCodec(*name) );

                // Anzahl Bad chars in Map (=> sortiert) speichern
                bad_chars.insertMulti(codec->countIllegalColumns( card ), *name );
        }

        // den erstbesten Codec nehmen (da Map nach anzahl schlechter Zeichen sortiert)
        QString best_code = bad_chars.begin().value();
        return best_code;
}

const QString autoDetectCodec(const Deck* deck) {
        QHash<QString, int> best_codec_counter;

        // alle karten itereieren und hochzaehlen, welcher codec am besten abschnitt
        for(int x = 0; x < deck->count(); x++) {
                // INEFFIZIENZ: bei autoDetectCodec wird *jeder* Codec *neu* erstellt.
                // Loesung: Codec-Caching in der CodecFactory
                best_codec_counter[ autoDetectCodec(&deck->at(x)) ]++;
        }

        // besten Wert kriegen
        QHashIterator<QString, int> i(best_codec_counter);
        QString min_failes_name;
        int min_failes = 0;
        while(i.hasNext()) {
                i.next();
                if(i.value() < min_failes) {
                        min_failes = i.value();
                        min_failes_name = i.key();
                }
        }

        // der ist es
        return min_failes_name;
}