ObjectDictionary.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

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

#include "ObjectDictionary.h"
#include "TCPLocation.h"

namespace cmlabs {

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

ObjectDictionary::ObjectDictionary()
{
        objectTable.type = "objectdictionary";
}

ObjectDictionary::~ObjectDictionary()
{

}

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

ObjectDictionary::ObjectDictionary(XMLNode* node) : CollectionBase(node) {
        objectTable.type = "objectdictionary";
}


ObjectDictionary::ObjectDictionary(const ObjectDictionary &c) {
        objectTable.addAll(c.objectTable);
        objectTable.deleteOnDestroy = c.objectTable.deleteOnDestroy;
        objectTable.type = c.objectTable.type;
        objectTable.sorting = c.objectTable.sorting;
}

const ObjectDictionary& ObjectDictionary::operator = (const ObjectDictionary& c) {
        objectTable.removeAll();
        objectTable.addAll(c.objectTable);
        objectTable.deleteOnDestroy = c.objectTable.deleteOnDestroy;
        objectTable.type = c.objectTable.type;
        objectTable.sorting = c.objectTable.sorting;
        return *this;
}



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

int ObjectDictionary::getPos(Object* value) const {
        return(objectTable.getPos(value));
}

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

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

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

Collection ObjectDictionary::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;
}

Object* ObjectDictionary::get(int pos) {
        return objectTable.get(pos);
}

Object* ObjectDictionary::operator [](int pos) const {
        return get(pos);
}

Object* ObjectDictionary::operator [](const JString& key) const {
        return get(key);
}

Object* ObjectDictionary::get(int pos) const {
        return objectTable.get(pos);
}

Object* ObjectDictionary::get(const JString& key) const {
        return objectTable.get(&key);
}

Object* ObjectDictionary::take(int pos) {
        return objectTable.take(pos);
}

Object* ObjectDictionary::take(const JString& key) {
        return objectTable.take(&key);
}

bool ObjectDictionary::containsIgnoreCase(const JString& key) const {
        Object* obj = get(key);
        if (obj == NULL)
                obj = get(key.toLowerCase());
        if (obj == NULL) {
                for (int n=0; n<getCount(); n++) {
                        if (getKey(n).equalsIgnoreCase(key))
                                return true;
                }
        }
        return (obj != NULL);
}

Object* ObjectDictionary::getIgnoreCase(const JString& key) const {
        Object* obj = get(key);
        if (obj == NULL)
                obj = get(key.toLowerCase());
        if (obj == NULL) {
                for (int n=0; n<getCount(); n++) {
                        if (getKey(n).equalsIgnoreCase(key))
                                return get(n);
                }
        }
        return obj;
}

bool ObjectDictionary::put(const JString& key, Object* obj) {
        JString* keycopy = (JString*) key.clone();
        if (!objectTable.add(keycopy, obj)) {
                delete(keycopy);
                return false;
        }
        else
                return true;
}

bool ObjectDictionary::putFirst(const JString& key, Object* obj) {
        if (contains(key))
                return false;
        JString* keycopy = (JString*) key.clone();
        if (!objectTable.addFirst(keycopy, obj)) {
                delete(keycopy);
                return false;
        }
        else
                return true;
}

bool ObjectDictionary::putLast(const JString& key, Object* obj) {
        if (contains(key))
                return false;
        JString* keycopy = (JString*) key.clone();
        if (!objectTable.addLast(keycopy, obj)) {
                delete(keycopy);
                return false;
        }
        else
                return true;
}

bool ObjectDictionary::putAfter(int pos, const JString& key, Object* obj) {
        if (contains(key))
                return false;
        JString* keycopy = (JString*) key.clone();
        if (!objectTable.addAfter(pos, keycopy, obj)) {
                delete(keycopy);
                return false;
        }
        else
                return true;
}

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

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

bool ObjectDictionary::removeNoDelete(const JString& key) {
        return objectTable.removeNoDelete(&key);
}

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

Object* ObjectDictionary::getFirst() {
        return objectTable.getFirst();
}

Object* ObjectDictionary::getLast() {
        return objectTable.getLast();
}

Object* ObjectDictionary::getNext() {
        return objectTable.getNext();
}

Object* ObjectDictionary::getPrevious() {
        return objectTable.getPrevious();
}

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

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

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

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


















bool ObjectDictionary::unitTest() {

        ObjectDictionary* t = new ObjectDictionary();

        TCPLocation* loc = new TCPLocation("addr1", 1001, "1111");
        t->put("test1", loc);
        loc = new TCPLocation("addr2", 1002, "2222");
        t->put("test2", loc);
        loc = new TCPLocation("addr3", 1003, "3333");
        t->put("test3", loc);
        loc = new TCPLocation("addr4", 1004, "4444");
        t->put("test4", loc);

        loc = (TCPLocation*) t->get("test1");
        if (!loc->addr.equals("addr1"))
                return false;
        loc = (TCPLocation*) t->get("test2");
        if (!loc->addr.equals("addr2"))
                return false;
        loc = (TCPLocation*) t->get("test3");
        if (!loc->addr.equals("addr3"))
                return false;
        loc = (TCPLocation*) t->get("test4");
        if (!loc->addr.equals("addr4"))
                return false;

        t->doDelete();
        delete(t);
        return true;
}



} // namespace cmlabs

---