common.cpp

Go to the documentation of this file.

/**********************************************************************
** Copyright (C) 2000 Trolltech AS.  All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "common.h"
#include "datacache.h"

/* OPIE */
#include <opie2/odebug.h>
#include <qpe/timestring.h>
using namespace Opie::Core;

/* QT */
#include <qstring.h>
#include <qheader.h>
#include <qvector.h>
#include <qdatetime.h>

/* STD */
#include <assert.h>
#include <stdlib.h>

static const int del_flag = 0x1;
static const int new_flag = 0x2;

/* Helper function */

int parseNextNumber(QString *q) {
    QChar c;
    uint i;
    int result = 0;

    bool found_digits = FALSE;
    for(i = 0; i < q->length(); i++) {
        c = q->at(i);
        if (c.isDigit()) {
            if (found_digits)
                result *= 10;
            found_digits = TRUE;
            result += c.digitValue();
        } else {
            if (found_digits)
                break;
            /* just skip this char */
        }
    }
    /* now truncate q */
    if (found_digits)
        q->remove(0, i);
    return result;
}

int QStringVector::compareItems(Item a, Item b)
{
    QString *qa = (QString *)a;
    QString *qb = (QString *)b;

    return QString::compare(*qa, *qb);
}

TVVariantPrivate::TVVariantPrivate()
{
    typ = TVVariant::Invalid;
}

TVVariantPrivate::TVVariantPrivate( TVVariantPrivate *d)
{
    switch(d->typ)
    {
        case TVVariant::Invalid:
            break;
        case TVVariant::String:
            value.ptr = new QString(*((QString *)d->value.ptr));
            break;
        case TVVariant::Date:
            value.ptr = new QDate(*((QDate *)d->value.ptr));
            break;
        case TVVariant::Time:
            value.ptr = new QTime(*((QTime *)d->value.ptr));
            break;
        case TVVariant::Int:
            value.i = d->value.i;
            break;
        default:
            ASSERT( 0 );
    }

    typ = d->typ;
}

TVVariantPrivate::~TVVariantPrivate()
{
    clear();
}

void TVVariantPrivate::clear()
{
    switch( typ )
    {
        case TVVariant::String:
            delete (QString *)value.ptr;
            break;
        case TVVariant::Date:
            delete (QDate *)value.ptr;
            break;
        case TVVariant::Time:
            delete (QTime *)value.ptr;
            break;
        case TVVariant::Invalid:
        case TVVariant::Int:
            break;
    }

    typ = TVVariant::Invalid;
}

TVVariant::TVVariant()
{
    d = new TVVariantPrivate;
}

TVVariant::~TVVariant()
{
    if (d->deref())
        delete d;
}

TVVariant::TVVariant(const TVVariant& p)
{
    d = new TVVariantPrivate;
    *this = p;
}

TVVariant::TVVariant(QDataStream& s)
{
    d = new TVVariantPrivate;
    s >> *this;
}

TVVariant::TVVariant(const QString &val)
{
    d = new TVVariantPrivate;
    d->typ = String;
    d->value.ptr = new QString(val);
}

TVVariant::TVVariant(const QDate &val)
{
    d = new TVVariantPrivate;
    d->typ = Date;
    d->value.ptr = new QDate(val);
}

TVVariant::TVVariant(const QTime &val)
{
    d = new TVVariantPrivate;
    d->typ = Time;
    d->value.ptr = new QTime(val);
}

TVVariant::TVVariant( int val )
{
    d = new TVVariantPrivate;
    d->typ = Int;
    d->value.i = val;
}

TVVariant& TVVariant::operator=(const TVVariant& variant )
{
    TVVariant& other = (TVVariant&) variant;

    other.d->ref();
    if ( d->deref() )
    delete d;

    d = other.d;

    return *this;
}

void TVVariant::detach()
{
    if (d->count == 1)
    return;

    d->deref();
    d = new TVVariantPrivate(d);
}

const QString TVVariant::typeName() const
{
    return typeToName(d->typ);
}

void TVVariant::clear()
{
    if (d->count > 1)
    {
        d->deref();
        d = new TVVariantPrivate;
        return;
    }

    d->clear();
}

const QString TVVariant::typeToName(KeyType typ)
{
    switch(typ) {
        case String:
            return QString("String");
        case Date:
            return QString("Date");
        case Time:
            return QString("Time");
        case Int:
            return QString("Int");
        case Invalid:
        default:
            return QString("Invalid");
    }
    return QString("Invalid");
}

