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

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

#include "TimeSeries.h"

namespace cmlabs {

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

TimeSeries::TimeSeries()
{
}

TimeSeries::~TimeSeries()
{
        removeAll();
}

TimeSeries::TimeSeries(const TimeSeries &ts) {
        times.addAll(ts.times);
        dict.copyAll(ts.dict);
}

const TimeSeries& TimeSeries::operator = (const TimeSeries& ts) {
        times.addAll(ts.times);
        dict.copyAll(ts.dict);
        return *this;
}

TimeSeries::TimeSeries(const JString& xml) {
        dict.fromXML(xml);
}

TimeSeries::TimeSeries(XMLNode* node) {
        dict.fromXML(node);
}

Object* TimeSeries::clone() const {
        TimeSeries* ts = new TimeSeries();
        ts->times.addAll(times);
        ts->dict.copyAll(dict);
/*      Object* obj;
        for (int n=0; n<getCount(); n++) {
                obj = get(n);
                if (obj != NULL)
                        ts->put(getTime(n), obj->clone());
        }*/
        return ts;
}

//! Get total size of payload
unsigned long TimeSeries::getPayloadSize() const {
        return times.getPayloadSize() + dict.getPayloadSize();
}


int TimeSeries::getCount() {
        return dict.getCount();
}


bool TimeSeries::contains(const JTime& time) {
        JString key = time.asText();
        return(dict.get(key) != NULL);
}


JTime TimeSeries::getTime(int pos) {
        JTime t;
        JString str = times.get(pos);
        str.replace("x", "");
        if (str.length() > 0)
                t = JTime(str);
        else
                t.setInvalid();
        return t;
}

Object* TimeSeries::get(int pos) {
        return dict.get(pos);
}

Object* TimeSeries::get(const JTime& time) {
        JString key = time.asText();
        return dict.get(key);
}

Object* TimeSeries::getOldest() {
        return dict.get(0);
}

Object* TimeSeries::getNewest() {
        return dict.get(dict.getCount()-1);
}

Object* TimeSeries::getFirstAfter(const JTime& time) {
        return dict.get(times.getFirstAfter(time.asText()));
}

Object* TimeSeries::getLastBefore(const JTime& time) {
        return dict.get(times.getLastBefore(time.asText()));
}


bool TimeSeries::put(const JTime& time, Object* obj) {
        JString key = time.asText();
        while (dict.contains(key)) {
                key += "x";
        }

        int pos = times.addAndReturnPosition(key);

        if (pos >= 0) {
                if (!dict.putAfter(pos, key, obj)) {
                        times.remove(pos);
                        return false;
                }
//              printf("Putting TimeSeries: '%s'\n%s\n\n", (char*) key, (char*) this->print());
                return true;
        }
        else
                return false;
}

bool TimeSeries::remove(const JTime& time) {
        JString key = time.asText();
        while (dict.contains(key)) {
                dict.remove(key);
                times.remove(key);
                key += "x";
        }
        return true;
}

bool TimeSeries::removeOldest() {
        JString key = times.getFirst();
        if (key.length() > 0) {
                dict.remove(key);
                times.remove(key);
                return true;
        }
        else
                return false;
}

bool TimeSeries::removeNewest() {
        JString key = times.getLast();
        if (key.length() > 0) {
                dict.remove(key);
                times.remove(key);
                return true;
        }
        else
                return false;
}

bool TimeSeries::removeAllBetween(const JTime& t1, const JTime& t2) {
        Collection col = times.getAllBetween(t1.asText(), t2.asText());
        for (int n=0; n<col.getCount(); n++) {
                times.remove(col.get(n));
                dict.remove(col.get(n));
        }
        return true;
}

bool TimeSeries::removeAllBefore(const JTime& time) {
        Collection col = times.getAllBetween("", time.asText());
        for (int n=0; n<col.getCount(); n++) {
                times.remove(col.get(n));
                dict.remove(col.get(n));
        }
        return true;
}

bool TimeSeries::removeAllAfter(const JTime& time) {
        Collection col = times.getAllBetween(time.asText(), "99999999999999999999999999999");
        for (int n=0; n<col.getCount(); n++) {
                times.remove(col.get(n));
                dict.remove(col.get(n));
        }
        return true;
}

ObjectCollection* TimeSeries::getAllBetween(const JTime& t1, const JTime& t2) {
        ObjectCollection* retCol = new ObjectCollection();      
        // If more entries with same time is added, the code above adds N*"x" as needed
        // When we compare with t2+"z" all t+"xxxxxxx...." will be matched as well
        Collection col = times.getAllBetween(t1.asText(), t2.asText()+"z");
        for (int n=0; n<col.getCount(); n++) {
                // printf("Found: %s\n", (char*) col.get(n));
                retCol->add(dict.get(col.get(n)));
        }
        if (retCol->getCount() == 0) {
                delete(retCol);
                return NULL;
        }
        return retCol;
}

ObjectCollection* TimeSeries::getAllBefore(const JTime& time) {
        ObjectCollection* retCol = new ObjectCollection();      
        Collection col = times.getAllBetween("", time.asText());
        for (int n=0; n<col.getCount(); n++) {
                retCol->add(dict.get(col.get(0)));
        }
        if (retCol->getCount() == 0) {
                delete(retCol);
                return NULL;
        }
        return retCol;
}

ObjectCollection* TimeSeries::getAllAfter(const JTime& time) {
        ObjectCollection* retCol = new ObjectCollection();      
        Collection col = times.getAllBetween(time.asText(), "");
        for (int n=0; n<col.getCount(); n++) {
                retCol->add(dict.get(col.get(0)));
        }
        if (retCol->getCount() == 0) {
                delete(retCol);
                return NULL;
        }
        return retCol;
}

bool TimeSeries::removeAll() {
//      printf("Removing TimeSeries: \n%s\n\n", (char*) this->print());
//      printf("\n\t%s\n", (char*) times.printListLine("\n\t"));
//      printf("\n\t%s\n", (char*) dict.printListLine("\n\t"));
        dict.removeAll();
        times.removeAll();
        return true;
}


JTime TimeSeries::getFirstTime() {
        JTime t;
        JString str = times.getFirst();
        str.replace("x", "");
        if (str.length() > 0)
                t = JTime(str);
        else
                t.setInvalid();
        return t;
}

JTime TimeSeries::getLastTime() {
        JTime t;
        JString str = times.getLast();
        str.replace("x", "");
        if (str.length() > 0)
                t = JTime(str);
        else
                t.setInvalid();
        return t;
}

JTime TimeSeries::getNextTime() {
        JTime t;
        JString str = times.getNext();
        str.replace("x", "");
        if (str.length() > 0)
                t = JTime(str);
        else
                t.setInvalid();
        return t;
}

JTime TimeSeries::getPreviousTime() {
        JTime t;
        JString str = times.getPrevious();
        str.replace("x", "");
        if (str.length() > 0)
                t = JTime(str);
        else
                t.setInvalid();
        return t;
}





JString TimeSeries::print() {

        JString res, str;
        JTime t;

        if (times.getCount() != dict.getCount())
                res += JString::format("TimeSeries broken with %d and %d entries...\n", times.getCount(), dict.getCount());

        Object* obj;
        for (int n=0; n<this->times.getCount(); n++) {
                str = times.get(n);
                str.replace("x", "");
                t = JTime(str);
                obj = dict.get(n);
                if (obj != NULL) {
                        res += JString::format("%s: %s = %s\n", (char*) JString(JString(n), 5, 1), (char*) t.print(), (char*) obj->print());
                }
                else {
                        res += JString::format("%s: %s = null\n", (char*) JString(JString(n), 5, 1), (char*) t.print());
                }
        }

        return res;
}


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


//! Get the size of any binary data
long TimeSeries::getBinarySize(int chunk) {
        return dict.getBinarySize(chunk);
}

//! Get the number of data chunks
int TimeSeries::getBinaryChunkCount() {
        return dict.getBinaryChunkCount();
}

//! Get a pointer to the binary data at chunk number 'chunk'
long TimeSeries::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        return dict.toBinaryBuffer(chunk, buffer, maxlen);
}

//! Set the data after separate reception
bool TimeSeries::fromBinaryBuffer(int chunk, char* buffer, long len) {
        return dict.fromBinaryBuffer(chunk, buffer, len);
}





bool TimeSeries::unitTest() {

//      try {
//      }
//      catch(...) {
//              return false;
//      }
        return true;
}



} // namespace cmlabs

---