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

************************************************************************/
#include "BinaryBuffer.h"

namespace cmlabs {

// BinaryBuffer.cpp: implementation of the BinaryBuffer class.
//
//////////////////////////////////////////////////////////////////////


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

BinaryBuffer::BinaryBuffer(long size) {
        first = last = current = NULL;
        count = 0;
        buffersize = size;
        inUseTable = new ObjectCollection();
}

BinaryBuffer::~BinaryBuffer() {
        deleteAll();
        delete(inUseTable);
}




bool BinaryBuffer::addEntry(JTime stamp, JString source, JString datatype, Object* obj) {

        BinaryBufferEntry* entry;

        if (count <= buffersize) {
                entry = new BinaryBufferEntry;
                
                entry->prev = current;
                if (current != NULL)
                        current->next = entry;
                last = entry;
                if (count == buffersize) {
                        entry->next = first;
                        first->prev = entry;
                }
                else
                        entry->next = NULL;

                if (first == NULL)
                        first = last = entry;

        }
        else {
                checkInUseTable();

                entry = (BinaryBufferEntry*) current->next;
                // If entry is in use
                if (entry->inUseBy.getCount() > 0) {
                        // save entry in inUseTable
                        inUseTable->add(entry);
                        // create new entry
                        BinaryBufferEntry* newentry = new BinaryBufferEntry;
                        // and put it into structure
                        newentry->next = entry->next;
                        newentry->prev = entry->prev;
                        // now we can let go of entry
                        entry = (BinaryBufferEntry*) newentry->prev;
                        entry->next = newentry;
                        entry = (BinaryBufferEntry*) newentry->next;
                        entry->prev = newentry;
                        // and let go of newentry
                        entry = newentry;
                }
                else {
                        if (entry->object != NULL)
                                delete(entry->object);
                }
        }

        entry->count = count;
        entry->timestamp = stamp;
        entry->source = source;
        entry->datatype = datatype;
        entry->object = obj;
        entry->inUseBy.removeAll();

        current = entry;

        count++;
        
        return true;
}


BinaryBufferEntry* BinaryBuffer::getLastEntry() {
        BinaryBufferEntry* entry;
        if (mutex.EnterMutex(1000)) {
                entry = current;
                mutex.LeaveMutex();
                return entry;
        }
        else
                return NULL;
}

BinaryBufferEntry* BinaryBuffer::waitForNextEntryAfter(JTime t, long ms) {

        JTime start;
        BinaryBufferEntry* entry = getNextEntryAfter(t);

        if (entry != NULL)
                return entry;

        // We are not ready, wait for the next one

        // Tag the current one
        entry = current;

        // and look for when it changes...
        while (entry == current) {
                if (JTime() - start > ms) break;
                wait(20);
        }

        // Either we timed out or there is new data
        return getNextEntryAfter(t);
}

BinaryBufferEntry* BinaryBuffer::getNextEntryAfter(JTime t) {

        BinaryBufferEntry* entry = NULL;

        if (first == NULL)
                return NULL;

        if (current->timestamp > t) {
                // We have one newer than t, find it
                entry = (BinaryBufferEntry*) current->prev;
                while ((entry != NULL) && (entry->timestamp > t)) {
                        entry = (BinaryBufferEntry*) entry->prev;
                }

                // Now entry is either NULL (none found, return first)
                if (entry == NULL) return first;

                // or entry is the one just before t and we want the next
                entry = (BinaryBufferEntry*) entry->next;
        }
        return entry;
}


bool BinaryBuffer::reset() {
        deleteAll();
        first = last = current = NULL;
        count = 0;
        return true;
}

bool BinaryBuffer::deleteAll() {
        if (first == NULL)
                return true;

        if ((last == NULL) || (current == NULL))
                return false;

        BinaryBufferEntry* entry = first;
        while (first != NULL) {
                entry = (BinaryBufferEntry*) first->next;
                delete(first);
                // if we just deleted the last one...
                if (first == last)
                        break;
                // else continue deleting...
                first = entry;
        }

        return true;
}





// *********************************************************
// Printing
// *********************************************************

JString BinaryBuffer::print() {
        return printLast();
}

JString BinaryBuffer::printLast() {
        return print(current);
}

JString BinaryBuffer::print(BinaryBufferEntry* entry) {
        if (entry == NULL) return "No entries in buffer...";
        
        JString str;
        if (mutex.EnterMutex(1000)) {
                str += JString(current->count) + ": ";
                str += current->timestamp.printTime() + " ";
                str += current->source + " ";
                str += current->datatype;
                mutex.LeaveMutex();
                return str;
        }
        else
                return "";
}


// *********************************************************
// Housekeeping
// *********************************************************

bool BinaryBuffer::checkInUseTable() {

        BinaryBufferEntry* entry;
        
        int c = inUseTable->getCount();

        if (c == 0)     return true;

        for (int n=0; n<c; n++) {
                entry = (BinaryBufferEntry*) inUseTable->get(n);
                if (entry != NULL) {
                        if (entry->inUseBy.getCount() == 0) {
                        //      delete(entry);
                                inUseTable->remove(n);
                                n--;
                        }
                }
        }

        return true;
}





} // namespace cmlabs

---