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

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

#include "Collection.h"

namespace cmlabs {

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

Collection::Collection()
{
        objectTable.type = "collection";
}

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

Collection::Collection(XMLNode *node) : CollectionBase(node) {
        objectTable.type = "collection";
}


Collection::~Collection()
{

}

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

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

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

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


bool Collection::contains(const JString& value) const {
        return (objectTable.contains(&value));
}

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


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

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

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

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

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

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

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

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

bool Collection::add(const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.add(NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

bool Collection::addFirst(const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.addFirst(NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

bool Collection::addLast(const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.addLast(NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

bool Collection::addAfter(int pos, const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.addAfter(pos, NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

bool Collection::addBefore(int pos, const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.addBefore(pos, NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

bool Collection::replace(int pos, const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.replace(pos, NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

int Collection::replace(const JString& oldvalue, const JString& value) {
        JString* str = new JString(value);
        if (!objectTable.replace(&oldvalue, NULL, str)) {
                delete(str);
                return false;
        }
        else
                return true;
}

int Collection::removeEntries(const JString& value) {
        return objectTable.remove(&value, true);
}

bool Collection::remove(const JString& value) {
        return (objectTable.remove(&value, false) > 0);
}

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

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

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

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

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



bool Collection::unitTest() {

        Collection* oc = new Collection();

        oc->add("Test1");
        oc->add("Test2");
        oc->add("Test3");
        oc->add("Test4");
        oc->add("Test5");
        oc->add("Test6");

        if (!oc->getFirst().equals("Test1"))
                return false;
        if (!oc->getNext().equals("Test2"))
                return false;
        if (!oc->getNext().equals("Test3"))
                return false;
        if (!oc->getNext().equals("Test4"))
                return false;
        if (!oc->getNext().equals("Test5"))
                return false;
        if (!oc->getNext().equals("Test6"))
                return false;

        Collection oc2;

        oc2 = *oc;

        if (!oc2.getFirst().equals("Test1"))
                return false;
        if (!oc2.getNext().equals("Test2"))
                return false;
        if (!oc2.getNext().equals("Test3"))
                return false;
        if (!oc2.getNext().equals("Test4"))
                return false;
        if (!oc2.getNext().equals("Test5"))
                return false;
        if (!oc2.getNext().equals("Test6"))
                return false;

        oc->removeAll();

        if (oc->getCount() != 0)
                return false;
        
        JString str = "1=2=3=4=5";

        Collection oc3, oc4;

        oc3 = str.split("=");
        oc4 = str.split("=");

        if (oc3 != oc4)
                return false;
        
        if (!(oc3 == oc4))
                return false;

        if (oc3.getCount() != 5)
                return false;

        if (!oc3.getFirst().equals("1"))
                return false;
        if (!oc3.getNext().equals("2"))
                return false;
        if (!oc3.getNext().equals("3"))
                return false;
        if (!oc3.getNext().equals("4"))
                return false;
        if (!oc3.getNext().equals("5"))
                return false;


        JString s1 = "Hello World";
        JString s2 = "Hello World";
        JString s3 = "Hello world";

        if (s1 != s2)
                return false;

        if (!(s1 == s2))
                return false;

        if (s1 == s3)
                return false;

        if (!(s1 != s3))
                return false;

//              cout << "\n******* Lookup *********" << endl << flush;
//              cout << oc->print() << flush;
//              cout << "************************" << endl << flush;

//      }
//      catch(...) {
//              printf("\nOups, caught exception in Collection\n");
//              return false;
//      }

        delete(oc);
        return true;
}




} // namespace cmlabs

---