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

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

#include "DataSample.h"


namespace cmlabs {

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

DataSample::DataSample(const JString& type, const JString& samplename) {
        id = createUniqueID();
        this->type = type;
        name = samplename;
        data = link = NULL;
        size = 0;
        width = height = 0;
        duration = 0;
        object = NULL;
        aux = NULL;
        markedForDeletion = false;
        sortfield = 0;
        channels = NULL;
}

DataSample::DataSample(XMLNode* node) {
        id = createUniqueID();
        data = link = NULL;
        size = 0;
        width = height = 0;
        duration = 0;
        object = NULL;
        aux = NULL;
        markedForDeletion = false;
        sortfield = 0;
        channels = NULL;
        fromXML(node);
}

DataSample::~DataSample() {
        markForDeletion();
        // printf("Sample %s is being deleted\n", (char*) print());
        if (data != NULL)
                delete [] data;
        data = NULL;
        if (object != NULL)
                delete(object);
        object = NULL;
        if (aux != NULL)
                delete(aux);
        aux = NULL;

        params.removeAll();
        link = NULL;
        size = 0;
        width = 0;
        height = 0;
}

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


bool DataSample::equals( const DataSample &s2 ) const {
   return ( this->sortfield == s2.sortfield );
}

int DataSample::compare(const Object* o2) const {
        if ((o2 == NULL) || (!isSameClass(o2)))
                return 0;
        return compareTo(*(DataSample*) o2);
}

int DataSample::compareTo( const DataSample &s2 ) const {
        if (this->sortfield == s2.sortfield)
                return 0;
        return (this->sortfield > s2.sortfield ? 1 : -1);
}

JString DataSample::getType() {
        return type;
}

bool DataSample::setType(const JString& type) {
        this->type = type;
        return true;
}

//! Get total size of payload
unsigned long DataSample::getPayloadSize() const {
        long payloadSize = id.length() + name.length() + type.length() + size +
                timestamp.getPayloadSize() + params.getPayloadSize();

        if (channels != NULL) payloadSize += channels->getPayloadSize();
        if (object != NULL) payloadSize += object->getPayloadSize();
        if (aux != NULL) payloadSize += aux->getPayloadSize();

        return payloadSize;
}

Object* DataSample::clone() const {
        DataSample* sample = new DataSample();
        sample->name = name;
        sample->id = id;
        sample->type = type;
        sample->width = width;
        sample->height = height;
        sample->timestamp = timestamp;
        sample->params.copyAll(params);
        if (data != NULL)
                sample->setDataCopy(data, size, duration);
        if (object != NULL) {
                sample->setObject(object->clone());
                sample->setDuration(duration);
        }
        return (Object*) sample;
}

DataSample* DataSample::cloneWithoutData() {
        DataSample* sample = new DataSample();
        sample->name = name;
        sample->timestamp = timestamp;
        sample->params.copyAll(params);
        sample->width = width;
        sample->height = height;
        sample->size = size;
        sample->duration = duration;
        return sample;
}

JString DataSample::print() {
        if (object != NULL)
                return JString::format("%s: Object: %s  %s", (char*) name, (char*) object->getClass(), (char*) timestamp.print());
        else
                return JString::format("%s: %d bytes  %s", (char*) name, getDataSize(), (char*) timestamp.print());
}


bool DataSample::clearDataFields() {
        data = link = NULL;
        size = 0;
        if (object != NULL)
                delete(object);
        object = NULL;
        return true;
}

bool DataSample::isLocked() {
        return (lockedBy.length() > 0);
}

bool DataSample::lockBy(const JString& locker) {
        if (isLocked())
                return false;
        lockedBy = locker;
        return true;
}

bool DataSample::isInUse() {
        if (users.getCount() == 0)
                return false;
        
        Collection removes;
        JTime* t;
        JTime now;
        int n;
        for (n=0; n<users.getCount(); n++) {
                if ( (t = (JTime*) users.get(n)) != NULL ) {
                        if (t->microDifference(now) < 0) {
                                removes.add(users.getKey(n));
                        }
                }
        }
        for (n=0; n<removes.getCount(); n++) {
        //      printf("Removing user %s from inUseBy", (char*) removes.get(n));
                users.remove(removes.get(n));
        }
        // printf(" - %d users left: \n\t%s\n", users.getCount(), (char*) users.printListLine("\n\t"));
        if (users.getCount() > 0) {
                // printf("Sample %s in use by %d users until: %s\n", (char*) print(), users.getCount(), (char*)((JTime*)users.get(0))->printTime());
                // printf("Sample %s in use until: %s\n", (char*) print(), (char*)((JTime*)users.get(0))->printTime());
                return true;
        }
        else
                return false;
}

bool DataSample::setInUseBy(const JString& user, int timeout) {
        JTime t;
        if (timeout > 0)
                t = t + timeout;
        else
                t = t + 1000*20;
        users.put(user, t.clone());

//      printf("setInUse[%d]: Now %d users: \n\t%s\n", (int) this, users.getCount(), (char*) users.printListLine("\n\t"));

        return true;
}

bool DataSample::removeInUseBy(const JString& user) {
        return users.remove(user);
}


JString DataSample::getName() {
        return name;
}

JTime DataSample::getTimestamp() {
        return timestamp;
}

JTime DataSample::getStartTime() {
        return timestamp;
}

JTime DataSample::getEndTime() {
        return (timestamp + duration);
}

Dictionary DataSample::getAllParameters() {
        return params;
}

long DataSample::getDataMemUse() {
        if (link != NULL)
                return 0;
        else
                return size;
}

long DataSample::getDataSize() {
        return size;
}

char* DataSample::getDataLink() {
        if (size <= 0)
                return NULL;
        if (link != NULL)
                return link;
        else
                return data;
}

char* DataSample::getDataCopy() {
        char* dat = getDataLink();
        if (dat == NULL)
                return NULL;
        char* copy = new char[size];
        memcpy(copy, dat, size);
        return copy;
}


JString DataSample::getParam(const JString& param) {
        return params.get(param);
}


int DataSample::getParamInt(const JString& param) {
        return params.get(param).toInt();
}

double DataSample::getParamFloat(const JString& param) {
        return params.get(param).toDouble();
}












bool DataSample::setParam(const JString& param, const JString& value) {
        return params.put(param, value);
}

bool DataSample::setParamInt(const JString& param, int value) {
        return params.put(param, JString(value));
}

bool DataSample::setParamFloat(const JString& param, double value) {
        return params.put(param, JString(value));
}

bool DataSample::setTimestamp(const JTime& time) {
        timestamp = time;
        return true;
}

bool DataSample::setParameters(Dictionary& dict) {
        return params.copyAll(dict);
}

bool DataSample::giveData(char* sampledata, long datasize, long durationMS) {
        if ( (datasize <= 0) || (sampledata == NULL) )
                return false;

        if (data != NULL)
                delete [] data;
        data = NULL;
        if (object != NULL)
                delete(object);
        object = NULL;

        size = datasize;
        data = sampledata;
        link = NULL;
        duration = durationMS;
        return true;
}

bool DataSample::setDataCopy(char* sampledata, long datasize, long durationMS) {
        if ( (datasize <= 0) || (sampledata == NULL) )
                return false;

        if (data != NULL)
                delete [] data;
        data = NULL;
        if (object != NULL)
                delete(object);
        object = NULL;

        char* copy = new char[datasize];
        memcpy(copy, sampledata, datasize);
        return giveData(copy, datasize, durationMS);
}

bool DataSample::setDataLink(char* sampledata, long datasize, long durationMS) {
        if ( (datasize <= 0) || (sampledata == NULL) )
                return false;

        if (data != NULL)
                delete [] data;
        data = NULL;
        if (object != NULL)
                delete(object);
        object = NULL;

        size = datasize;
        link = sampledata;
        data = NULL;
        duration = durationMS;
        return true;
}

long DataSample::getDuration() {
        return duration;
}

bool DataSample::setDuration(long durationMS) {
        duration = durationMS;
        return true;
}

int DataSample::getWidth() {
        return width;
}

int DataSample::getHeight() {
        return height;
}

bool DataSample::setWidth(int w) {
        width = w;
        return true;
}

bool DataSample::setHeight(int h) {
        height = h;
        return true;
}


Object* DataSample::getObject() {
        return object;
}

bool DataSample::setObject(Object* obj) {
        if (object != NULL)
                delete(object);
        if (data != NULL)
                delete [] data;
        data = NULL;
        link = NULL;
        size = 0;
        object = obj;
        type = "Object";
        return true;
}


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


//! Get the size of any binary data
long DataSample::getBinarySize(int chunk) {

        if (chunk > 0) {
                if (object != NULL)
                        return object->getBinarySize(chunk-1);
                else
                        return 0;
        }

        params.put("builtin:id", id);
        params.put("builtin:type", type);
        params.put("builtin:duration", JString(duration));
        params.put("builtin:timestamp", timestamp.asText());
        params.put("builtin:name", name);
        params.put("builtin:width", JString(width));
        params.put("builtin:height", JString(height));
        JString extra = params.printListLine("%sep%", "%equals%");

        long objectSize = 0;
        if (object != NULL)
                objectSize = object->toXML().length()+1;
        return (4 + size + extra.length()+1 + objectSize);

        //      return (4 + size + extra.length()+1);
        //else {
        //      return (4 + size + extra.length()+1);
        //}
        //return (4 + object->toXML().length()+1 + extra.length()+1);
}

//! Get the number of data chunks
int DataSample::getBinaryChunkCount() {
        if (object != NULL)
                return 1 + object->getBinaryChunkCount();
        else
                return 1;
}

long DataSample::toBinaryBuffer(int chunk, char* buffer, int maxlen) {

        if (chunk > 0) {
                if (object != NULL)
                        return object->toBinaryBuffer(chunk-1, buffer, maxlen);
                else
                        return 0;
        }

        params.put("builtin:id", id);
        params.put("builtin:type", type);
        params.put("builtin:duration", JString(duration));
        params.put("builtin:timestamp", timestamp.asText());
        params.put("builtin:name", name);
        params.put("builtin:width", JString(width));
        params.put("builtin:height", JString(height));

        JString extra = params.printListLine("%sep%", "%equals%");

        char* ptr;
        JString xml;
        if (object != NULL) {
                xml = object->toXML();
                size = xml.length() + 1;
                ptr = (char*) xml;
        }
        else
                ptr = getDataLink();

        long len = 4 + size + extra.length()+1;
        if (len > maxlen)
                return 0;

        writeLongToBytes(buffer, size);
        
        if ((ptr != NULL) && (size > 0))
                memcpy(buffer+4, ptr, size);
        memcpy(buffer+4+size, extra.charpoint(), extra.length()+1);

        if (object != NULL) {
                size = 0;
        }

        return len;
}

bool DataSample::fromBinaryBuffer(int chunk, char* buffer, long len) {

        if (chunk > 0) {
                if (object != NULL)
                        return object->fromBinaryBuffer(chunk-1, buffer, len);
                else
                        return false;
        }

        if ((buffer == NULL) || (len <= 0))
                return false;

        long binsize = getLongFromBytes(buffer);

        JString extra = (char*)(buffer + 4 + binsize);
        if (extra.length() == 0)
                return false;
        params = extra.split("%sep%", "%equals%");
        if (params.getCount() < 3)
                return false;

        long dur = params.get("builtin:duration").toLong();
        timestamp = JTime(params.get("builtin:timestamp"));
        id = params.get("builtin:id");
        type = params.get("builtin:type");
        name = params.get("builtin:name");
        width = params.get("builtin:width").toInt();
        height = params.get("builtin:height").toInt();
        params.remove("builtin:duration");
        params.remove("builtin:timestamp");
        params.remove("builtin:id");
        params.remove("builtin:type");
        params.remove("builtin:name");
        params.remove("builtin:width");
        params.remove("builtin:height");

        if (binsize > 0)
                if (type.equalsIgnoreCase("Object")) {
                        JString xml = (char*)(buffer + 4);
                        duration = dur;
                        return (this->setObject(Object::createObjectFromXML(xml)));
                }
                else
                        return (this->setDataCopy(buffer + 4, binsize, dur));
        else {
                duration = dur;
                return true;
        }
}




long DataSample::getLongFromBytes(char* buffer) {
        long val = ( (unsigned char) buffer[0] + ( (unsigned char) buffer[1] << 8) + ( (unsigned char) buffer[2] << 16) + ( (unsigned char) buffer[3] << 24) );
//      long val2 = *((long*) (buffer));

        return val;
}

bool DataSample::writeLongToBytes(char* buffer, long val) {
        buffer[0] = (unsigned char) val;
        buffer[1] = (unsigned char) (val >> 8);
        buffer[2] = (unsigned char) (val >> 16);
        buffer[3] = (unsigned char) (val >> 24);
        return true;
}




bool DataSample::readFromFile(const JString& filename) {
        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL)
                return false;
        this->giveData(dat, len);
        return true;
}

