Dictionary.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 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

************************************************************************/
// Dictionary.cpp: implementation of the ObjectDictionary class.
//
//////////////////////////////////////////////////////////////////////

#include "Dictionary.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Dictionary::Dictionary()
{
        objectTable.type = "dictionary";
}

Dictionary::Dictionary(const JString& xml) : CollectionBase(xml) {
        objectTable.type = "dictionary";
}

Dictionary::Dictionary(XMLNode* node) : CollectionBase(node) {
        objectTable.type = "dictionary";
}


Dictionary::~Dictionary()
{

}

bool Dictionary::addAll(const CollectionBase* c) {
        return CollectionBase::copyAll(c);
}

bool Dictionary::addAll(const CollectionBase& c) {
        return CollectionBase::copyAll(c);
}

Dictionary::Dictionary(const Dictionary &c) {
        objectTable.copyAll(c.objectTable);
        objectTable.type = c.objectTable.type;
        objectTable.sorting = c.objectTable.sorting;
}

const Dictionary& Dictionary::operator = (const Dictionary& c) {
        objectTable.removeAll();
        objectTable.copyAll(c.objectTable);
        objectTable.type = c.objectTable.type;
        objectTable.sorting = c.objectTable.sorting;
        return *this;
}


bool Dictionary::contains(const JString& key) const {
        return objectTable.containsKey(&key);
}


JString Dictionary::get(const JString& key) const {
        JString* str = (JString*) objectTable.get(&key);
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::take(const JString& key) {
        JString* str = (JString*) objectTable.take(&key);
        if (str == NULL)
                return "";
        else
                return *str;
}

bool Dictionary::containsIgnoreCase(const JString& key) const {
        if (contains(key))
                return true;
        if (contains(key.toLowerCase()))
                return true;
        for (int n=0; n<getCount(); n++) {
                if (getKey(n).equalsIgnoreCase(key))
                        return true;
        }
        return false;
}

JString Dictionary::getIgnoreCase(const JString& key) const {
        if (contains(key))
                return get(key);
        if (contains(key.toLowerCase()))
                return get(key.toLowerCase());
        for (int n=0; n<getCount(); n++) {
                if (getKey(n).equalsIgnoreCase(key))
                        return get(n);
        }
        return "";
}

bool Dictionary::put(const JString& key, const JString& value) {
        if (key.length() == 0)
                return false;
        JString* keycopy = (JString*) key.clone();
        JString* valuecopy = (JString*) value.clone();
        if (!objectTable.add(keycopy, valuecopy)) {
                delete(keycopy);
                delete(valuecopy);
                return false;
        }
        else
                return true;
}

bool Dictionary::remove(const JString& key) {
        return objectTable.remove(&key);
}

bool Dictionary::remove(int pos) {
        return objectTable.remove(pos);
}

bool Dictionary::putFirst(const JString& key, const JString& value) {
        if (key.length() == 0)
                return false;
        JString* keycopy = (JString*) key.clone();
        JString* valuecopy = (JString*) value.clone();
        if (!objectTable.addFirst(keycopy, valuecopy)) {
                delete(keycopy);
                delete(valuecopy);
                return false;
        }
        else
                return true;
}

bool Dictionary::putLast(const JString& key, const JString& value) {
        if (key.length() == 0)
                return false;
        JString* keycopy = (JString*) key.clone();
        JString* valuecopy = (JString*) value.clone();
        if (!objectTable.addLast(keycopy, valuecopy)) {
                delete(keycopy);
                delete(valuecopy);
                return false;
        }
        else
                return true;
}

bool Dictionary::putAfter(int pos, const JString& key, const JString& value) {
        if (key.length() == 0)
                return false;
        JString* keycopy = (JString*) key.clone();
        JString* valuecopy = (JString*) value.clone();
        if (!objectTable.addAfter(pos, keycopy, valuecopy)) {
                delete(keycopy);
                delete(valuecopy);
                return false;
        }
        else
                return true;
}



Collection Dictionary::getAllKeys() {
        Collection col;
        if (objectTable.first == NULL)
                return col;

        CollectionEntry* item = objectTable.first;

        while (item != NULL) {
                if (item->key != NULL)
                        col.add(*(JString*)item->key);
                item = (CollectionEntry*) item->next;
        }               
        return col;
}

JString Dictionary::get(int pos) {
        JString* str = (JString*) objectTable.get(pos);
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::operator [](int pos) const {
        return get(pos);
}

JString Dictionary::operator [](const JString& key) const {
        return get(key);
}

JString Dictionary::get(int pos) const {
        JString* str = (JString*) objectTable.get(pos);
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::take(int pos) {
        JString* str = (JString*) objectTable.take(pos);
        if (str == NULL)
                return "";
        else
                return *str;
}


JString Dictionary::getFirst() {
        JString* str = (JString*) objectTable.getFirst();
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::getLast() {
        JString* str = (JString*) objectTable.getLast();
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::getNext() {
        JString* str = (JString*) objectTable.getNext();
        if (str == NULL)
                return "";
        else
                return *str;
}

JString Dictionary::getPrevious() {
        JString* str = (JString*) objectTable.getPrevious();
        if (str == NULL)
                return "";
        else
                return *str;
}

int Dictionary::getPos(const JString& value) const {
        return(objectTable.getPos(&value));
}

int Dictionary::getPosKey(const JString& key) const {
        return(objectTable.getPosKey(&key));
}

JString Dictionary::getKey(int pos) {
        Object* obj = objectTable.getKey(pos);
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

JString Dictionary::getKey(int pos) const {
        Object* obj = objectTable.getKey(pos);
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

JString Dictionary::getFirstKey() {
        Object* obj = objectTable.getFirstKey();
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

JString Dictionary::getLastKey() {
        Object* obj = objectTable.getLastKey();
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

JString Dictionary::getNextKey() {
        Object* obj = objectTable.getNextKey();
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

JString Dictionary::getPreviousKey() {
        Object* obj = objectTable.getPreviousKey();
        if (obj == NULL)
                return "";
        return *(JString*) obj;
}

bool Dictionary::removeNoDelete(int pos) {
        return objectTable.remove(pos);
}

bool Dictionary::removeAllNoDelete() {
        return objectTable.removeAll();
}

void Dictionary::noDelete() {
        objectTable.doDelete();
}

void Dictionary::doDelete() {
        objectTable.doDelete();
}








bool Dictionary::unitTest() {

        // First of all, test that class typeid is enabled:
        JString test1 = "test";
        JString test2 = "test";
        if (!test1.isSameClass(&test2)) {
                this->addUnitTestLog("System typeid is not working/enabled!");
                return false;
        }

        Dictionary* t = new Dictionary();
        t->put("test1", "bla1");
        t->put("test2", "bla2");
        t->put("test3", "bla3");
        t->put("test4", "bla4");

        if (!t->get("test1").equals("bla1"))
                return false;
        if (!t->get("test2").equals("bla2"))
                return false;
        if (!t->get("test3").equals("bla3"))
                return false;
        if (!t->get("test4").equals("bla4"))
                return false;

        t->put("test4", "bla5");

        if (!t->get("test4").equals("bla5"))
                return false;

        delete(t);
        return true;
}




} // namespace cmlabs

---