datacache.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.
**
**********************************************************************/
/*
 * This file is used to load the xml files that represent the database.
 * The main requirment for said file is each data entry must contain a key,
 * otherwise any other data headings are allowed.
 */

#include "datacache.h"
#include "xmlsource.h"
#include "csvsource.h"

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

/* QT */
#include <qheader.h>

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

#define INIT_TABLE_SIZE 128

DBStore::DBStore()
{
    name = "";
    number_elems = 0;
    full = false;
    kRep = new KeyList();
    master_table.resize(INIT_TABLE_SIZE);
    table_size = INIT_TABLE_SIZE;

    current_elem = 0;
    archive = 0;
}

//TODO
void DBStore::freeTable()
{
    name = "";
    if(archive) {
        delete archive;
        archive = 0;
    }
    kRep->clear(); /* clear the current key list */

    number_elems = 0;
    table_size = INIT_TABLE_SIZE;
    master_table.resize(table_size);
    full = false;
    current_elem = 0;
}

DBStore::~DBStore()
{
    freeTable();
}

bool DBStore::openSource(QIODevice *inDev, const QString &source) {

    /* first check if db is already open, if contains data.. then clear */
    if(number_elems > 0) {
        freeTable();
    }

    if (source == "text/x-xml-tableviewer") {
        archive = new DBXml(this);
    } else if (source == "text/csv") {
    archive = new DBCsv(this);
    } else
        return false;

    return (archive->openSource(inDev));
}

bool DBStore::saveSource(QIODevice *outDev, const QString &source)
{
    /* saving a new file */
    if(!archive) {
        if (source == "text/x-xml-tableviewer") {
            archive = new DBXml(this);
    } else if (source == "text/x-xml-tableviewer") {
            archive = new DBCsv(this);
        } else
        return false;
    }

    /* changing file type */
    if(archive->type() != source) {
        delete archive;
        if (source == "text/x-xml-tableviewer") {
            archive = new DBXml(this);
    } else if (source == "text/x-xml-tableviewer") {
            archive = new DBCsv(this);
        } else
        return false;
    }

    return (archive->saveSource(outDev));
}

void DBStore::addItem(DataElem *delem)
{
    addItemInternal(delem);
}

void DBStore::addItemInternal(DataElem *delem)
{
    /* if already full, don't over fill, do a owarn though */
    if (full) {
        owarn << "Attempted to add items to already full table" << oendl;
        return;
    }

    master_table.insert(number_elems, delem);

    current_elem = number_elems;
    number_elems++;

    if(number_elems >= table_size) {
        /* filled current table, double if we can */
        table_size = table_size << 1;

        /* check that the new table size is still valid, i.e. that we didn't
           just shift the 1 bit of the end of the int. */
        if (!table_size) {
            full = true;
            /* no point in doing antying else. */
            return;
        }
        master_table.resize(table_size);
    }
}

void DBStore::removeItem(DataElem *r)
{
    int position = master_table.findRef(r);
    if(position != -1) {
        /* there is at least one item, this is it */
        /* replace this with the last element, decrease the element count */
        master_table.insert(position, master_table.at(--number_elems));
        master_table.remove(number_elems);
        delete r;
    }
}

void DBStore::setName(const QString &n)
{
    name = n;
}

QString DBStore::getName()
{
    return name;
}

KeyList *DBStore::getKeys()
{
    return kRep;
}

void DBStore::setKeys(KeyList *k)
{
    kRep = k;
}

void DBStore::first()
{
    current_elem = 0;
}

void DBStore::last()
{
    current_elem = number_elems - 1;
}

bool DBStore::next()
{
    unsigned int new_current_elem = current_elem + 1;
    if (current_elem < number_elems)
        /* was valid before inc (it is possible but unlikely that inc current
           elem will change it from invalid to valid) */
        if (new_current_elem < number_elems) {
            /* is valid after inc */
            current_elem = new_current_elem;
            return true;
        }
    return false;
}

bool DBStore::previous()
{
    unsigned int new_current_elem = current_elem -1;
    if (current_elem < number_elems)
        /* was valid */
        if (new_current_elem < number_elems) {
            /* still is (if was 0, then now -1, but as is unsigned will wrap
               and hence be invalid */
            current_elem = new_current_elem;
            return true;
        }
    return false;
}

DataElem *DBStore::getCurrentData()
{
    if (current_elem >= number_elems)
        return NULL;
    return master_table[current_elem];
}

---