bool DataSample::writeToFile(const JString& filename) {
        if ( (data == NULL) || (size <= 0) )
                return false;
        return JFile::writeAFileBinary(filename, this->data, this->size);
}



bool DataSample::markForDeletion() {
        markedForDeletion = true;
        if (channels != NULL) {
                channels->removeAllNoDelete();
                delete(channels);
                channels = NULL;
        }
        return true;
}

bool DataSample::isMarkedForDeletion() {
        return markedForDeletion;
}





















HTMLPage* DataSample::toHTMLBitmap() {
        return NULL;
}

JString DataSample::toHTML() {
        return JString::format("DataSample size %d bytes, time %s", size, (char*) timestamp.print());
}


JString DataSample::toXML() {
        return "<datasample />";
//      return JString::format("<datasample name=\"%s\" size=\"%s\" duration=\"%s\">\n%s%s</datasample>",
//              (char*)name, (char*)JString(size), (char*)JString(duration), (char*) timestamp.toXML().indentXML(), (char*)params.toXML().indentXML());
}

bool DataSample::fromXML(XMLNode* node) {

        if (node == NULL)
                return false;

        if (!node->getTag().equalsIgnoreCase("datasample"))
                return false;

/*      name = node->getAttribute("name");
        size = node->getAttribute("size").toLong();
        duration = node->getAttribute("duration").toLong();

        ObjectCollection col = node->getChildTags();

        XMLNode* entry;
        JString key;

        for (int n=0; n<col.getCount(); n++) {
                entry = (XMLNode*) col.get(n);
                if (entry->getTag().equalsIgnoreCase("time")) {
                        timestamp = JTime(entry);
                }
                else if (entry->getTag().equalsIgnoreCase("collection")) {
                        params = Dictionary(entry);
                }
                else if (entry->getTag().equalsIgnoreCase("collection")) {
                        params = Dictionary(entry);
                }
        }
*/
        return true;    
}