TVVariant::KeyType TVVariant::nameToType(const QString &name)
{
    if(!qstrcmp("String", name))
        return String;
    if(!qstrcmp("Date", name))
        return Date;
    if(!qstrcmp("Time", name))
        return Time;
    if(!qstrcmp("Int", name))
        return Int;

    return Invalid;
}

void TVVariant::load(QDataStream &s )
{
    KeyType t;
    s >> t;

    d->typ = t;
    switch(t) {
        case Invalid:
            d->typ = t;
            break;
        case String:
            {
                QString *x = new QString;
                s >> *x;
                d->value.ptr = x;
            }
            break;
        case Time:
            {
                QTime *x = new QTime;
                s >> *x;
                d->value.ptr = x;
            }
            break;
        case Date:
            {
                QDate *x = new QDate;
                s >> *x;
                d->value.ptr = x;
            }
            break;
        case Int:
            {
                int x;
                s >> x;
                d->value.i = x;
            }
      break;
        default:
      ofatal << "Unrecognized data type" << oendl;
    }
}

void TVVariant::save( QDataStream &s ) const
{
    s << type();

    switch( d->typ ) {
        case String:
            s << *((QString *)d->value.ptr);
            break;
        case Date:
            s << *((QDate *)d->value.ptr);
            break;
        case Time:
            s << *((QTime *)d->value.ptr);
            break;
        case Int:
            s << d->value.i;
            break;
        case Invalid:
            break;
    }
}

QDataStream& operator>>(QDataStream& s, TVVariant& p)
{
    p.load( s );
    return s;
}

QDataStream& operator<<(QDataStream &s, const TVVariant& p)
{
    p.save( s );
    return s;
}

QDataStream& operator>> (QDataStream &s, TVVariant::KeyType& p)
{
    Q_UINT8 u = 0;
    s >> u;
    p = (TVVariant::KeyType) u;

    return s;
}

QDataStream& operator<< (QDataStream& s, const TVVariant::KeyType& p)
{
    s << (Q_UINT8)p;
    return s;
}

const QString TVVariant::toString() const
{
    switch(d->typ) {
        case String:
            return *((QString*)d->value.ptr);
        case Date:
            return ((QDate*)d->value.ptr)->toString();
        case Time:
            return ((QTime*)d->value.ptr)->toString();
        case Int:
                return QString::number(d->value.i);
        case Invalid:
        default:
            return QString::null;
    }
    return QString::null;
}

// TODO DO, this properly, */
int TVVariant::toInt() const
{
    if(d->typ == Int)
        return d->value.i;

    if(d->typ == String) {
      QString tmpq(*(QString *)d->value.ptr);
        return parseNextNumber(&tmpq);
    }

    return 0;
}

const QDate TVVariant::toDate() const
{
    if(d->typ == Date)
        return *((QDate *)d->value.ptr);

    if(d->typ == String) {
        QString q = toString();

        /* date format is day mon d yyyy */
        /* ignore the first three letters, read the next
           three for month.. etc */

        int day = parseNextNumber(&q);
        int month = parseNextNumber(&q);
        int year = parseNextNumber(&q);
        if (!QDate::isValid(year, month, day))
            return QDate();
        return QDate(year, month, day);
    }


    return QDate();
}

const QTime TVVariant::toTime() const
{
    if(d->typ == Time)
        return *((QTime *)d->value.ptr);

    if(d->typ == String) {
        QString q = toString();
        int hour = parseNextNumber(&q);
        int minute = parseNextNumber(&q);
        int second = parseNextNumber(&q);
        int msecond = parseNextNumber(&q);
        if (!QTime::isValid(hour, minute, second, msecond))
            return QTime();
        return QTime(hour, minute, second, msecond);
    }

    return QTime();
}

