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

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

#include "ObjectTable.h"
#include "Collections.h"
#include "XMLParser.h"
#include "JSemaphore.h"


namespace cmlabs {

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

ObjectTable::ObjectTable()
{
        hashTable = create_hashtable(1);
        accessMutex = new JMutex();
        sorting = SORTNONE;
        count = 0;
        currentPos = -1;
        current = NULL;
        first = NULL;
        last = NULL;
        deleteOnDestroy = true;
        type = "ObjectTable";
}

ObjectTable::ObjectTable(const ObjectTable &Coll) {
        hashTable = create_hashtable(1);
        accessMutex = new JMutex();
        sorting = SORTNONE;
        count = 0;
        currentPos = -1;
        current = NULL;
        first = NULL;
        last = NULL;
        type = Coll.type;
        addAll(Coll.first);
        deleteOnDestroy = Coll.deleteOnDestroy;
}

ObjectTable::ObjectTable(const JString& xml) {
        hashTable = create_hashtable(1);
        accessMutex = new JMutex();
        sorting = SORTNONE;
        count = 0;
        currentPos = -1;
        current = NULL;
        first = NULL;
        last = NULL;
        deleteOnDestroy = true;
        type = "ObjectTable";

        if (xml.length() == 0)
                return;

        fromXML(xml);
}

ObjectTable::ObjectTable(XMLNode* node) {
        hashTable = create_hashtable(1);
        accessMutex = new JMutex();
        sorting = SORTNONE;
        count = 0;
        currentPos = -1;
        current = NULL;
        first = NULL;
        last = NULL;
        deleteOnDestroy = true;
        type = "ObjectTable";

        fromXML(node);
}


ObjectTable::~ObjectTable()
{
        removeAll();
        hashtable_destroy(hashTable);
        delete(accessMutex);
}

bool ObjectTable::isCollection() {
        return true;
}

const ObjectTable& ObjectTable::operator = (const ObjectTable& c) {
        removeAll();
        type = c.type;
        addAll(c.first);
        deleteOnDestroy = c.deleteOnDestroy;
        return *this;
}


bool ObjectTable::equals(const Object* o2) const {
        if (o2 == NULL) return false;
        if (!this->isSameClass(o2)) {
                return false;
        }

        ObjectTable* t = (ObjectTable*) o2;
        if (!this->type.equalsIgnoreCase(t->type))
                return false;

        if (this->getCount() != t->getCount())
                return false;

        CollectionEntry* item1;
        CollectionEntry* item2;

        if (accessMutex->EnterMutex(5000)) {
                for (int n=0; n<getCount(); n++) {
                        item1 = getEntry(n);
                        item2 = t->getEntry(n);
                        if ((item1->key == NULL) || (item2->key == NULL)) {
                                if (item1->key != item2->key) {
                                        accessMutex->LeaveMutex();
                                        return false;
                                }
                        }
                        else if (!item1->key->equals(item2->key)) {
                                accessMutex->LeaveMutex();
                                return false;
                        }
                        if (!item1->value->equals(item2->value)) {
                                accessMutex->LeaveMutex();
                                return false;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 1 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}

bool ObjectTable::operator ==(ObjectTable& c) {
        return this->equals(&c);
}

bool ObjectTable::operator !=(ObjectTable& c) {
        return (!(*this == c));
}

Object* ObjectTable::clone() const {
        ObjectTable* coll = new ObjectTable();
//      if (accessMutex->EnterMutex(5000)) {
                coll->copyAll(this);
                coll->type = type;
//              accessMutex->LeaveMutex();
//      }
//      else {
//              printf("******* Access Denied 2 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
//      }
        return (Object*) coll;
}

bool ObjectTable::removeAll() {
        if (first == NULL) {
                count = 0;
                currentPos = -1;
                current = NULL;
                last = NULL;
                return true;
        }
        
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* item = first;
                while (first != NULL) {
                        if (deleteOnDestroy) {
                                delete(first->value);
                                first->value = NULL;
                        }
                        item = (CollectionEntry*) first->next;
                        delete(first->key);
                        delete(first);
                        first = item;
                }
                count = 0;
                current = NULL;
                last = NULL;
                currentPos = -1;
                hashtable_destroy(hashTable);
                hashTable = create_hashtable(1);
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 3 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return true;
}


void ObjectTable::noDelete() {
        deleteOnDestroy = false;
}

void ObjectTable::doDelete() {
        deleteOnDestroy = true;
}

bool ObjectTable::removeAllNoDelete() {
        bool prevVal = deleteOnDestroy;
        deleteOnDestroy = false;
        bool res = removeAll();
        deleteOnDestroy = prevVal;
        return res;
}

bool ObjectTable::removeNoDelete(int pos) {
        bool prevVal = deleteOnDestroy;
        deleteOnDestroy = false;
        bool res = remove(pos);
        deleteOnDestroy = prevVal;
        return res;
}

bool ObjectTable::removeNoDelete(const Object* key) {
        bool prevVal = deleteOnDestroy;
        deleteOnDestroy = false;
        bool res = remove(key);
        deleteOnDestroy = prevVal;
        return res;
}

int ObjectTable::removeNoDelete(const Object* value, bool removeAll) {
        bool prevVal = deleteOnDestroy;
        deleteOnDestroy = false;
        int res = remove(value, removeAll);
        deleteOnDestroy = prevVal;
        return res;
}



int ObjectTable::getCount() const {
        return count;
}

bool ObjectTable::containsKey(const Object* key) const {
        return (this->getEntryKey(key) != NULL);
}

bool ObjectTable::contains(const Object* value) const {
        return (this->getPos(value) >= 0);
}

ObjectCollection* ObjectTable::getAllKeysCopy() {
        ObjectCollection* coll = new ObjectCollection();
        CollectionEntry* item = first;
        while (item != NULL) {
                if (item->key != NULL)
                        coll->add(item->key->clone());
                item = (CollectionEntry*) item->next;
        }               
        return coll;
}


//int ObjectTable::length() {
//      return count;
//}

int ObjectTable::getPos(const Object* obj) const {

        if (first == NULL)
                return -1;

        int n = 0;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = hashtable_search_value(hashTable, obj);
                if (entry == NULL) {
                        accessMutex->LeaveMutex();
                        return -1;
                }

                n = getEntryPos(entry);
                accessMutex->LeaveMutex();
                return n;

                //CollectionEntry* item = first;
                //while (item != NULL) {
                //      if (item == founditem) {
                //              accessMutex->LeaveMutex();
                //              return n;
                //      }
                //      item = (CollectionEntry*) item->next;
                //      n++;
                //}             
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 4 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return -1;
}

int ObjectTable::getPosKey(const Object* key) const {

        if (first == NULL)
                return -1;

        int n = 0;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = hashtable_search_key(hashTable, key);
                if (entry == NULL) {
                        accessMutex->LeaveMutex();
                        return -1;
                }

                n = getEntryPos(entry);
                accessMutex->LeaveMutex();
                return n;

                //CollectionEntry* item = first;
                //while (item != NULL) {
                //      if (item == founditem) {
                //              accessMutex->LeaveMutex();
                //              return n;
                //      }
                //      item = (CollectionEntry*) item->next;
                //      n++;
                //}             
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 4 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return -1;
}










// ******************************************************
// Adding...
// ******************************************************


// Raw Add

bool ObjectTable::add(Object* key, Object* value) {

        // Check to see if an entry with this key already exist
        if (key != NULL) {
                CollectionEntry* entry = getEntryKey(key);
                if (entry != NULL) {
                        // If exist, overwrite entry
                        return replaceEntry(entry, key, value);
                }
        }
        
        if ((this->count > 0) && (this->sorting != 0))
                return (addAndReturnPosition(key, value) >= 0);

        // If not, add to the end
        return addLast(key, value);
}

// First/Last Add

bool ObjectTable::addLast(Object* key, Object* value) {
        if (count == 0)
                return addBetweenEntries(NULL, NULL, key, value);
        return addAfterEntry(last, key, value);
}

bool ObjectTable::addFirst(Object* key, Object* value) {
        if (count == 0)
                return addBetweenEntries(NULL, NULL, key, value);
        return addBeforeEntry(first, key, value);
}

// Name based Add

bool ObjectTable::addAfter(const Object* obj, Object* key, Object* value) {
        return addAfterEntry(getEntryKey(obj), key, value);
}


bool ObjectTable::addBefore(const Object* obj, Object* key, Object* value) {
        return addBeforeEntry(getEntryKey(obj), key, value);
}

// Positional Add

bool ObjectTable::addBefore(int pos, Object* key, Object* value) {
        if (pos == 0)
                return addFirst(key, value);
        if (count == 0)
                return addBetweenEntries(NULL, NULL, key, value);
        CollectionEntry* nextItem = getEntry(pos);
        if (nextItem == NULL) return false;
        return addBetweenEntries((CollectionEntry*) nextItem->prev, nextItem, key, value);
}

bool ObjectTable::addAfter(int pos, Object* key, Object* value) {
        if (count == 0)
                return addFirst(key, value);
        if (pos >= getCount())
                return addLast(key, value);
        CollectionEntry* prevItem = getEntry(pos);
        if (prevItem == NULL) return false;
        return addBetweenEntries(prevItem, (CollectionEntry*) prevItem->next, key, value);
}








// Entry based Add

bool ObjectTable::addBeforeEntry(CollectionEntry* entry, Object* key, Object* value) {
        if (entry == NULL) return false;
        return addBetweenEntries((CollectionEntry*) entry->prev, entry, key, value);
}

bool ObjectTable::addAfterEntry(CollectionEntry* entry, Object* key, Object* value) {
        if (entry == NULL) return false;
        return addBetweenEntries(entry, (CollectionEntry*) entry->next, key, value);
}

// Actual Add

bool ObjectTable::addBetweenEntries(CollectionEntry* prevItem, CollectionEntry* nextItem, Object* key, Object* value) {
        if (value == NULL)
                return false;

        if (accessMutex->EnterMutex(5000)) {
                currentPos = -1;
                current = NULL;

                CollectionEntry* item = new CollectionEntry(key, value);

                item->prev = prevItem;
                item->next = nextItem;

                if (prevItem != NULL)
                        prevItem->next = item;
                else
                        first = item;

                if (nextItem != NULL)
                        nextItem->prev = item;
                else
                        last = item;

                if (item->key != NULL)
                        hashtable_insert_key(hashTable, item);
                hashtable_insert_value(hashTable, item);
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 5 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        count++;
        return true;
}

// ******************************************************
// Replacing...
// ******************************************************


bool ObjectTable::replace(const Object* obj, Object* key, Object* value) {
        return replaceEntry(getEntryKey(obj), key, value);
}

bool ObjectTable::replace(int pos, Object* key, Object* value) {
        return replaceEntry(getEntry(pos), key, value);
}

// Actual Replace

bool ObjectTable::replaceEntry(CollectionEntry* entry, Object* key, Object* value) {
        if ((entry == NULL) || (value == NULL))
                return false;

        if (accessMutex->EnterMutex(5000)) {
                if (this->deleteOnDestroy) {
                //      if (entry->value != NULL) {
                                delete(entry->value);
                //      }
                }
                //if (entry->key != NULL) {
                        delete(entry->key);
                //}

                entry->key = key;
                entry->value = value;
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 6 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return true;
}





// ******************************************************
// Removing...
// ******************************************************


bool ObjectTable::removeFirst() {
//      return removeEntry(getFirstEntry());
        if (accessMutex->EnterMutex(5000)) {
                if (first == NULL) {
                        accessMutex->LeaveMutex();
                        return true;
                }
                CollectionEntry* second = first->next;
                if (second != NULL) {
                        second->prev = NULL;
                }

                hashtable_remove_key(hashTable, first);
                hashtable_remove_value(hashTable, first);

                if (this->deleteOnDestroy) {
                        delete(first->value);
                }
                first->value = NULL;
                delete(first->key);
                if (first == last)
                        last = NULL;
                delete(first);
                first = second;
                count--;
                current = NULL;
                currentPos = -1;
                accessMutex->LeaveMutex();
                return true;
        }
        else {
                printf("******* Access Denied 100 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return false;
}

bool ObjectTable::removeLast() {
//      return removeEntry(getLastEntry());
        if (accessMutex->EnterMutex(5000)) {
                if (last == NULL) {
                        accessMutex->LeaveMutex();
                        return true;
                }
                CollectionEntry* second = last->prev;
                if (second != NULL) {
                        second->next = NULL;
                }

                hashtable_remove_key(hashTable, first);
                hashtable_remove_value(hashTable, first);

                if (this->deleteOnDestroy) {
                        delete(last->value);
                }
                last->value = NULL;
                delete(last->key);
                if (first == last)
                        first = NULL;
                delete(last);
                last = second;
                count--;
                current = NULL;
                currentPos = -1;
                accessMutex->LeaveMutex();
                return true;
        }
        else {
                printf("******* Access Denied 101 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return false;
}

int ObjectTable::remove(const Object* value, bool removeAllMatches) {

        int c = 0;
        if (accessMutex->EnterMutex(5000)) {

                ObjectCollection* coll = hashtable_search_values(hashTable, value);
                if (coll == NULL) {
                        accessMutex->LeaveMutex();
                        return 0;
                }
                for (CollectionEntry* entry = (CollectionEntry*)coll->getFirst(); entry != NULL; entry = (CollectionEntry*)coll->getNext()) {
                        removeEntry(entry);
                        c++;
                        if (!removeAllMatches) {
                                accessMutex->LeaveMutex();
                                delete(coll);
                                return 1;
                        }
                }
                accessMutex->LeaveMutex();
                delete(coll);

                //while ((first != NULL) && (first->value->equals(value))) {
                //      removeEntry(first);
                //      // removeFirst();
                //      c++;
                //      if (!removeAllMatches) {
                //              accessMutex->LeaveMutex();
                //              return 1;
                //      }
                //}

                //if (first == NULL) {
                //      accessMutex->LeaveMutex();
                //      return c;
                //}

                //CollectionEntry* item = first->next;

                //while (item != NULL) {
                //      if (item->value->equals(value)) {
                //              item = item->prev;
                //              removeEntry(item->next);
                //              c++;
                //              if (!removeAllMatches) {
                //                      accessMutex->LeaveMutex();
                //                      return 1;
                //              }
                //      }
                //      item = (CollectionEntry*) item->next;
                //}
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 7 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return c;
}

bool ObjectTable::remove(const Object* key) {
        return removeEntry(getEntryKey(key));
}

bool ObjectTable::remove(int pos) {
        return removeEntry(getEntry(pos));
}

// Actual Remove

bool ObjectTable::removeEntry(CollectionEntry* entry) {
        if (entry == NULL)
                return false;
        
        if (accessMutex->EnterMutex(5000)) {
                currentPos = -1;
                current = NULL;

                hashtable_remove_key(hashTable, entry);
                hashtable_remove_value(hashTable, entry);

                CollectionEntry* prevItem = (CollectionEntry*) entry->prev;
                CollectionEntry* nextItem = (CollectionEntry*) entry->next;

                if (prevItem != NULL)
                        prevItem->next = nextItem;
                else
                        first = nextItem;
                
                if (nextItem != NULL)
                        nextItem->prev = prevItem;
                else
                        last = prevItem;

                if (this->deleteOnDestroy) {
                        delete(entry->value);
                }
                entry->value = NULL;
                delete(entry->key);
                delete(entry);

                count--;
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 8 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}








// ******************************************************
// Getting...
// ******************************************************


Object* ObjectTable::get(const Object* key) const {
        CollectionEntry* entry = getEntryKey(key);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::get(int pos) const {
        CollectionEntry* entry = getEntry(pos);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::get(int pos) {
        CollectionEntry* entry = getEntry(pos);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::take(const Object* key) {
        CollectionEntry* entry = getEntryKey(key);
        if (entry != NULL) {
                this->removeNoDelete(entry);
                return entry->value;
        }
        else
                return NULL;
}

Object* ObjectTable::take(int pos) {
        CollectionEntry* entry = getEntry(pos);
        if (entry != NULL) {
                this->removeNoDelete(entry);
                return entry->value;
        }
        else
                return NULL;
}

Object* ObjectTable::getNext() {
        CollectionEntry* entry = getNextEntry();
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getPrevious() {
        CollectionEntry* entry = getPreviousEntry();
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getFirst() {
        CollectionEntry* entry = getFirstEntry();
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getLast() {
        CollectionEntry* entry = getLastEntry();
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}


CollectionEntry* ObjectTable::getEntryKey(const Object* key) const {
        if ((first == NULL) || (key == NULL))
                return NULL;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* item = hashtable_search_key(hashTable, key);
                accessMutex->LeaveMutex();
                return item;
                //CollectionEntry* item = first;

                //while (item != NULL) {
                //      if (item->key->equals(key)) {
                //              accessMutex->LeaveMutex();
                //              return item;
                //      }
                //      item = (CollectionEntry*) item->next;
                //}
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 9 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        
        return NULL;
}

CollectionEntry* ObjectTable::getEntryValue(const Object* value) const {
        if ((first == NULL) || (value == NULL))
                return NULL;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* item = hashtable_search_value(hashTable, value);
                accessMutex->LeaveMutex();
                return item;
                //CollectionEntry* item = first;

                //while (item != NULL) {
                //      if (item->key->equals(key)) {
                //              accessMutex->LeaveMutex();
                //              return item;
                //      }
                //      item = (CollectionEntry*) item->next;
                //}
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 9 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        
        return NULL;
}

CollectionEntry* ObjectTable::getEntry(int pos) const {
        if ((pos < 0) || (pos >= count)) return NULL;
        if (first == NULL) return NULL;
        if (pos >= count) return NULL;

        int end = count-1;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                int n;
                int distEnd = end-pos;
                int distCur = currentPos-pos;
                // Here we need the smart algoritm to find
                // the minimum distance from 0, last or current;
                if ( (pos < distEnd) && (pos < abs(distCur)) ) {
                        // search from start, works if pos=0
                        for (n=0; n<pos; n++)
                                entry = entry->next;
                }
                else if (distEnd < abs(distCur)) {
                        // search from end, works if pos=end
                        entry = last;
                        for (n=0; n<distEnd; n++)
                                entry = entry->prev;
                }
                else {
                        if (distCur >= 0) {
                                // search down from currentPos, works if pos = currentPos
                                entry = current;
                                for (n=0; n<distCur; n++)
                                        entry = entry->prev;
                        }
                        else {
                                // search up from currentPos
                                entry = current;
                                distCur = 0-distCur;
                                for (n=0; n<distCur; n++)
                                        entry = entry->next;
                        }
                }
                accessMutex->LeaveMutex();
                return entry;


                //CollectionEntry* item = first;

                //int n = 0;
                //while (item != NULL) {
                //      if (n == pos) {
                //              accessMutex->LeaveMutex();
                //              return item;
                //      }
                //      item = (CollectionEntry*) item->next;
                //      n++;
                //}             
                //accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 10 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return NULL;
}

CollectionEntry* ObjectTable::getEntry(int pos) {

        if (accessMutex->EnterMutex(5000)) {
                const ObjectTable* table = this;
                CollectionEntry* entry = table->getEntry(pos);
                if (entry == NULL) {
                        accessMutex->LeaveMutex();
                        return NULL;
                }
                currentPos = pos;
                current = entry;
                accessMutex->LeaveMutex();
                return entry;
        }
        else
                printf("******* Access Denied 11 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        return NULL;


        //if (first == NULL) return NULL;
        //if (pos >= count) return NULL;

        //int end = count-1;
        //if (accessMutex->EnterMutex(5000)) {
        //      //if (pos == 0) {
        //      //      currentPos = 0;
        //      //      current = first;
        //      //      accessMutex->LeaveMutex();
        //      //      return current;
        //      //}
        //      //else if (pos == end) {
        //      //      currentPos = end;
        //      //      current = last;
        //      //      accessMutex->LeaveMutex();
        //      //      return current;
        //      //}
        //      //else if ((current != NULL) && (currentPos >= 0)) {
        //      //      if (pos == currentPos) {
        //      //              accessMutex->LeaveMutex();
        //      //              return current;
        //      //      }
        //      //      if ((currentPos > 0) && (pos == currentPos-1) && (current->prev != NULL)) {
        //      //              currentPos--;
        //      //              current = (CollectionEntry*) current->prev;
        //      //              accessMutex->LeaveMutex();
        //      //              return current;
        //      //      }
        //      //      else if ((currentPos < end) && (pos == currentPos+1) && (current->next != NULL)) {
        //      //              currentPos++;
        //      //              current = (CollectionEntry*) current->next;
        //      //              accessMutex->LeaveMutex();
        //      //              return current;
        //      //      }
        //      //}

        //      CollectionEntry* entry = first;
        //      int n;
        //      int distEnd = end-pos;
        //      int distCur = currentPos-pos;
        //      // Here we need the smart algoritm to find
        //      // the minimum distance from 0, last or current;
        //      if ( (pos < distEnd) && (pos < abs(distCur)) ) {
        //              // search from start, works if pos=0
        //              for (n=0; n<pos; n++)
        //                      entry = entry->next;
        //              currentPos = pos;
        //              current = entry;
        //      }
        //      else if (distEnd < abs(distCur)) {
        //              // search from end, works if pos=end
        //              entry = last;
        //              for (n=0; n<distEnd; n++)
        //                      entry = entry->prev;
        //              currentPos = pos;
        //              current = entry;
        //      }
        //      else {
        //              if (distCur >= 0) {
        //                      // search down from currentPos, works if pos = currentPos
        //                      entry = current;
        //                      for (n=0; n<distCur; n++)
        //                              entry = entry->prev;
        //                      currentPos = pos;
        //                      current = entry;
        //              }
        //              else {
        //                      // search up from currentPos
        //                      entry = current;
        //                      distCur = 0-distCur;
        //                      for (n=0; n<distCur; n++)
        //                              entry = entry->prev;
        //                      currentPos = pos;
        //                      current = entry;
        //              }
        //      }
        //      accessMutex->LeaveMutex();
        //      return current;

        //      //CollectionEntry* item = first;
        //      //int n = 0;

        //      //while (item != NULL) {
        //      //      if (n == pos) {
        //      //              currentPos = n;
        //      //              current = item;
        //      //              accessMutex->LeaveMutex();
        //      //              return current;
        //      //      }
        //      //      item = (CollectionEntry*) item->next;
        //      //      n++;
        //      //}             
        //      //accessMutex->LeaveMutex();
        //}
        //else {
        //      printf("******* Access Denied 11 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //}

        //return NULL;
}




CollectionEntry* ObjectTable::getNextEntry() {

        if (accessMutex->EnterMutex(5000)) {
                if ( (current != NULL) && (current->next != NULL) ) {
                        currentPos++;
                        current = (CollectionEntry*) current->next;
                        accessMutex->LeaveMutex();
                        return current;
                }
                accessMutex->LeaveMutex();
        }
        return NULL;
}


CollectionEntry* ObjectTable::getPreviousEntry() {
        if (accessMutex->EnterMutex(5000)) {
                if ( (current != NULL) && (current->prev != NULL) ) {
                        currentPos--;
                        current = (CollectionEntry*) current->prev;
                        accessMutex->LeaveMutex();
                        return current;
                }
                accessMutex->LeaveMutex();
        }
        return NULL;
}


CollectionEntry* ObjectTable::getFirstEntry() {
        CollectionEntry* item = NULL;   
        if (accessMutex->EnterMutex(5000)) {
                currentPos = 0;
                current = first;
                item = first;
                accessMutex->LeaveMutex();
        }
        return item;
}

CollectionEntry* ObjectTable::getLastEntry() {
        CollectionEntry* item = NULL;   
        if (accessMutex->EnterMutex(5000)) {
                currentPos = count - 1;
                current = last;
                item = last;
                accessMutex->LeaveMutex();
        }
        return item;
}

Object* ObjectTable::getKey(int pos) const {
        CollectionEntry* entry = getEntry(pos);
        if (entry == NULL)
                return NULL;
        return entry->key;
}

Object* ObjectTable::getKey(int pos) {
        CollectionEntry* entry = getEntry(pos);
        if (entry == NULL)
                return NULL;
        return entry->key;
}

Object* ObjectTable::getFirstKey() {
        CollectionEntry* entry = getFirstEntry();
        if (entry == NULL)
                return NULL;
        return entry->key;
}

Object* ObjectTable::getLastKey() {
        CollectionEntry* entry = getLastEntry();
        if (entry == NULL)
                return NULL;
        return entry->key;
}

Object* ObjectTable::getNextKey() {
        CollectionEntry* entry = getNextEntry();
        if (entry == NULL)
                return NULL;
        return entry->key;
}

Object* ObjectTable::getPreviousKey() {
        CollectionEntry* entry = getPreviousEntry();
        if (entry == NULL)
                return NULL;
        return entry->key;
}
















int ObjectTable::getEntryPos(CollectionEntry* entry) const {
        int c = 0;
        CollectionEntry* e = NULL;
        if (accessMutex->EnterMutex(5000)) {
                e = first;
                while ((e != NULL) && (e != entry)) {
                        e = e->next;
                        c++;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 12 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return ((e == NULL) ? -1 : c);
}


int ObjectTable::addAndReturnPosition(Object* key, Object* value) {
        CollectionEntry* entry;

        if (sorting & SORTBYKEY) {
                if (sorting & SORTREVERSE) {
                        if ( (entry = getLastEntryBeforeKey(key)) != NULL) {
                                if (addAfterEntry(entry, key, value))
                                        return getEntryPos(entry)+1;
                                else
                                        return -1;
                        }
                        else {
                                addFirst(key, value);
                                return 0;
                        }
                }
                else {
                        if ( (entry = getLastEntryBeforeKey(key)) != NULL) {
                                if (addAfterEntry(entry, key, value))
                                        return getEntryPos(entry)+1;
                                else
                                        return -1;
                        }
                        else {
                                addFirst(key, value);
                                return 0;
                        }
                }
        }
        else if (sorting & SORTBYVALUE) {
                if (sorting & SORTREVERSE) {
                        /*
                        if ( (entry = getEntryValue(value)) != NULL) {
                                if (addBeforeEntry(entry, key, value))
                                        return getEntryPos(entry)-1;
                                else
                                        return -1;
                        }
                        else */
                        if ( (entry = getLastEntryBefore(value)) != NULL) {
                                if (addAfterEntry(entry, key, value))
                                        return getEntryPos(entry)+1;
                                else
                                        return -1;
                        }
                        else {
                                addFirst(key, value);
                                return 0;
                        }
                }
                else {
                        /*
                        if ( (entry = getEntryValue(value)) != NULL) {
                                if (addAfterEntry(entry, key, value))
                                        return getEntryPos(entry)+1;
                                else
                                        return -1;
                        }
                        else */
                        if ( (entry = getLastEntryBefore(value)) != NULL) {
                                if (addAfterEntry(entry, key, value))
                                        return getEntryPos(entry)+1;
                                else
                                        return -1;
                        }
                        else {
                                addFirst(key, value);
                                return 0;
                        }
                }
        }
        else {
                if (!addLast(key, value))
                        return -1;
                else
                        return getCount()-1;
        }
}




ObjectCollection* ObjectTable::getAllBetweenKeys(const Object* key1, const Object* key2) {
        ObjectCollection* entries = getAllEntriesBetweenKeys(key1, key2);
        if (entries == NULL)
                return NULL;
        ObjectCollection* col = new ObjectCollection();
        col->noDelete();
        CollectionEntry* entry;
        for (int n=0; n<entries->getCount(); n++) {
                if ( (entry = (CollectionEntry*) entries->get(n)) != NULL )
                        col->add(entry->value);
        }
        delete(entries);
        return col;
}

ObjectCollection* ObjectTable::getAllBetween(const Object* value1, const Object* value2) {
        ObjectCollection* entries = getAllEntriesBetween(value1, value2);
        if (entries == NULL)
                return NULL;
        ObjectCollection* col = new ObjectCollection();
        col->noDelete();
        CollectionEntry* entry;
        for (int n=0; n<entries->getCount(); n++) {
                if ( (entry = (CollectionEntry*) entries->get(n)) != NULL )
                        col->add(entry->value);
        }
        delete(entries);
        return col;
}

Object* ObjectTable::getFirstAfterKey(const Object* key) {
        CollectionEntry* entry = getFirstEntryAfterKey(key);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getFirstAfter(const Object* value) {
        CollectionEntry* entry = getFirstEntryAfter(value);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getLastBeforeKey(const Object* key) {
        CollectionEntry* entry = getLastEntryBeforeKey(key);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

Object* ObjectTable::getLastBefore(const Object* value) {
        CollectionEntry* entry = getLastEntryBefore(value);
        if (entry != NULL)
                return entry->value;
        else
                return NULL;
}

int ObjectTable::removeAllBetweenKeys(const Object* key1, const Object* key2) {
        return removeAllEntriesBetweenKeys(key1, key2);
}

int ObjectTable::removeAllBetween(const Object* value1, const Object* value2) {
        return removeAllEntriesBetween(value1, value2);
}

int ObjectTable::removeAllBeforeKey(const Object* key) {
        if (first == NULL)
                return 0;
        return removeAllEntriesBetweenKeys(first->key, key);
}

int ObjectTable::removeAllBefore(const Object* value) {
        if (first == NULL)
                return 0;
        return removeAllEntriesBetween(first->value, value);
}

int ObjectTable::removeAllAfterKey(const Object* key) {
        if (first == NULL)
                return 0;
        return removeAllEntriesBetweenKeys(key, last->key);
}

int ObjectTable::removeAllAfter(const Object* value) {
        if (first == NULL)
                return 0;
        return removeAllEntriesBetween(value, last->value);
}







CollectionEntry** ObjectTable::findClosestKeys(const Object* key) const {
        CollectionEntry** triplet = new CollectionEntry*[3];
        memset(triplet, 0, sizeof(CollectionEntry*)*3);

        CollectionEntry* entry = this->getEntryKey(key);
        if (entry != NULL) {
                triplet[0] = entry;
                triplet[1] = entry->prev;
                triplet[2] = entry->next;
                return triplet;
        }

        // Key not found, search for nearest keys on both sides

        // If collection not sorted by key or empty or no keys, return nothing
        if ((!(sorting & SORTBYKEY)) || (first == NULL) || (first->key == NULL))
                return triplet;

        int comp, comp2;

        if (sorting & SORTREVERSE) {
                // If first < key then return [0,first]
                comp = first->key->compare(key);
                if ( (comp < 0) ) {
                        triplet[2] = first;
                        return triplet;
                }
                else {
                        // If last > key then return [last,0]
                        comp2 = last->key->compare(key);
                        if ( (comp2 >= 0) ) {
                                triplet[1] = last;
                                return triplet;
                        }
                        // If first = last = value then return [last,0]
                        else if ( (comp == 0) && (comp2 == 0)) {
                                triplet[1] = last;
                                return triplet;
                        }
                }
        }
        else {
                // If first > key then return [0,first]
                comp = first->key->compare(key);
                if ( (comp > 0) ) {
                        triplet[2] = first;
                        return triplet;
                }
                else {
                        // If last < key then return [last,0]
                        comp2 = last->key->compare(key);
                        if ( (comp2 <= 0) ) {
                                triplet[1] = last;
                                return triplet;
                        }
                        // If first = last = value then return [last,0]
                        else if ( (comp == 0) && (comp2 == 0)) {
                                triplet[1] = last;
                                return triplet;
                        }
                }
        }

        // If count == 2 then return [first,last]
        if (getCount() == 2) {
                triplet[1] = first;
                triplet[2] = last;
                return triplet;
        }

        entry = first;
        bool growing = true;
        int n;
        // Now we know that we need to search in between first and last
        // Binary search, find the middle key and go lower/higher, etc.
        for (int delta = (getCount() >> 1); delta >= 1; delta = (delta >> 1)) {
                if (growing)
                        for (n=0; n<delta; n++) entry = entry->next;
                else
                        for (n=0; n<delta; n++) entry = entry->prev;
                growing = ( (comp = entry->key->compare(key)) <= 0);
                if ((comp != 0) && (sorting & SORTREVERSE))
                        growing = (!growing);
        }

        if (sorting & SORTREVERSE) {
                // If entry > key (growing)
                // go up until not
                if (growing) {
                        do { entry = entry->next; }
                        while ( (entry != NULL) && (entry->key->compare(key) >= 0) );
                        if (entry == NULL)
                                triplet[1] = last;
                        else {
                                triplet[1] = entry->prev;
                                triplet[2] = entry;
                        }
                }
                // If entry < key (!growing)
                // go up until not
                else {
                        do { entry = entry->prev; }
                        while (entry->key->compare(key) < 0);
                        triplet[1] = entry;
                        triplet[2] = entry->next;
                }
        }
        else {
                // If entry > key (!growing)
                // go down until not
                if (!growing) {
                        do { entry = entry->prev; }
                        while (entry->key->compare(key) > 0);
                        triplet[1] = entry;
                        triplet[2] = entry->next;
                }
                // If entry < key (growing)
                // go up until not
                else {
                        do { entry = entry->next; }
                        while ( (entry != NULL) && (entry->key->compare(key) <= 0));
                        if (entry == NULL)
                                triplet[1] = last;
                        else {
                                triplet[1] = entry->prev;
                                triplet[2] = entry;
                        }
                }
        }

        //if (growing) {
        //      if (sorting & SORTREVERSE) {
        //              while (entry->key->compare(key) > 0)
        //                      entry = entry->next;
        //      }
        //      else {
        //              while (entry->key->compare(key) < 0)
        //                      entry = entry->next;
        //      }
        //      triplet[1] = entry->prev;
        //      triplet[2] = entry;
        //}
        //else {
        //      if (sorting & SORTREVERSE) {
        //              while (entry->key->compare(key) > 0)
        //                      entry = entry->prev;
        //      }
        //      else {
        //              while (entry->key->compare(key) < 0)
        //                      entry = entry->prev;
        //      }
        //      triplet[1] = entry;
        //      triplet[2] = entry->next;
        //}

        return triplet;
}

CollectionEntry** ObjectTable::findClosestValues(const Object* value) const {
        CollectionEntry** triplet = new CollectionEntry*[3];
        memset(triplet, 0, sizeof(CollectionEntry*)*3);

        CollectionEntry* entry = this->getEntryValue(value);
        if (entry != NULL) {
                triplet[0] = entry;
                triplet[1] = entry->prev;
                triplet[2] = entry->next;
                return triplet;
        }

        // Value not found, search for nearest keys on both sides

        // If collection not sorted by value or empty, return nothing
        if ((!(sorting & SORTBYVALUE)) || (first == NULL))
                return triplet;

        int comp, comp2;

        if (sorting & SORTREVERSE) {
                // If first < value then return [0,first]
                comp = first->value->compare(value);
                if ( (comp < 0) ) {
                        triplet[2] = first;
                        return triplet;
                }
                else {
                        comp2 = last->value->compare(value);
                        // If last > value then return [last,0]
                        if ( (comp2 >= 0) ) {
                                triplet[1] = last;
                                return triplet;
                        }
                        // If first = last = value then return [last,0]
                        else if ( (comp == 0) && (comp2 == 0)) {
                                triplet[1] = last;
                                return triplet;
                        }
                }
        }
        else {
                // If first > value then return [0,first]
                comp = first->value->compare(value);
                if ( (comp > 0) ) {
                        triplet[2] = first;
                        return triplet;
                }
                else {
                        // If last < value then return [last,0]
                        comp2 = last->value->compare(value);
                        if ( (comp2 <= 0) ) {
                                triplet[1] = last;
                                return triplet;
                        }
                        // If first = last = value then return [last,0]
                        else if ( (comp == 0) && (comp2 == 0)) {
                                triplet[1] = last;
                                return triplet;
                        }
                }
        }

        // If count == 2 then return [first,last]
        if (getCount() == 2) {
                triplet[1] = first;
                triplet[2] = last;
                return triplet;
        }

        entry = first;
        bool growing = true;
        int n;
        // Now we know that we need to search in between first and last
        // Binary search, find the middle key and go lower/higher, etc.
        for (int delta = (getCount() >> 1); delta >= 1; delta = (delta >> 1)) {
                if (growing)
                        for (n=0; n<delta; n++) entry = entry->next;
                else
                        for (n=0; n<delta; n++) entry = entry->prev;
                growing = ( (comp = entry->value->compare(value)) <= 0);
                if ( (comp != 0) && (sorting & SORTREVERSE))
                        growing = (!growing);
        }

        if (sorting & SORTREVERSE) {
                // If entry > value (growing)
                // go up until not
                if (growing) {
                        do { entry = entry->next; }
                        while ( (entry != NULL) && (entry->value->compare(value) >= 0) );
                        if (entry == NULL)
                                triplet[1] = last;
                        else {
                                triplet[1] = entry->prev;
                                triplet[2] = entry;
                        }
                }
                // If entry < value (!growing)
                // go up until not
                else {
                        do { entry = entry->prev; }
                        while (entry->value->compare(value) < 0);
                        triplet[1] = entry;
                        triplet[2] = entry->next;
                }
        }
        else {
                // If entry > value (!growing)
                // go down until not
                if (!growing) {
                        do { entry = entry->prev; }
                        while (entry->value->compare(value) > 0);
                        triplet[1] = entry;
                        triplet[2] = entry->next;
                }
                // If entry < value (growing)
                // go up until not
                else {
                        do { entry = entry->next; }
                        while ( (entry != NULL) && (entry->value->compare(value) <= 0) );
                        if (entry == NULL)
                                triplet[1] = last;
                        else {
                                triplet[1] = entry->prev;
                                triplet[2] = entry;
                        }
                }
        }

        return triplet;
}








ObjectCollection* ObjectTable::getAllEntriesBetweenKeys(const Object* key1, const Object* key2) {
        if ( (key1 == NULL) || (key2 == NULL) )
                return NULL;
        // If collection not sorted by key or empty or no keys, return nothing
        if ((!(sorting & SORTBYKEY)) || (first == NULL) || (first->key == NULL))
                return NULL;

        ObjectCollection* col = new ObjectCollection();
        col->noDelete();

        if (key1->equals(key2)) {
                col->add(getEntryKey(key1));
                return col;
        }

        const Object* k1, *k2;
        if (key1->compare(key2) < 0) {
                k1 = key1;
                k2 = key2;
        }
        else {
                k2 = key1;
                k1 = key2;
        }

        CollectionEntry* entry;
        if (sorting & SORTREVERSE) {
                entry = getEntryKey(k2);
                if (entry == NULL)
                        entry = getFirstEntryAfterKey(k2);
                if (accessMutex->EnterMutex(5000)) {
                        if ( (entry != NULL) && (entry->prev != NULL) && (k2->compare(entry->prev->key) == 0) )
                                col->add(entry->prev);
                        while ((entry != NULL) && (k1->compare(entry->key) <= 0)) {
                                col->add(entry);
                                entry = entry->next;
                        }
                        accessMutex->LeaveMutex();
                }
        }
        else {
                entry = getEntryKey(k1);
                if (entry == NULL)
                        entry = getFirstEntryAfterKey(k1);
                if (accessMutex->EnterMutex(5000)) {
                        if ( (entry != NULL) && (entry->prev != NULL) && (k1->compare(entry->prev->key) == 0) )
                                col->add(entry->prev);
                        while ((entry != NULL) && (k2->compare(entry->key) >= 0)) {
                                col->add(entry);
                                entry = entry->next;
                        }
                        accessMutex->LeaveMutex();
                }
        }
        return col;
}




ObjectCollection* ObjectTable::getAllEntriesBetween(const Object* value1, const Object* value2) {
        if ( (value1 == NULL) || (value2 == NULL) )
                return NULL;
        // If collection not sorted by value or empty, return nothing
        if ((!(sorting & SORTBYVALUE)) || (first == NULL))
                return NULL;

        ObjectCollection* col = new ObjectCollection();
        col->noDelete();

        if (value1->equals(value2)) {
                col->add(getEntryValue(value1));
                return col;
        }

        const Object* k1, *k2;
        if (value1->compare(value2) <= 0) {
                k1 = value1;
                k2 = value2;
        }
        else {
                k2 = value1;
                k1 = value2;
        }

        CollectionEntry* entry;
        if (sorting & SORTREVERSE) {
                entry = getEntryValue(k2);
                if (entry != NULL) {
                        while ((entry->prev != NULL) && (entry->value->compare(entry->prev->value) == 0))
                                entry = entry->prev;
                }
                else
                        entry = getFirstEntryAfter(k2);
                if (accessMutex->EnterMutex(5000)) {
                        if (entry == NULL)
                                entry = last;
                        else if ( (entry != NULL) && (entry->prev != NULL) && (k2->compare(entry->prev->value) == 0) )
                                col->add(entry->prev);
                        while ((entry != NULL) && (k1->compare(entry->value) <= 0)) {
                                col->add(entry);
                                entry = entry->next;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                entry = getEntryValue(k1);
                if (entry != NULL) {
                        while ((entry->prev != NULL) && (entry->value->compare(entry->prev->value) == 0))
                                entry = entry->prev;
                }
                else
                        entry = getFirstEntryAfter(k1);
                if (accessMutex->EnterMutex(5000)) {
                        if (entry == NULL)
                                entry = first;
                        if ( (entry != NULL) && (entry->prev != NULL) && (k1->compare(entry->prev->value) == 0) )
                                col->add(entry->prev);
                        while ((entry != NULL) && (k2->compare(entry->value) >= 0)) {
                                col->add(entry);
                                entry = entry->next;
                        }
                }
                accessMutex->LeaveMutex();
        }
        return col;
}

CollectionEntry* ObjectTable::getFirstEntryAfterKey(const Object* key) {

        CollectionEntry** entries = findClosestKeys(key);
        CollectionEntry* entry = entries[2];
        delete [] entries;
        return entry;

        //if (accessMutex->EnterMutex(5000)) {
        //      if ( (first != NULL) && (first->key != NULL) && (last->key != NULL) && (first->key->compare(last->key) == 0) ) {
        //              if (sorting & SORTREVERSE) {
        //                      if (key->compare(first->key) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //              }
        //              else {
        //                      if (key->compare(first->key) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //              }
        //      }

        //      CollectionEntry* entry;

        //      if (sorting & SORTREVERSE) {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (key->compare(entry->key) <= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (key->compare(entry->key) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->prev;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //      }
        //      else {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (key->compare(entry->key) >= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->next;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (key->compare(entry->key) < 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //      }
        //      accessMutex->LeaveMutex();
        //}
        //else {
        //      printf("******* Access Denied 15 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //}
        //return NULL;
}

CollectionEntry* ObjectTable::getFirstEntryAfter(const Object* value) {

        CollectionEntry** entries = findClosestValues(value);
        CollectionEntry* entry = entries[2];
        delete [] entries;
        return entry;

        //if (accessMutex->EnterMutex(5000)) {
        //      if ( (first != NULL) && (first->value->compare(last->value) == 0) ) {
        //              if (sorting & SORTREVERSE) {
        //                      if (value->compare(first->value) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //              }
        //              else {
        //                      if (value->compare(first->value) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //              }
        //      }

        //      CollectionEntry* entry;

        //      if (sorting & SORTREVERSE) {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (value->compare(entry->value) <= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (value->compare(entry->value) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->prev;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //      }
        //      else {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (value->compare(entry->value) >= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->next;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (value->compare(entry->value) < 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //      }
        //      accessMutex->LeaveMutex();
        //}
        //else {
        //      printf("******* Access Denied 16 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //}
        //return NULL;
}

CollectionEntry* ObjectTable::getLastEntryBeforeKey(const Object* key) {
        
        CollectionEntry** entries = findClosestKeys(key);
        CollectionEntry* entry = entries[1];
        delete [] entries;
        return entry;

        //if (accessMutex->EnterMutex(5000)) {
        //      if ( (first != NULL) && (first->key != NULL) && (last->key != NULL) && (first->key->compare(last->key) == 0) ) {
        //              if (sorting & SORTREVERSE) {
        //                      if (key->compare(first->key) <= 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //              }
        //              else {
        //                      if (key->compare(first->key) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return last;
        //                      }
        //              }
        //      }
        //      
        //      CollectionEntry* entry;

        //      if (sorting & SORTREVERSE) {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (key->compare(entry->key) < 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->next;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (key->compare(entry->key) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return last;
        //              }
        //      }
        //      else {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (key->compare(entry->key) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (key->compare(entry->key) <= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->prev;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return last;
        //              }
        //      }
        //      accessMutex->LeaveMutex();
        //}
        //else {
        //      printf("******* Access Denied 17 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //}
        //return NULL;
}

CollectionEntry* ObjectTable::getLastEntryBefore(const Object* value) {

        CollectionEntry** entries = findClosestValues(value);
        CollectionEntry* entry = entries[1];
        delete [] entries;
        return entry;

        //if (accessMutex->EnterMutex(5000)) {
        //      if ( (first != NULL) && (first->value->compare(last->value) == 0) ) {
        //              if (sorting & SORTREVERSE) {
        //                      if (value->compare(first->value) <= 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return first;
        //                      }
        //              }
        //              else {
        //                      if (value->compare(first->value) < 0) {
        //                              accessMutex->LeaveMutex();
        //                              return NULL;
        //                      }
        //                      else {
        //                              accessMutex->LeaveMutex();
        //                              return last;
        //                      }
        //              }
        //      }

        //      CollectionEntry* entry;

        //      if (sorting & SORTREVERSE) {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              // printf("."); fflush(stdout);
        //                              if (value->compare(entry->value) < 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->next;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return first;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              // printf("."); fflush(stdout);
        //                              if (value->compare(entry->value) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return last;
        //              }
        //      }
        //      else {
        //              if (sorting & FINDREVERSE) {
        //                      for (entry = last; entry != NULL; entry = entry->prev) {
        //                              if (value->compare(entry->value) > 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return NULL;
        //              }
        //              else {
        //                      for (entry = first; entry != NULL; entry = entry->next) {
        //                              if (value->compare(entry->value) <= 0) {
        //                                      accessMutex->LeaveMutex();
        //                                      return entry->prev;
        //                              }
        //                      }
        //                      accessMutex->LeaveMutex();
        //                      return last;
        //              }
        //      }
        //      accessMutex->LeaveMutex();
        //}
        //else {
        //      printf("******* Access Denied 18 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //}
        //return NULL;
}


int ObjectTable::removeAllEntriesBetweenKeys(const Object* key1, const Object* key2) {
        int c = 0;
        if (accessMutex->EnterMutex(5000)) {
                ObjectCollection* col = getAllEntriesBetweenKeys(key1, key2);
                if (col != NULL) {
                        for (CollectionEntry* entry = (CollectionEntry*) col->getFirst(); entry != NULL; entry = (CollectionEntry*) col->getNext()) {
                                if (removeEntry(entry))
                                        c++;
                        }
                }
                delete(col);
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 19 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return c;
}

int ObjectTable::removeAllEntriesBetween(const Object* value1, const Object* value2) {
        int c = 0;
        if (accessMutex->EnterMutex(5000)) {
                ObjectCollection* col = getAllEntriesBetween(value1, value2);
                if (col != NULL) {
                        for (CollectionEntry* entry = (CollectionEntry*) col->getFirst(); entry != NULL; entry = (CollectionEntry*) col->getNext()) {
                                if (removeEntry(entry))
                                        c++;
                        }
                }
                delete(col);
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 20 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return c;
}










// ******************************************************
// Printing...
// ******************************************************

JString ObjectTable::toHTML() {
        JString str = "<TABLE width=\"100%%\" class=\"DictionaryTable\">\n";
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->key != NULL)
                                str += JString::format("<TR>\n<TD class=\"DictionaryKey\" valign=\"top\" align=\"left\">%s</TD>\n", (char*) entry->key->toHTML());
                        else
                                str += JString("<TR>\n<TD></TD>\n");
                        str += JString::format("<TD class=\"DictionaryValue\" valign=\"top\" align=\"left\">%s</TD>\n</TD>\n", (char*) entry->value->toHTML());
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 21 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        str += JString("</TABLE>\n");
        return str;
}


JString ObjectTable::toXML() {
        JString xml;
//      CollectionEntry* entry;

        int mytype = -1; // ObjectTable
        if (type.equals("objectcollection"))
                mytype = 1;
        else if (type.equals("objectdictionary"))
                mytype = 2;
        else if (type.equals("dictionary"))
                mytype = 3;
        else if (type.equals("sortedcollection"))
                mytype = 0;
        else if (type.equals("sortedobjectcollection"))
                mytype = 1;
        else if (type.equals("sorteddictionary"))
                mytype = 3;
        else if (type.equals("sortedobjectdictionary"))
                mytype = 2;
        else if (type.equals("collection"))
                mytype = 0;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        switch(mytype) {
                                case -1: // ObjectTable
                                        if (entry->key != NULL) {
                                                xml += JString::format("<objectkey>\n%s</objectkey>\n", (char*) entry->key->toXML().indentXML());
                                        }
                                        xml += JString::format("<objectvalue>\n%s</objectvalue>\n", (char*) entry->value->toXML().indentXML());
                                        break;
                                case 0: // collection
                                        if (((JString*)entry->value)->startsOrEndsWithWhiteSpace())
                                                xml += JString::format("<entry value=\"%s\" />\n", (char*) ((JString*)entry->value)->xmlStringEncode());
                                        else
                                                xml += JString::format("<entry>%s</entry>\n", (char*) ((JString*)entry->value)->xmlStringEncode());
                                        break;
                                case 1: // objectcollection
                                        xml += JString::format("<object>\n%s</object>\n", (char*) entry->value->toXML().indentXML());
                                        break;
                                case 2: // objectdictionary
                                        xml += JString::format("<object name=\"%s\">\n%s</object>\n", (char*) ((JString*)entry->key)->xmlStringEncode(), (char*) entry->value->toXML().indentXML());
                                        break;
                                case 3: // dictionary
                                        if (((JString*)entry->value)->startsOrEndsWithWhiteSpace())
                                                xml += JString::format("<entry name=\"%s\" value=\"%s\" />\n", (char*) ((JString*)entry->key)->xmlStringEncode(), (char*) ((JString*)entry->value)->xmlStringEncode());
                                        else
                                                xml += JString::format("<entry name=\"%s\">%s</entry>\n", (char*) ((JString*)entry->key)->xmlStringEncode(), (char*) ((JString*)entry->value)->xmlStringEncode());
                                        break;
                                default: // collection
                                        break;
                        }
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 22 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        if (xml.length() > 0)
                return (JString::format("<%s>\n%s</%s>", (char*) type, (char*) xml.indentXML(), (char*) type));
        else
                return (JString::format("<%s />", (char*) type));

}

bool ObjectTable::fromXML(const JString& xml) {

        bool ret = false;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        ret = fromXML(xmlParser->getRootNode());
        delete(xmlParser);
        return ret;
}

bool ObjectTable::fromXML(XMLNode* node) {

        removeAll();

        if (node == NULL)
                return false;

        JString tag = node->getTag();
        JString subtag;

        Object* object, *objectkey = NULL;
        XMLNode* xmlNode;
        ObjectCollection* col = node->getChildTags();

        if (col != NULL) {
                for (int n=0; n<col->getCount(); n++) {
                        if ( (xmlNode = (XMLNode*) col->get(n)) != NULL ) {
                                subtag = xmlNode->getTag();
                                if (subtag.equals("object")) {
                                        object = createObjectFromXML(xmlNode->getFirstChildNode());
                                        if (xmlNode->hasAttribute("name"))
                                                objectkey = xmlNode->getAttribute("name").clone();
                                        else
                                                objectkey = NULL;
                                        this->add(objectkey, object);
                                        objectkey = NULL;
                                }
                                else if (subtag.equals("entry")) {
                                        if (xmlNode->hasAttribute("value"))
                                                object = xmlNode->getAttribute("value").clone();
                                        else
                                                object = xmlNode->getTextContent().clone();
                                        if (xmlNode->hasAttribute("name"))
                                                objectkey = xmlNode->getAttribute("name").clone();
                                        else
                                                objectkey = NULL;
                                        this->add(objectkey, object);
                                        objectkey = NULL;
                                }
                                else if (subtag.equals("objectkey")) {
                                        objectkey = createObjectFromXML(xmlNode->getFirstChildNode());
                                }
                                else if ((objectkey != NULL) && (subtag.equals("objectvalue"))) {
                                        object = createObjectFromXML(xmlNode->getFirstChildNode());
                                        this->add(objectkey, object);
                                        objectkey = NULL;
                                }
                        }
                }
        }
        return true;    
}



JString ObjectTable::print() const {
        JString str;
        int n = 0;

        str = "Number of entries: ";
        str += JString(count);
        str += "\n";
        
        if (count == 0) return str;

        str = "";

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* item = first;
                while (item != NULL) {
                        str += JString(n);
                        str += "\t";
                        str += print(item);
                        str += "\n";
                        item = (CollectionEntry*) item->next;
                        n++;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 23 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        
        return str;
}

JString ObjectTable::printListLine(const JString& separator, const JString& equalsign, const JString& quotes) const {
        JString str;
        if (count == 0) return "";

        int c = 0;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* item = first;
                while (item != NULL) {
                        str += printEntry(item, equalsign, quotes);
                        if (item->next != NULL)
                                str += separator;
                        item = (CollectionEntry*) item->next;
                        c++;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 24 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        
        return str;
}


JString ObjectTable::print(const Object* key) const {
        const CollectionEntry* entry = getEntryKey(key);
        return(printEntry(entry));
}

JString ObjectTable::printEntry(const CollectionEntry* item, const JString& separator, const JString& quotes) const {
        if (item == NULL) return "";

        if (item->key != NULL)
                return JString::format("%s%s%s%s%s", (char*) item->key->print(), (char*) separator, (char*) quotes, (char*) item->value->print(), (char*) quotes);
        else
                return item->value->print();
}







// ******************************************************
// Testing...
// ******************************************************

bool ObjectTable::unitTest() {

        //Creating Table .1k:              19.373ms    1.092ms
        //Creating Table 1k:              147.996ms   12.723ms
        //Creating Table 10k:           20875.000ms  139.289ms
        //Key Fetching:                  2422.000ms    3.905ms
        //Pos Fetching:                    65.529ms   12.810ms

        //MediaServer Unit Test:  27.80 / 33.96 MB/sec | 4.0ms = 247.9fps        PASSED
        //MediaServer Unit Test:  53.94 / 51.10 MB/sec | 0.2ms = 5350.5fps       PASSED

        printf("\n  Performance Tests:\n");

        Dictionary dict;
        JString s;
        int n;
        JTime start;

        for (n=0; n<100; n++) {
                dict.put(JString(n), JString(n));
        }
        dict.removeAll();

        start = JTime();
        for (n=0; n<100; n++) {
                dict.put(JString(n), JString(n));
        }
        printf("    %s %s", (char*) JString("Creating Table .1k:", 20, 0), (char*) JString(JString::format("%.3fms", start.getMicroAge()/1000.0), 20, 1));
        printf("\n");
        dict.removeAll();

        start = JTime();
        for (n=0; n<1000; n++) {
                dict.put(JString(n), JString(n));
        }
        printf("    %s %s", (char*) JString("Creating Table 1k:", 20, 0), (char*) JString(JString::format("%.3fms", start.getMicroAge()/1000.0), 20, 1));
        printf("\n");
        dict.removeAll();

        start = JTime();
        for (n=0; n<10000; n++) {
                dict.put(JString(n), JString(n));
        }
        printf("    %s %s", (char*) JString("Creating Table 10k:", 20, 0), (char*) JString(JString::format("%.3fms", start.getMicroAge()/1000.0), 20, 1));
        printf("\n");

        this->addUnitTestLog("Testing get by key...");
        start = JTime();

        for (n=0; n<100; n++) {
                if (!dict.get("200").equals("200"))
                        return false;
                if (!dict.get("500").equals("500"))
                        return false;
                if (!dict.get("3200").equals("3200"))
                        return false;
                if (!dict.get("3500").equals("3500"))
                        return false;
                if (!dict.get("5200").equals("5200"))
                        return false;
                if (!dict.get("5500").equals("5500"))
                        return false;
                if (!dict.get("9200").equals("9200"))
                        return false;
                if (!dict.get("9500").equals("9500"))
                        return false;
                dict.get("11200");
                dict.get("11500");
        }
        printf("    %s %s", (char*) JString("Key Fetching:", 20, 0), (char*) JString(JString::format("%.3fms", start.getMicroAge()/1000.0), 20, 1));
        printf("\n");

        this->addUnitTestLog("Testing get by pos...");
        start = JTime();
        for (n=0; n<100; n++) {
                dict.get(200);
                if (!dict.get(500).equals("500"))
                        return false;
                if (!dict.get(3200).equals("3200"))
                        return false;
                if (!dict.get(3500).equals("3500"))
                        return false;
                if (!dict.get(5200).equals("5200"))
                        return false;
                if (!dict.get(5500).equals("5500"))
                        return false;
                if (!dict.get(9200).equals("9200"))
                        return false;
                if (!dict.get(9500).equals("9500"))
                        return false;
                dict.get(11200);
                dict.get(11500);
        }
        printf("    %s %s", (char*) JString("Pos Fetching:", 20, 0), (char*) JString(JString::format("%.3fms", start.getMicroAge()/1000.0), 20, 1));
        printf("\n");

        // Insert into sorted
        // getPos()
        // Test getRange()

        ObjectTable table;
        table.sorting = SORTBYKEY | SORTREVERSE;
//      for (n=0; n<100; n+=2) {
        table.add(new JString("00"), new JString("00"));
        table.add(new JString("14"), new JString("14"));
        table.add(new JString("04"), new JString("04"));
        table.add(new JString("06"), new JString("06"));
        table.add(new JString("08"), new JString("08"));
        table.add(new JString("02"), new JString("02"));
        table.add(new JString("10"), new JString("10"));
        table.add(new JString("12"), new JString("12"));
        table.add(new JString("16"), new JString("16"));
        table.add(new JString("18"), new JString("18"));
        table.add(new JString("20"), new JString("20"));
//      }

        JString key = "09";
        CollectionEntry** entries = table.findClosestKeys(&key);
        if (entries[0] != NULL) {
                this->addUnitTestLog("Closest key failed by finding exact key...");
                return false;
        }
        if (entries[1] == NULL) {
                this->addUnitTestLog("Closest key failed by not finding lower key...");
                return false;
        }
        if (entries[2] == NULL) {
                this->addUnitTestLog("Closest key failed by not finding upper key...");
                return false;
        }
        //if (entries[0] != NULL)
        //      printf("Found match for '%s': %s\n", (char*) key, (char*) entries[0]->key->print());
        //if (entries[1] != NULL)
        //      printf("Found lower match for '%s': %s\n", (char*) key, (char*) entries[1]->key->print());
        //if (entries[2] != NULL)
        //      printf("Found upper match for '%s': %s\n", (char*) key, (char*) entries[2]->key->print());
        delete [] entries;

        JString k1 = JString(40);
        JString k2 = JString(15);
        ObjectCollection* coll = table.getAllBetweenKeys(&k1, &k2);
        if (coll == NULL) {
                this->addUnitTestLog("Found nothing between keys...");
                return false;
        }
        if (coll->getCount() != 3) {
                this->addUnitTestLog("Found wrong amount between keys...");
                return false;
        }
        delete(coll);
        coll = table.getAllBetween(&k1, &k2);
        if (coll != NULL) {
                this->addUnitTestLog("Found something between values...");
                return false;
        }
        delete(coll);

        printf("                                                                       ");

        return true;
}

bool ObjectTable::addAll(const ObjectTable* c)
{
//      if (c->getCount() == 0)
//              return true;
        return addAll(c->first, false);
}

bool ObjectTable::copyAll(const ObjectTable* c)
{
//      if (c->getCount() == 0)
//              return true;
        return addAll(c->first, true);
}

bool ObjectTable::takeAll(ObjectTable* c)
{
        if (!addAll(c->first, false))
                return false;
        c->removeAllNoDelete();
        return true;
}

bool ObjectTable::addAll(const ObjectTable& c)
{
//      if (c.getCount() == 0)
//              return true;
        return addAll(c.first, false);
}

bool ObjectTable::copyAll(const ObjectTable& c)
{
//      if (c.getCount() == 0)
//              return true;
        return addAll(c.first, true);
}

bool ObjectTable::takeAll(ObjectTable& c)
{
        if (!addAll(c.first, false))
                return false;
        c.removeAllNoDelete();
        return true;
}

bool ObjectTable::addAll(const CollectionEntry* f, bool copy) {
        const CollectionEntry* e = f;
//      JString* lpstr;
        Object* keycopy;

        if (accessMutex->EnterMutex(5000)) {
                while (e != NULL) {
                        if (e->key == NULL)
                                keycopy = NULL;
                        else
                                keycopy = e->key->clone();

                        if (copy)
                                addBetweenEntries(last, NULL, keycopy, e->value->clone());
                        else
                                addBetweenEntries(last, NULL, keycopy, e->value);
                        e = (CollectionEntry*) e->next;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 25 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        return true;
}



// ***************************************************************
// Binary Functions
// ***************************************************************

//! Get total size of payload
unsigned long ObjectTable::getPayloadSize() const {
        long payloadSize = 0;

        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->key != NULL )
                                payloadSize += entry->key->getPayloadSize();
                        if (entry->value != NULL )
                                payloadSize += entry->value->getPayloadSize();
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 26a ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return payloadSize;
}

//! Get the size of any binary data
long ObjectTable::getBinarySize(int chunk) {
        int c;
        long pos = 0;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->value != NULL) {
                                c = entry->value->getBinaryChunkCount();
                                if ( (pos <= chunk) && (chunk < pos+c) ) {
                                        long binsize = entry->value->getBinarySize(chunk-pos);
                                        accessMutex->LeaveMutex();
                                        return binsize;
                                }
                                pos += c;
                        }
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else
                printf("******* Access Denied 26.2 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        return 0;
}

//! Get the number of data chunks
int ObjectTable::getBinaryChunkCount() {
        long c = 0;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->value != NULL)
                                c += entry->value->getBinaryChunkCount();
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else
                printf("******* Access Denied 26.1 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        return c;
}

//! Get a pointer to the binary data at chunk number 'chunk'
long ObjectTable::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        int c;
        long pos = 0;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->value != NULL) {
                                c = entry->value->getBinaryChunkCount();
                                if ( (pos <= chunk) && (chunk < pos+c) ) {
                                        long binsize = entry->value->toBinaryBuffer(chunk-pos, buffer, maxlen);
                                        accessMutex->LeaveMutex();
                                        return binsize;
                                }
                                pos += c;
                        }
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else
                printf("******* Access Denied 26.2 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        return 0;
}

//! Set the data after separate reception
bool ObjectTable::fromBinaryBuffer(int chunk, char* buffer, long len) {
        int c;
        long pos = 0;
        if (accessMutex->EnterMutex(5000)) {
                CollectionEntry* entry = first;
                while (entry != NULL) {
                        if (entry->value != NULL) {
                                c = entry->value->getBinaryChunkCount();
                                if ( (pos <= chunk) && (chunk < pos+c) ) {
                                        bool res = entry->value->fromBinaryBuffer(chunk-pos, buffer, len);
                                        accessMutex->LeaveMutex();
                                        return res;
                                }
                                pos += c;
                        }
                        entry = entry->next;
                }
                accessMutex->LeaveMutex();
        }
        else
                printf("******* Access Denied 26.2 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        return 0;
}



//! Get the binary data containing objects
//ObjectCollection* ObjectTable::getBinaryDataObjects() {
//
//      ObjectCollection* col = new ObjectCollection();
//      col->noDelete();
//
//      Object* obj;
//      if (accessMutex->EnterMutex(5000)) {
//              CollectionEntry* entry = first;
//              while (entry != NULL) {
//                      if ( (obj = entry->value) != NULL ) {
//                              if (obj->getBinaryChunkCount() != 0)
//                                      col->add(obj);
//                      }
//                      entry = entry->next;
//              }
//              accessMutex->LeaveMutex();
//      }
//      else {
//              printf("******* Access Denied 26 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
//      }
//      return col;
//}

bool ObjectTable::sortKeysReverse() {
        if (count == 0)
                return true;

        int j;
        CollectionEntry *temp1, *temp2;
        int st = -1;
        bool swapped;

        if (accessMutex->EnterMutex(5000)) {

                int limit = getCount();

                while(st < limit) {
                        swapped = false;
                        st++;
                        limit--;
                        // Bubble the next largest one up
                        for(j=st; j<limit; j++) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isKeyBigger(temp2, temp1)) {
                                        if (temp1->prev != NULL)
                                                temp1->prev->next = temp2;
                                        if (temp2->next != NULL)
                                                temp2->next->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                        swapped = false;
                        
                        // Bubble the next smallest one down
                        for(j=limit-1; j>=st; --j) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isKeyBigger(temp2, temp1)) {
                                        if (temp1->prev != NULL)
                                                temp1->prev->next = temp2;
                                        if (temp2->next != NULL)
                                                temp2->next->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 27 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}

bool ObjectTable::sortKeys() {
        if (count == 0)
                return true;

        int j;
        CollectionEntry *temp1, *temp2;
        int st = -1;
        bool swapped;

        if (accessMutex->EnterMutex(5000)) {

                int limit = getCount();

                while(st < limit) {
                        swapped = false;
                        st++;
                        limit--;
                        // Bubble the next largest one up
                        for(j=st; j<limit; j++) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isKeyBigger(temp1, temp2)) {
                                        if (temp1->prev != NULL)
                                                temp1->prev->next = temp2;
                                        if (temp2->next != NULL)
                                                temp2->next->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                        swapped = false;
                        
                        // Bubble the next smallest one down
                        for(j=limit-1; j>=st; --j) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isKeyBigger(temp1, temp2)) {
                                        if (temp1->prev != NULL)
                                                temp1->prev->next = temp2;
                                        if (temp2->next != NULL)
                                                temp2->next->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 28 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}

bool ObjectTable::sortValues() {
        if (count == 0)
                return true;

        int j;
        CollectionEntry *temp1, *temp2;
        int st = -1;
        bool swapped;

        if (accessMutex->EnterMutex(5000)) {
                int limit = getCount();
                while(st < limit) {
                        swapped = false;
                        st++;
                        limit--;
                        // Bubble the next largest one up
                        for(j=st; j<limit; j++) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isValueBigger(temp1, temp2)) {
                                        if (temp1->prev != NULL)
                                                ((CollectionEntry*)(temp1->prev))->next = temp2;
                                        if (temp2->next != NULL)
                                                ((CollectionEntry*)(temp2->next))->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                        swapped = false;
                        
                        // Bubble the next smallest one down
                        for(j=limit-1; j>=st; --j) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isValueBigger(temp1, temp2)) {
                                        if (temp1->prev != NULL)
                                                ((CollectionEntry*)(temp1->prev))->next = temp2;
                                        if (temp2->next != NULL)
                                                ((CollectionEntry*)(temp2->next))->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 29 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}

bool ObjectTable::sortValuesReverse() {
        if (count == 0)
                return true;

        int j;
        CollectionEntry *temp1, *temp2;
        int st = -1;
        bool swapped;

        if (accessMutex->EnterMutex(5000)) {
                int limit = getCount();
                while(st < limit) {
                        swapped = false;
                        st++;
                        limit--;
                        // Bubble the next largest one up
                        for(j=st; j<limit; j++) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isValueBigger(temp2, temp1)) {
                                        if (temp1->prev != NULL)
                                                ((CollectionEntry*)(temp1->prev))->next = temp2;
                                        if (temp2->next != NULL)
                                                ((CollectionEntry*)(temp2->next))->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                        swapped = false;
                        
                        // Bubble the next smallest one down
                        for(j=limit-1; j>=st; --j) {
                                currentPos = -1;
                                current = NULL;
                                temp1 = ((ObjectTable*)this)->getEntry(j);
                                temp2 = (CollectionEntry*) temp1->next;
                                if(isValueBigger(temp2, temp1)) {
                                        if (temp1->prev != NULL)
                                                ((CollectionEntry*)(temp1->prev))->next = temp2;
                                        if (temp2->next != NULL)
                                                ((CollectionEntry*)(temp2->next))->prev = temp1;
                                        temp2->prev = temp1->prev;
                                        temp1->next = temp2->next;
                                        temp2->next = temp1;
                                        temp1->prev = temp2;
                                        if (first == temp1)
                                                first = temp2;
                                        if (last == temp2)
                                                last = temp1;
                                        swapped = true;
                                }
                        }

                        // Quit if the array is already sorted
                        if(!swapped) {
                                accessMutex->LeaveMutex();
                                return true;
                        }
                }
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 30 ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}

bool ObjectTable::sortRandomMix() {
        if (count == 0)
                return true;

        int count, p;
        Object* value;

        ObjectTable newTable;
        if (accessMutex->EnterMutex(5000)) {
                while ( (count = this->getCount()) > 0) {
                        if (count == 2) break;
                        p = (int)(Object::getRandomNumber() * count);
                        if ( (value = this->get(p)) != NULL ) {
                                newTable.addLast(this->getKey(p), value);
                                this->removeNoDelete(p);
                        }
                }
                if ( (value = this->get(1)) != NULL ) {
                        newTable.addLast(this->getKey(1), value);
                        this->removeNoDelete(1);
                }
                if ( (value = this->get(0)) != NULL ) {
                        newTable.addLast(this->getKey(0), value);
                        this->removeNoDelete(0);
                }
                this->removeAll();
                this->takeAll(newTable);
                accessMutex->LeaveMutex();
        }
        else {
                printf("******* Access Denied 29a ********\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        }

        return true;
}




bool ObjectTable::isKeyBigger(CollectionEntry* entry1, CollectionEntry* entry2) {
        if ( (entry1 == NULL) || (entry1->key == NULL) )
                return false;
        if ( (entry2 == NULL) || (entry2->key == NULL) )
                return true;
        if (entry1->key->compare(entry2->key) > 0)
                return true;
        else
                return false;
}

bool ObjectTable::isValueBigger(CollectionEntry* entry1, CollectionEntry* entry2) {
        if (entry1->value->compare(entry2->value) > 0)
                return true;
        else
                return false;
}























// HashTable implementation
//
//////////////////////////////////////////////////////////////////////

// http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
static const unsigned int primenumbers[] = {
53, 97, 193, 389, 769, 1543, 3079, 6151,
12289, 24593, 49157, 98317, 196613, 393241,
786433, 1572869, 3145739, 6291469, 12582917,
25165843, 50331653, 100663319, 201326611,
402653189, 805306457, 1610612741};

const double maximum_fill = 0.65;
const unsigned int primelen = sizeof(primenumbers)/sizeof(primenumbers[0]);

/*****************************************************************************/
struct HashTable *create_hashtable(unsigned int minsize) {
    struct HashTable *h;
    unsigned int pindex, size = primenumbers[0];
    /* Check requested hashtable isn't too large */
    if (minsize > (1u << 30)) return NULL;
    /* Enforce size as prime */
    for (pindex=0; pindex < primelen; pindex++) {
        if (primenumbers[pindex] > minsize) { size = primenumbers[pindex]; break; }
    }
    h = (struct HashTable *)malloc(sizeof(struct HashTable));
    if (NULL == h) return NULL; /*oom*/
    h->table = (struct HashEntry **)malloc(sizeof(struct HashEntry*) * size);
    if (NULL == h->table) { free(h); return NULL; } /*oom*/
    memset(h->table, 0, size * sizeof(struct HashEntry *));
    h->length  = size;
    h->prime   = pindex;
    h->count   = 0;
    h->limit    = (unsigned int) ceil(size * maximum_fill);
    return h;
}

/*****************************************************************************/
unsigned long hash(unsigned long hashkey) {
        unsigned long i = hashkey;
        i += ~(i << 9);
        i ^=  ((i >> 14) | (i << 18));
        i +=  (i << 4);
        i ^=  ((i >> 10) | (i << 22));
        return i;
}

/*****************************************************************************/
static int hashtable_expand(struct HashTable *h) {
    /* Double the size of the table to accomodate more entries */
    struct HashEntry **newtable;
    struct HashEntry *e;
    struct HashEntry **pE;
    unsigned int newsize, i, index;
    /* Check we're not hitting max capacity */
    if (h->prime == (primelen - 1)) return 0;
    newsize = primenumbers[++(h->prime)];

    newtable = (struct HashEntry **)malloc(sizeof(struct HashEntry*) * newsize);
    if (NULL != newtable)
    {
        memset(newtable, 0, newsize * sizeof(struct HashEntry *));
        /* This algorithm is not 'stable'. ie. it reverses the list
         * when it transfers entries between the tables */
        for (i = 0; i < h->length; i++) {
            while (NULL != (e = h->table[i])) {
                h->table[i] = e->next;
                index = hash2index(newsize,e->hash);
                e->next = newtable[index];
                newtable[index] = e;
            }
        }
        free(h->table);
        h->table = newtable;
    }
    /* Plan B: realloc instead */
    else 
    {
        newtable = (struct HashEntry **)
                   realloc(h->table, newsize * sizeof(struct HashEntry *));
        if (NULL == newtable) { (h->prime)--; return 0; }
        h->table = newtable;
        memset(newtable[h->length], 0, newsize - h->length);
        for (i = 0; i < h->length; i++) {
            for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
                index = hash2index(newsize,e->hash);
                if (index == i)
                {
                    pE = &(e->next);
                }
                else
                {
                    *pE = e->next;
                    e->next = newtable[index];
                    newtable[index] = e;
                }
            }
        }
    }
    h->length = newsize;
    h->limit   = (unsigned int) ceil(newsize * maximum_fill);
    return -1;
}

/*****************************************************************************/
unsigned int hashtable_count(const struct HashTable *h) {
    return h->count;
}

/*****************************************************************************/
bool hashtable_insert_key(struct HashTable *h, CollectionEntry* entry) {
        if ( (entry == NULL) || (entry->key == NULL)) return false;
        /* This method allows duplicate keys - but they shouldn't be used */
    unsigned int index;
    struct HashEntry *e;
    if (++(h->count) > h->limit) {
        /* Ignore the return value. If expand fails, we should
         * still try cramming just this value into the existing table
         * -- we may not have memory for a larger table, but one more
         * element may be ok. Next time we insert, we'll try expanding again.*/
        hashtable_expand(h);
    }
    e = (struct HashEntry *)malloc(sizeof(struct HashEntry));
    if (NULL == e) { --(h->count); return false; } /*oom*/
    e->hash = hash(entry->key->getHash());
    index = hash2index(h->length,e->hash);
        e->entry = entry;
    e->next = h->table[index];
    h->table[index] = e;
        entry->keyhash = e->hash;
    return true;
}

bool hashtable_insert_value(struct HashTable *h, CollectionEntry* entry) {
        if ( (entry == NULL) || (entry->value == NULL)) return false;
    /* This method allows duplicate keys - but they shouldn't be used */
    unsigned int index;
    struct HashEntry *e;
    if (++(h->count) > h->limit)
    {
        /* Ignore the return value. If expand fails, we should
         * still try cramming just this value into the existing table
         * -- we may not have memory for a larger table, but one more
         * element may be ok. Next time we insert, we'll try expanding again.*/
        hashtable_expand(h);
    }
    e = (struct HashEntry *)malloc(sizeof(struct HashEntry));
    if (NULL == e) { --(h->count); return 0; } /*oom*/
    e->hash = hash(entry->value->getHash());
    index = hash2index(h->length,e->hash);
        e->entry = entry;
    e->next = h->table[index];
    h->table[index] = e;
        entry->valuehash = e->hash;
    return true;
}

/*****************************************************************************/
CollectionEntry* hashtable_search_key(const struct HashTable *h, const Object* key) {
        if (key == NULL) return NULL;
    struct HashEntry *e;
    unsigned long hashvalue;
        unsigned int index;
    hashvalue = hash(key->getHash());
    index = hash2index(h->length,hashvalue);
    e = h->table[index];
    while (NULL != e)
    {
        /* Check hash value to short circuit heavier comparison */
        if ((hashvalue == e->hash) && (e->entry->key->equals(key)))
                        return e->entry;
        e = e->next;
    }
    return NULL;
}

CollectionEntry* hashtable_search_value(const struct HashTable *h, const Object* value) {
        if (value == NULL) return NULL;
    struct HashEntry *e;
    unsigned long hashvalue;
        unsigned int index;
    hashvalue = hash(value->getHash());
    index = hash2index(h->length,hashvalue);
    e = h->table[index];
        while (NULL != e)
    {
        /* Check hash value to short circuit heavier comparison */
                if ((hashvalue == e->hash) && (e->entry->value->equals(value))) {
                        return e->entry;
                } // return e->entry;
        e = e->next;
    }
        return NULL;
}

ObjectCollection* hashtable_search_values(const struct HashTable *h, const Object* value) {
        if (value == NULL) return NULL;
    struct HashEntry *e;
    unsigned long hashvalue;
        unsigned int index;
    hashvalue = hash(value->getHash());
    index = hash2index(h->length,hashvalue);
    e = h->table[index];
        ObjectCollection* coll = new ObjectCollection();
        coll->noDelete();
        while (NULL != e)
    {
        /* Check hash value to short circuit heavier comparison */
                if ((hashvalue == e->hash) && (e->entry->value->equals(value))) {
                        coll->add(e->entry);
                } // return e->entry;
        e = e->next;
    }
        if (coll->getCount() == 0) {
                delete(coll); coll = NULL;
        }
        return coll;
}

/*****************************************************************************/
bool hashtable_remove_key(struct HashTable *h, const CollectionEntry* entry) {
    /* TODO: consider compacting the table when the load factor drops enough,
     *       or provide a 'compact' method. */

        if (entry == NULL) return false;
    struct HashEntry *e;
    struct HashEntry **pE;
        unsigned int index;

    index = hash2index(h->length,entry->keyhash);
    pE = &(h->table[index]);
    e = *pE;
    while (NULL != e)
    {
        /* Check hash value to short circuit heavier comparison */
        if ((entry->keyhash == e->hash) && (e->entry == entry))
        {
            *pE = e->next;
            h->count--;
            free(e);
            return true;
        }
        pE = &(e->next);
        e = e->next;
    }
    return false;
}

bool hashtable_remove_value(struct HashTable *h, const CollectionEntry* entry) {
    /* TODO: consider compacting the table when the load factor drops enough,
     *       or provide a 'compact' method. */

        if (entry == NULL) return false;
    struct HashEntry *e;
    struct HashEntry **pE;
        unsigned int index;

    index = hash2index(h->length,entry->valuehash);
    pE = &(h->table[index]);
    e = *pE;
    while (NULL != e)
    {
        /* Check hash value to short circuit heavier comparison */
        if ((entry->valuehash == e->hash) && (e->entry == entry))
        {
            *pE = e->next;
            h->count--;
            free(e);
            return true;
        }
        pE = &(e->next);
        e = e->next;
    }
    return false;
}

/*****************************************************************************/
/* destroy */
void hashtable_destroy(struct HashTable *h) {
        unsigned int i;
        struct HashEntry *e, *f;
        struct HashEntry **table = h->table;
        for (i = 0; i < h->length; i++) {
                e = table[i];
                while (NULL != e) {
                        f = e;
                        e = e->next;
                        free(f);
                }
        }
        free(h->table);
        free(h);
}


} // namespace cmlabs

---