bool DataSample::unitTest() {

        // Test to and from Binary Buffer using collections
        ObjectDictionary* mainCol = new ObjectDictionary();

        DataSample* sample;
        ObjectDictionary* subCol;
        char* data;
        int len = 100;
        int nMax = 3;
        int mMax = 3;
        Collection expectedSizes;
        // create N sub collection
        for (int n=0; n<nMax; n++) {
                subCol = new ObjectDictionary();
                // add M samples to it
                for (int m=0; m<mMax; m++) {
                        data = new char[len*(m+1)];
                        memset(data, m, len);
                        sample = new DataSample();
                        sample->giveData(data, len);
                        expectedSizes.add(JString(sample->getBinarySize(0)));
                        subCol->put(JString(m), sample);
                }
                mainCol->put(JString(n), subCol);
        }

        int chunks = mainCol->getBinaryChunkCount();
        if (chunks != nMax * mMax) {
                this->addUnitTestLog(JString::format("Collection::getBinaryChunkCount() should be %d, was %d!", nMax * mMax, chunks));
                return false;
        }

        long size, totalSize = 0;
        for (int e=0; e<expectedSizes.getCount(); e++) {
                size = mainCol->getBinarySize(e);
                if (size != expectedSizes.get(e).toLong()) {
                        this->addUnitTestLog(JString::format("Collection::getBinarySize(%d) should be %ld, was %ld!",
                                e, expectedSizes.get(e).toLong(), size));
                        return false;
                }
                totalSize += size;
        }

        int c;
        long pos = 0, delta;
        data = new char[totalSize];
        for (c=0; c<chunks; c++) {
                delta = mainCol->toBinaryBuffer(c, data+pos, expectedSizes.get(c).toLong());
                pos += delta;
        }

        if (pos != totalSize) {
                this->addUnitTestLog(JString::format("Collection::toBinaryBuffer() should be %ld, was %ld!",
                        totalSize, pos));
                return false;
        }

        JString xml = mainCol->toXML();

        ObjectDictionary* copyCol = new ObjectDictionary(xml);

        int copyChunks = mainCol->getBinaryChunkCount();
        if (copyChunks != nMax * mMax) {
                this->addUnitTestLog(JString::format("Copy of Collection::getBinaryChunkCount() should be %d, was %d!", nMax * mMax, copyChunks));
                return false;
        }

        pos = 0;
        for (c=0; c<copyChunks; c++) {
                if (!copyCol->fromBinaryBuffer(c, data+pos, expectedSizes.get(c).toLong())) {
                        this->addUnitTestLog(JString::format("Collection::fromBinaryBuffer(%d) failed!", c));
                        return false;
                }
                pos += expectedSizes.get(c).toLong();
        }

        c = 0;
        for (int nn=0; nn<nMax; nn++) {
                if ( (subCol = (ObjectDictionary*)copyCol->get(nn)) == NULL) {
                        this->addUnitTestLog(JString::format("Copy Collection did not contain subCol %d!", nn));
                        return false;
                }
                if (subCol->getCount() != mMax) {
                        this->addUnitTestLog(JString::format("Copy Sub Collection %d had count %, should have been %d!", nn, subCol->getCount(), mMax));
                        return false;
                }
                // add M samples to it
                for (int mm=0; mm<mMax; mm++) {
                        if ( (sample = (DataSample*) subCol->get(mm)) == NULL) {
                                this->addUnitTestLog(JString::format("Copy Sub Collection %d did not contain sample %d!", nn, mm));
                                return false;
                        }

                        if (sample->data == NULL) {
                                this->addUnitTestLog(JString::format("Copy Sub Collection %d sample %d has no data!", nn, mm));
                                return false;
                        }

                        long binsize = sample->getBinarySize(0);
                        if (binsize != expectedSizes.get(c).toLong()) {
                                this->addUnitTestLog(JString::format("Copy Sub Collection %d sample %d had size %ld, should have been %ld!", nn, mm, binsize, expectedSizes.get(c).toLong()));
                                return false;
                        }
                        c++;
                }
        }
        
        delete(mainCol);
        delete(subCol);
        delete [] data;

        return true;
}


} // namespace cmlabs

---