Character.cc

Go to the documentation of this file.

/*
 * Character.cc
 *
 * Smalltalk like class library for C++
 * Character wrapper.
 *
 * Copyright (c) 2003-5 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/Character.h>
#include <stlib/Association.h>
#include <stlib/Dictionary.h>
#include <stlib/Integer.h>
#include <stlib/String.h>
#include <stlib/Stream.h>
#include <stlib/Visitor.h>

#include <ctype.h>

Dictionary *Character::character_store = nil;

Character::Character(unsigned long val)
{
    _value = val;
}

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

Dictionary *Character::characterStore(void)
{
    if (character_store == nil)
        character_store = new Dictionary(128);
    return character_store;
}

/* Class-constants protocol */
Character *Character::cr(void)
{
    return value('\r');
}

Character *Character::lf(void)
{
    return value('\n');
}

Character *Character::space(void)
{
    return value(32);
}

Character *Character::tab(void)
{
    return value('\t');
}

/* Instance creation protocol */
Character *Character::value(unsigned long val)
{
    return Character::value(Integer::value(val));
}

Character *Character::value(Integer *val)
{
    /* Can't use Dictionary>>#at:ifAbsent: method 'cause it raises exception
       that may need to construct more Characters. */
    Character *chr;
    int index = characterStore()->findKeyOrNil(val);
    if (characterStore()->isEmptyAt(index)) {
        /* Need to construct new one */
        chr = new Character(val->asUnsignedLong());
        characterStore()->atNewIndexPut(index, new Association(val, chr));
    } else {
        /* OK now. Sure it's there. */
        Association *assoc = dynamic_cast<Association *>(characterStore()->privAtIndex(index));
        chr = dynamic_cast<Character *>(assoc->value());
    }
    return chr;
}

/* Accessing protocol */
int Character::byteSize(void)
{
    if (_value < 256) return 1;
    if (_value < 65536) return 2;
    return 4;
}

int Character::digitValue(void)
{
    int code = asInteger();
    int val = code - '0';
    if (val <= 9) return val;
    val = code - 'A';
    if (val >= 0 && val < 26) return val + 10;
    val = code - 'a';
    if (val >= 0 && val < 26) return val + 10;
    return -1;
}

/* Comparing protocol */
long Character::hash(void) const
{
    return (long) _value;
}

bool Character::isEqual(const Object *object) const
{
    if (object == nil) return false;

    return object->isCharacter() &&
           _value == ((Character *) object)->_value;
}

bool Character::isEqual(char cChar) const
{
    return _value == cChar;
}

/* Converting protocol */
unsigned long Character::asInteger(void)
{
    return _value;
}

Character *Character::asLowercase(void)
{
    return value(tolower(_value));
}

Character *Character::asUppercase(void)
{
    return value(toupper(_value));
}

/* Printing protocol */
void Character::printOn(Stream *stream) const
{
    stream->nextPut('\'');
    stream->nextPut(_value);
    stream->nextPutAll("\' /* ");
    stream->nextPutAll(String::format("0x%02X", _value));
    stream->nextPutAll(" */");
}

/* Testing protocol */
bool Character::isCharacter(void) const
{
    return true;
}

bool Character::isSeparator(void) const
{
    return isspace(_value);
}

bool Character::isVowel(void) const
{
    char upperCase = toupper(_value);
    return upperCase == 'A' || upperCase == 'E' || upperCase == 'I' ||
           upperCase == 'Y' || upperCase == 'O' || upperCase == 'U';
}

bool Character::isDigit(void) const
{
    return isdigit(_value);
}

bool Character::isLowercase(void) const
{
    return islower(_value);
}

bool Character::isUppercase(void) const
{
    return isupper(_value);
}

/* Visiting protocol */
void Character::visitBy(Visitor *visitor)
{
    visitor->visitCharacter(this);
}

---