#define TV_VARIANT_AS( f ) Q##f& TVVariant::as##f() { \
    if ( d->typ != f ) \
        *this = TVVariant( to##f() ); \
    else \
        detach(); \
    return *((Q##f*)d->value.ptr); }

TV_VARIANT_AS(String)
TV_VARIANT_AS(Date)
TV_VARIANT_AS(Time)

#undef TV_VARIANT_AS

int& TVVariant::asInt()
{
    detach();
    if (d->typ != Int) {
        d->value.i = toInt();
        d->typ = Int;
    }
    return d->value.i;
}

bool TVVariant::canCast(KeyType t) const
{
    if(d->typ == t)
        return TRUE;

    if(t == String)
        return TRUE;

    if(t == Int) {
        if (d->typ == Date)
            return TRUE;
        if (d->typ == Time)
            return TRUE;
        if (d->typ == String)
            return TRUE;
    }

    return FALSE;
}

bool TVVariant::operator==( const TVVariant &v ) const
{
    switch(d->typ) {
        case String:
            return v.toString() == toString();
        case Date:
            return v.toDate() == toDate();
        case Time:
            return v.toTime() == toTime();
        case Int:
            return v.toInt() == toInt();
        case Invalid:
            break;
    }

    return FALSE;
}

bool TVVariant::operator!=( const TVVariant &v ) const
{
    return !( v == *this);
}

bool TVVariant::operator<( const TVVariant &v ) const
{
    switch(d->typ) {
        case String:
            return toString().lower() < v.toString().lower();
        case Date:
            return toDate() < v.toDate();
        case Time:
            return toTime() < v.toTime();
        case Int:
            return toInt() < v.toInt();
        case Invalid:
        default:
            break;
    }
    return FALSE;
}

bool TVVariant::operator>( const TVVariant &v ) const
{
    switch(d->typ) {
        case String:
            return toString().lower() > v.toString().lower();
        case Date:
            return toDate() > v.toDate();
        case Time:
            return toTime() > v.toTime();
        case Int:
            return toInt() > v.toInt();
        case Invalid:
        default:
            break;
    }
    return FALSE;
}

bool TVVariant::closer(TVVariant n, TVVariant o)
{
    /* Nothing is close to an invalid, so nothing can be closer */
    if(d->typ == Invalid)
        return FALSE;

    /* can't be closer if of different type */
    if(n.type() != type())
        return FALSE;

    /* if new shares type, and old doesn't, then new is closer */
    if(o.type() != type())
        return TRUE;

    switch(type()){
        case String: {
            /* case for strings is close is a substring.. closer is
             * earlier alphabetically */
            QString qs1 = n.toString().lower();
            QString qs2 = o.toString().lower();
            QString qsv = toString().lower();

            if (!qs1.startsWith(qsv))
                return FALSE;

            /* contains sub-str, if later than is not closer */
            if(QString::compare(qs1, qs2) > 0)
                return FALSE;
            return TRUE;
        }
        case Int: {
            /* case for int is smallest absolute difference */
            int i1 = n.toInt();
            int i2 = o.toInt();
            int iv = toInt();

            int diff1 = (i1 - iv);
            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = (i2 - iv);
            if (diff2 < 0)
                diff2 = -diff2;

            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        case Date: {
            QDate i1 = n.toDate();
            QDate i2 = o.toDate();
            QDate iv = toDate();

            /* definition of closer is the least difference in days */
            int diff1 = i1.daysTo(iv);
            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = i2.daysTo(iv);
            if (diff2 < 0)
                diff2 = -diff2;

            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        case Time: {
            QTime i1 = n.toTime();
            QTime i2 = o.toTime();
            QTime iv = toTime();

            /* definition of closer is the least difference in days */
            int diff1 = i1.msecsTo(iv);
            if (diff1 < 0)
                diff1 = -diff1;
            int diff2 = i2.msecsTo(iv);
            if (diff2 < 0)
                diff2 = -diff2;
            if (diff1 < diff2)
                return TRUE;
            return FALSE;
        }
        default:
            /* don't know how to do 'closer' on this type, hence never closer
             * or even close */
            break;
    }
    return FALSE;
}

bool TVVariant::close(TVVariant n)
{
    /* Nothing is close to an invalid, so nothing can be closer */
    if(type() == Invalid)
        return FALSE;

    /* can't be close if of different type */
    if(n.type() != type())
        return FALSE;

    switch(type()){
        case String: {
            /* case for strings is close is a substring.. closer is
             * earlier alphabetically */
            QString qs1 = n.toString().lower();
            QString qsv = toString().lower();

            if (!qs1.startsWith(qsv))
                return FALSE;
            return TRUE;
        }
        case Int:
        case Date:
        case Time:
            return TRUE;
        default:
            /* don't know how to do 'closer' on this type, hence never closer
             * or even close */
            break;
    }
    return FALSE;
}

Key::Key() : kname(), kexample(), kflags(0) { }

Key::Key(QString name, TVVariant example, int flags) :
    kname(name), kexample(example), kflags(flags) { }

Key::Key(const Key &other)
{
  kname = other.kname;
  kexample = other.kexample;
  kflags = other.kflags;
}

Key& Key::operator=(const Key& key)
{
    kname = key.kname;
    kexample = key.kexample;
    kflags = key.kflags;
    return *this;
}

QString Key::name() const
{
    return QString(kname);
}

TVVariant Key::example() const
{
    return TVVariant(kexample);
}

TVVariant::KeyType Key::type() const
{
    return kexample.type();
}

void Key::setName(const QString &name)
{
    kname = QString(name);
}

void Key::setExample(const TVVariant &e)
{
    kexample = TVVariant(e);
}

int Key::flags() const
{
    return kflags;
}

void Key::setFlags(int fl)
{
    kflags = fl;
}

bool Key::delFlag() const
{
    if(kflags & del_flag)
        return TRUE;
    return FALSE;
}

bool Key::newFlag() const
{
    if(kflags & new_flag)
        return TRUE;
    return FALSE;
}

void Key::setDelFlag(bool v)
{
    if(delFlag() != v)
        kflags = kflags ^ del_flag;
}

void Key::setNewFlag(bool v)
{
    if(newFlag() != v)
        kflags = kflags ^ new_flag;
}

KeyList::KeyList() : QIntDict<Key>(20)
{
    setAutoDelete(TRUE);
}

/* Should be deep copy, but isn't */
KeyList::KeyList(const KeyList &k) : QIntDict<Key>(k)
{
    KeyListIterator it(k);
  while(it.current()) {
    replace(it.currentKey(), new Key(*it.current()));
    ++it;
  }

    setAutoDelete(TRUE);
}

KeyList::~KeyList() {
}

/* Do a comparision base on Keys */
bool KeyList::operator!=(const KeyList &other)
{
    KeyListIterator it(*this);

    if (other.getNumFields() != getNumFields())
  return TRUE;

    while(it.current()) {
  //it.currentKey(), it.current();
  if (other.getKeyName(it.currentKey()) != getKeyName(it.currentKey()))
      return TRUE;
  if (other.getKeyType(it.currentKey()) != getKeyType(it.currentKey()))
      return TRUE;
  ++it;
    }
    return FALSE;
}

int KeyList::getNumFields() const
{
    return count();
}

int KeyList::addKey(QString name, TVVariant example)
{
    int i = count();
    while(find(i) && (i > -1))
        i--;
    replace(i, new Key(name, example, 0));
    return i;
}

int KeyList::addKey(QString name, TVVariant::KeyType type)
{
    /* generate a valid type for the example? */
    TVVariant e = TVVariant("0");
    switch(type) {
        case TVVariant::String:
            return addKey(name, TVVariant("<undefined>").asString());
            break;
        case TVVariant::Date:
            return addKey(name, TVVariant(QDate::currentDate()).asDate());
            break;
        case TVVariant::Time:
            return addKey(name, TVVariant(QTime(0,0,0)).toTime());
            break;
        case TVVariant::Int:
            return addKey(name, TVVariant(0).toInt());
            break;
        default:
            owarn << "KeyList::addKey() Cannot make default value for type " << type << ", Key not added." << oendl;
            break;
    }
    return -1;
}

void KeyList::setKeyFlags(int i, int flag)
{
    if(find(i))
        find(i)->setFlags(flag);
}

int KeyList::getKeyFlags(int i) const
{
    if(find(i))
        return find(i)->flags();
    return 0;
}

bool KeyList::checkNewFlag(int i) const
{
    if (find(i))
        return find(i)->newFlag();
    return false;
}

void KeyList::setNewFlag(int i, bool f)
{
    if(!find(i))
        return;
    find(i)->setNewFlag(f);
}

bool KeyList::checkDeleteFlag(int i) const
{
    if (find(i))
        return find(i)->delFlag();
    return false;
}

void KeyList::setDeleteFlag(int i, bool f)
{
    if(!find(i))
        return;
    find(i)->setDelFlag(f);
}

QString KeyList::getKeyName(int i) const
{
    if (find (i))
        return find(i)->name();
    return QString();
}

void KeyList::setKeyName(int i, const QString &n)
{
    if(find(i))
        find(i)->setName(n);
}

TVVariant::KeyType KeyList::getKeyType(int i) const
{
    if(find(i))
        return find(i)->type();
    return TVVariant::Invalid;
}

void KeyList::setKeyType(int i, TVVariant::KeyType t)
{
    if(!find(i))
        return;
    switch(t) {
        case TVVariant::String:
            find(i)->setExample(TVVariant(QString("default")));
            return;
        case TVVariant::Int:
            find(i)->setExample(TVVariant(int(0)));
            return;
        case TVVariant::Date:
            find(i)->setExample(TVVariant(QDate::currentDate()));
            return;
        case TVVariant::Time:
            find(i)->setExample(TVVariant(QTime(0,0,0,0)));
            return;
        default:
            break;
    }
    return;
}

TVVariant KeyList::getKeyExample(int i) const
{
    if(find(i))
        return find(i)->example();
    return TVVariant();
}

void KeyList::setKeyExample(int i, TVVariant example)
{
    if(find(i))
        find(i)->setExample(example);
}

int KeyList::getKeyIndex(QString q) const
{
    KeyListIterator it(*this);

    while(it.current()) {
        if(it.current()->name() == q)
            return it.currentKey();
        ++it;
    }
    return -1;
}

bool KeyList::validIndex(int i) const
{
    if(!find(i))
        return FALSE;
    if(find(i)->delFlag())
        return FALSE;
    return TRUE;
}

QDataStream &operator<<( QDataStream &s, const KeyList &k)
{
    s << k.getNumFields();

    KeyListIterator it(k);

    while(it.current()) {
        s << (Q_UINT16)it.currentKey();
        s << it.current()->name();
        s << it.current()->example();
        s << (Q_UINT16)it.current()->flags();
        ++it;
    }
    return s;
}

QDataStream &operator>>( QDataStream &s, KeyList &k)
{
    int i;
    int size;
    int index = 0;
    int flags = 0;
    TVVariant type = TVVariant();
    QString name;

    s >> size;

    for (i=0; i < size; i++) {
        s >> (Q_UINT16 &)index;
        s >> name;
        s >> type;
        s >> (Q_UINT16 &)flags;
        k.replace(index, new Key(name, type, flags));
    }
    return s;
}

DataElem::DataElem(DBStore *c) : values(20)
{
    int size;
    contained = c;
    size = c->getNumFields();
    values.setAutoDelete(TRUE);
}

DataElem::~DataElem() {
}



QDataStream &operator<<( QDataStream &s, const DataElem &d)
{
    int size = d.getNumFields();

    s << size; /* redundent data but makes streaming easier */
    KeyList k = d.getKeys();

    KeyListIterator it(k);

    while(it.current()) {
        s << (Q_UINT16)it.currentKey();
        s << d.getField(it.currentKey());
        ++it;
    }
    return s;
}

QDataStream &operator>>( QDataStream &s, DataElem &d)
{
    int i;
    int size;
    TVVariant t;
    Q_UINT16 index = 0;

    s >> size; /* redundent data but makes streaming easier */
    if (size != d.getNumFields()) {
        owarn << "DataSize mis-match" << oendl;
        return s; /* sanity check failed.. don't load */
    }

    for(i = 0; i < size; i++) {
        s >> index;
        s >> t;
        d.setField(index, t);
    }
    return s;
}

int DataElem::getNumFields() const
{
    return contained->getNumFields();
}

KeyList DataElem::getKeys() const
{
    return *(contained->getKeys());
}

bool DataElem::hasValidValue(int i) const
{
    if(!values.find(i))
        return FALSE;
    if(!contained->getKeys()->validIndex(i))
        return FALSE;
    return values.find(i)->isValid();
}

bool DataElem::hasValidValue(QString qs) const
{
    int i = contained->getKeyIndex(qs);
    return hasValidValue(i);
}

TVVariant::KeyType DataElem::getFieldType(int i) const
{
    return contained->getKeyType(i);
}

TVVariant::KeyType DataElem::getFieldType(QString qs) const
{
    int i = contained->getKeyIndex(qs);
    return contained->getKeyType(i);
}

TVVariant DataElem::getField(int i) const
{
    if(hasValidValue(i))
        return TVVariant(*values.find(i));
    return TVVariant();
}

TVVariant DataElem::getField(QString qs) const
{
    int i = contained->getKeyIndex(qs);
    return getField(i);
}

void DataElem::setField(int i, QString q)
{
    /* from the type of the field, parse q and store */
    TVVariant::KeyType kt = contained->getKeyType(i);

    TVVariant t = TVVariant(q);

    switch(kt) {
        case TVVariant::Int: {
            t.asInt();
            setField(i, t);
      return;
        }
        case TVVariant::String: {
            t.asString();
            setField(i, t);
            return;
        }
        case TVVariant::Date: {
            t.asDate();
            setField(i, t);
            return;
        }
        case TVVariant::Time: {
            t.asTime();
            setField(i, t);
            return;
        }
        default:
            owarn << "DataElem::setField(" << i << ", " << q << ") No valid type found" << oendl;
    }
}

void DataElem::setField(int i, TVVariant value)
{
    if (value.isValid()) {
        values.remove(i);
        values.replace(i, new TVVariant(value));
    }
}

void DataElem::setField(QString qs, QString q)
{
    /* from the type of the field, parse q and store */
    int i = contained->getKeyIndex(qs);
    setField(i, qs);
}

void DataElem::setField(QString qs, TVVariant value)
{
    int i = contained->getKeyIndex(qs);
    setField(i, value);
}

void DataElem::unsetField(int i) {
    values.remove(i);
}

void DataElem::unsetField(QString qs)
{
    int i = contained->getKeyIndex(qs);
    unsetField(i);
}

QString DataElem::toQString() const
{
    /* lets make an attempt at this function */
    int i;
    QString scratch = "";

    QIntDictIterator<TVVariant> it(values);

    while (it.current()) {
      i = it.currentKey();
        if(hasValidValue(i)) {
            scratch += "<B>" + contained->getKeyName(i) + ":</B> ";
            scratch += getField(i).toString();
            scratch += "<br>";
        }
        ++it;
    }
    return scratch;
}

QString DataElem::toQString(int i) const
{
    if(hasValidValue(i)) {
        return getField(i).toString();
    }
    return "";
}
QString DataElem::toSortableQString(int i) const
{
    QString scratch = "";
    if(hasValidValue(i)) {
        switch (contained->getKeyType(i)) {
            case TVVariant::String: {
                scratch += getField(i).toString();
                break;
            }
            case TVVariant::Int: {
                scratch.sprintf("%08d", getField(i).toInt());
                break;
            }
            case TVVariant::Date: {
                static QDate epochD(1800, 1, 1);
                scratch.sprintf("%08d",
                                epochD.daysTo(getField(i).toDate()));
                break;
            }
            case TVVariant::Time: {
                static QTime epochT(0, 0, 0);
                scratch.sprintf("%08d",
                                epochT.msecsTo(getField(i).toTime()));
                break;
            }
            default:
                scratch += "Unknown type";
                break;
        }
    }
    return scratch;
}

/* compare functions */

bool DataElem::lessThan(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    return (getField(i) < v);
}

bool DataElem::moreThan(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    return (getField(i) > v);
}

bool DataElem::equalTo(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    return (getField(i) == v);
}

bool DataElem::contains(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            if (qs1.contains(qs2) > 0) return TRUE;
            break;
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            break;
        default:
            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
}

bool DataElem::startsWith(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            return qs1.startsWith(qs2);
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            return FALSE;
        default:
            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
}

bool DataElem::endsWith(int i, TVVariant v) const
{
    if (!hasValidValue(i)) return FALSE;

    if (getField(i).type() != v.type())
        return FALSE;

    switch(getField(i).type()) {
        case TVVariant::String: {
            QString qs1 = getField(i).toString().lower();
            QString qs2 = v.toString().lower();
            return qs1.startsWith(qs2);
        }
            /* meaningless for ints */
            /* meaningless for time */
            /* meaningless for dates */
        case TVVariant::Int:
        case TVVariant::Time:
        case TVVariant::Date:
            return FALSE;
        default:
            owarn << "Tried to compare unknown data type" << oendl;
    }
    return FALSE;
}

bool DataElem::closer(DataElem*d1, DataElem *d2, TVVariant target, int column)
{
    int type;

    if(!d1) return FALSE;

    if (!d1->hasValidValue(column)) return FALSE;

    if(!target.isValid()) return FALSE;

    type = d1->getField(column).type();

    if(d2) {
        if (type != d2->getField(column).type()) {
                /* can't do compare */
                owarn << "Tried to compare two incompatable types" << oendl;
                return FALSE;
        }
        return target.closer(d1->getField(column), d2->getField(column));
    }
    return target.close(d1->getField(column));
}

---