ByteCharacterEncoder.cc

Go to the documentation of this file.

/*
 * ByteCharacterEncoder.cc
 *
 * Smalltalk like class library for C++
 * Character 8-bit encoding translator.
 *
 * Copyright (c) 2005 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stlib/ByteCharacterEncoder.h>
#include <stlib/Array.h>
#include <stlib/Character.h>
#include <stlib/Dictionary.h>
#include <stlib/EncodedStream.h>
#include <stlib/ExternalEncodedStreamFactory.h>
#include <stlib/ExternalReadStream.h>
#include <stlib/FileAccessor.h>
#include <stlib/GenericException.h>
#include <stlib/Integer.h>
#include <stlib/String.h>
#include <stlib/Stream.h>

#include <fcntl.h>

namespace Core {

ByteCharacterEncoder::ByteCharacterEncoder(void)
{
    decodeMap = new Array(256);
    encodeMap = new Dictionary(320); // 256 * 5/4 -> pregrowed
}

ByteCharacterEncoder::~ByteCharacterEncoder(void)
{
    if (decodeMap != nil) delete decodeMap;
    if (encodeMap != nil) delete encodeMap;
}

/* Class-accessing protocol */
String *ByteCharacterEncoder::className(void) const
{
    return new String("ByteCharacterEncoder");
}

/* Initialize protocol */
void ByteCharacterEncoder::loadFromFile(const char *filename)
{
    FileAccessor *file = new FileAccessor(filename, O_RDONLY, 0);
    loadFrom(file->withEncoding("us-ascii")->readStream());
}

void ByteCharacterEncoder::loadFrom(Stream *stream)
{
    _ensure(
        while (!stream->atEnd()) {
            parseLine(dynamic_cast<String *>(stream->nextLine()));
        }
    ,
        stream->close()
    );
}

ByteCharacterEncoder *ByteCharacterEncoder::forASCII(void)
{
    ByteCharacterEncoder *ascii = new ByteCharacterEncoder;
    ascii->initializeAsciiEncoder();
    return ascii;
}

void ByteCharacterEncoder::initializeAsciiEncoder(void)
{
    for (int i = 0; i < 0x7F; i++) {
        Character *character = Character::value(i);
        encodeMap->put(character, Integer::value(i));
        decodeMap->put(i, character);
    }
}

/* Accessing protocol */
Character *ByteCharacterEncoder::decode(Integer *value)
{
    Object *ch = decodeMap->at(value->asLong());
    if (ch == nil)
        error(new String("No character available"),
              new String(__PRETTY_FUNCTION__), value);
    return dynamic_cast<Character *>(ch);
}

Integer *ByteCharacterEncoder::encode(Character *character)
{
    Integer *value = dynamic_cast<Integer *>(encodeMap->at(character, nil));
    if (value == nil)
        error(new String("No character available"),
              new String(__PRETTY_FUNCTION__), character);
    return value;
}

/* Private protocol */
long ByteCharacterEncoder::integerValueFrom(String *strNumber)
{
    unsigned long value = 0, index = 0, radix = 10;
    if (strNumber->startsWith("0x")) {
        index = 2;
        radix = 16;
    }

    for (; index < strNumber->size(); index++) {
        Character *ch = dynamic_cast<Character *>(strNumber->at(index));
        value = value * radix + ch->digitValue();
    }
    return value;
}
    
void ByteCharacterEncoder::parseLine(String *line)
{
    long idx;
    unsigned long encValue, charValue;
    Character *character;

    line->replaceAll(Character::tab(), Character::space());

    /* Remove comments */
    idx = line->indexOf('#');
    if (idx > 0) line = dynamic_cast<String *>(line->copy(0, idx));
    line = line->trimBlanks();
    if (idx == 0 || line->isEmpty()) return;

    Array *pair = line->asArrayOfSubstrings();
    if (pair->size() >= 2) {  /* At least two items are needed */
        encValue = integerValueFrom(dynamic_cast<String *>(pair->at(0)));
        charValue = integerValueFrom(dynamic_cast<String *>(pair->at(1)));
    }
    character = Character::value(charValue);
    encodeMap->put(character, Integer::value(encValue));
    decodeMap->put(encValue, character);
}

};

---