InfoItem.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 "InfoItem.h"

namespace cmlabs {

InfoItem::InfoItem() {
        object = NULL;
        setID(createUniqueID());
}

InfoItem::InfoItem(const JString& xml) {
        object = NULL;
        setID(createUniqueID());
        if (!Object::fromXML(xml)) {
        }
}

InfoItem::InfoItem(XMLNode* node) {
        object = NULL;
        setID(createUniqueID());
        if (!fromXML(node)) {
        }
}

InfoItem::InfoItem(const InfoItem &item) {

        id = item.id;
        createdTime = item.createdTime;

        auxDict.copyAll(item.auxDict);
        timeDict.copyAll(item.timeDict);

        if (item.object != NULL) {
                object = item.object->clone();
        }
        else
                object = NULL;
}

        JString id;
        JTime createdTime;
        //! Dictionary of generic text entries
        Dictionary auxDict;
        //! Dictionary of Timestamps
        ObjectDictionary timeDict;
        Object* object;

//! Get total size of payload
unsigned long InfoItem::getPayloadSize() const {
        unsigned long payloadSize = id.getPayloadSize() + createdTime.getPayloadSize() + auxDict.getPayloadSize();
        if (object != NULL) payloadSize += object->getPayloadSize();
        return payloadSize;
}

InfoItem& InfoItem::operator=(const InfoItem &item) {

        id = item.id;
        createdTime = item.createdTime;

        auxDict.copyAll(item.auxDict);
        timeDict.copyAll(item.timeDict);

        if (item.object != NULL) {
                object = item.object->clone();
        }
        else
                object = NULL;
        return *this;
}


InfoItem::~InfoItem() {
        if (object != NULL)
                delete(object);
}

Object* InfoItem::clone() const {
        InfoItem* item = new InfoItem();
        item->id = id;
        item->createdTime = createdTime;

        item->auxDict.copyAll(auxDict);
        item->timeDict.copyAll(timeDict);

        if (object != NULL) {
                item->object = object->clone();
        }
        else
                item->object = NULL;
        return (Object*) item;
}

InfoItem* InfoItem::cloneDataOnly() const {
        InfoItem* item = new InfoItem();

        item->auxDict.copyAll(auxDict);
        item->timeDict.copyAll(timeDict);

        if (object != NULL) {
                item->object = object->clone();
        }
        else
                item->object = NULL;
        return item;
}

bool InfoItem::fromXML(XMLNode* node) {

        if (node == NULL) {
                return false;
        }

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

        id = node->getAttribute("id");

        JString tag, value;
        XMLNode* xmlNode;
        XMLNode* subNode;
        ObjectCollection* nodes = node->getChildTags();

        if (nodes != NULL) {
                for (int n=0; n<nodes->getCount(); n++) {
                        xmlNode = (XMLNode*) nodes->get(n);
                        if (xmlNode != NULL) {
                                tag = xmlNode->getTag();
                                value = xmlNode->getText();
                                subNode = (XMLNode*) xmlNode->getFirstChildNode();

                                if (tag.equalsIgnoreCase("object")) {
                                        setObject(createObjectFromXML(subNode));
                                }
                                else if (tag.equalsIgnoreCase("createdtime")) {
                                        createdTime = JTime(xmlNode);
                                }
                                else if ( xmlNode->hasAttribute("sec") ) {
                                        setTime(xmlNode->getAttribute("name"), JTime(xmlNode));
                                }
                                else if (tag.equalsIgnoreCase("entry")) {
                                        setEntry(xmlNode->getAttribute("name"), value);
                                }
                        }
                }
        }

        return true;
}


JString InfoItem::toXML() {

        JString xml = createdTime.toXML("createdtime") + "\n";

        if (object != NULL) {
                xml += JString::format("<object>\n%s</object>\n", (char*)object->toXML().indentXML());
        }

        JString key, value;
        int n;
        for (n = 0; n < auxDict.getCount(); n++) {
                key = auxDict.getKey(n);
                value = auxDict.get(n);
                if (key.length() > 0) {
                        xml += JString::format("<entry name=\"%s\">%s</entry>\n", (char*)key.xmlStringEncode(), (char*)value.xmlStringEncode());
                }
      }

        JTime* time;
        for (n = 0; n < timeDict.getCount(); n++) {
                key = timeDict.getKey(n);
                time = (JTime*) timeDict.get(n);
                if ( (time != NULL) && (key.length() > 0)) {
                        xml += time->toXML("time", JString::format("name=\"%s\"", (char*) key)) + "\n";
                }
        }

        return JString::format("<infoitem id=\"%s\">\n%s</infoitem>", (char*) id, (char*) xml.indentXML());
}



JString InfoItem::print() {
        return printShort();
}

JString InfoItem::printShort() {

        JString message = JString::format("InfoItem:\n   ID: %s\n   Created: %s\n",
                (char*) id, (char*) createdTime.print());

        JString key, value;
        int n;
        for (n=0; n<auxDict.getCount(); n++) {
                key = auxDict.getKey(n);
                value = auxDict.get(n);
                if (key.length() > 0) {
                        message = JString::format("%s   %s: %s\n",
                                (char*)message, (char*) key, (char*) value);
                }
        }

        JTime* time;
        for (n=0; n<timeDict.getCount(); n++) {
                key = timeDict.getKey(n);
                time = (JTime*) timeDict.get(n);
                if ((key.length() > 0) && (time != NULL)) {
                        message = JString::format("%s   %s: %s\n",
                                (char*)message, (char*) key, (char*) time->print());
                }
        }

        return message;
}

JString InfoItem::toHTML() {
        return printHTML("");
}

JString InfoItem::printHTML(JString htmlTemplate) {
        JString html;

        if (htmlTemplate.length() == 0) {
                htmlTemplate = "\
<table border=\"0\">\
<!-- start:InfoItem -->\
        <tr><td class=\"InfoItemKey\">%1</td><td class=\"InfoItemValue\">%2</td></tr>\
<!-- end:InfoItem -->\
</table>";
        }

        ObjectCollection* col = new ObjectCollection();
        Collection* lines;
        int n;
        JString key, value;
        for (n=0; n<auxDict.getCount(); n++) {
                key = auxDict.getKey(n);
                value = auxDict.get(n);
                if (key.length() > 0) {
                        lines = new Collection();
                        lines->add(key.toHTML());
                        lines->add(value.toHTML());
                        col->add(lines);
                }
        }

        JTime* time;
        for (n=0; n<timeDict.getCount(); n++) {
                key = timeDict.getKey(n);
                time = (JTime*) timeDict.get(n);
                if ((key.length() > 0) && (time != NULL)) {
                        lines = new Collection();
                        lines->add(key.toHTML());
                        if (time->isValid())
                                lines->add(time->print().toHTML());
                        else
                                lines->add("n/a");
                        col->add(lines);
                }
        }

        if (object != NULL) {
                lines = new Collection();
                lines->add("Object");
                lines->add(object->print().toHTML());
                col->add(lines);
        }

        htmlTemplate.scriptReplace("InfoItem", col);
        delete(col);

        return htmlTemplate;
}


bool InfoItem::setEntry(const JString& name, const JString& value) {
//      JString lname = name.toLowerCase();
//      return auxDict.put(lname, value);
        return auxDict.put(name, value);
}


JString InfoItem::getEntry(const JString& name) {
//      JString lname = name.toLowerCase();
//      return auxDict.get(lname);
        return auxDict.getIgnoreCase(name);
}

bool InfoItem::setTime(const JString& name, const JTime& t) {
//      JString lname = name.toLowerCase();
        JTime* tt = new JTime();
        *tt = t;
        timeDict.put(name, tt);
        return true;
}

JTime InfoItem::getTime(const JString& name) {
//      JString lname = name.toLowerCase();
        JTime* t = (JTime*) timeDict.getIgnoreCase(name);
        if (t != NULL)
                return *t;
        JTime tt;
        tt.setInvalid();
        return tt;
}











bool InfoItem::setObject(Object* obj) {
        deleteObject();
        object = obj;
        return true;
}

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

JString InfoItem::getObjectType() {
        if (object != NULL)
                return object->getClass();
        return "";
}

bool InfoItem::deleteObject() {
        if (object == NULL)
                return true;
        delete(object);
        object = NULL;
        return true;
}

Object* InfoItem::takeObject() {
        Object* obj = object;
        object = NULL;
        return obj;
}

JString InfoItem::getID() {
        return id;
}

JTime InfoItem::getCreatedTime() {
        return createdTime;
}

bool InfoItem::setID(const JString& iD) {
        id = iD;
        return true;
}

bool InfoItem::setCreatedTime(const JTime& t) {
        createdTime = t;
        return true;
}


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


//! Get the size of any binary data
long InfoItem::getBinarySize(int chunk) {
        if (object == NULL)
                return 0;
        return object->getBinarySize(chunk);
}

//! Get the number of data chunks
int InfoItem::getBinaryChunkCount() {
        if (object == NULL)
                return 0;
        return object->getBinaryChunkCount();
}

//! Get a pointer to the binary data at chunk number 'chunk'
long InfoItem::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        if (object == NULL)
                return false;
        return object->toBinaryBuffer(chunk, buffer, maxlen);
}

//! Set the data after separate reception
bool InfoItem::fromBinaryBuffer(int chunk, char* buffer, long len) {
        if (object == NULL)
                return false;
        return object->fromBinaryBuffer(chunk, buffer, len);
}





// ***************************************************************
// File Functions
// ***************************************************************

bool InfoItem::loadFromFile(const JString& filename) {
        JString xml = JFile::readAFileASCII(filename);
        if (xml.length() == 0)
                return false;
        if (!Object::fromXML(xml))
                return false;

        JString binfile;
        long binsize = 0;
        char* buffer = NULL;
        int bufferlen = 0;

        JString binaryFilesXML = this->getEntry("BinaryFiles");
        if (binaryFilesXML.length() == 0)
                return true;

        Dictionary binaryFiles;
        if (!binaryFiles.fromXML(binaryFilesXML))
                return false;
        
        if (binaryFiles.getCount() > 0) {
                for (int n=0; n<binaryFiles.getCount(); n++) {
                        if ( (binfile = binaryFiles.getKey(n)).length() > 0) {
                                if ( (binsize = binaryFiles.get(n).toLong()) > 0 )      {
                                        buffer = JFile::readAFileBinary(binfile, bufferlen);
                                        if (buffer != NULL) {
                                                if (bufferlen != binsize) {
                                                        // Maybe print an error...
                                                }
                                                this->fromBinaryBuffer(n, buffer, bufferlen);
                                                delete [] buffer;
                                                buffer = NULL;
                                                bufferlen = 0;
                                        }
                                }
                        }
                }
        }
        return true;
}

bool InfoItem::writeToFile(const JString& filename) {

        JString binfile;
        char* buffer = NULL;
        long bufferlen = 0;
        int bincount = this->getBinaryChunkCount();

        Collection files;
        files.add(filename);
        Dictionary binaryFiles;
        if (bincount > 0) {
                for (int n=0; n<bincount; n++) {
                        binfile = JString::format("%s.%.6d.bin", (char*) filename, n);
                        bufferlen = this->getBinarySize(n);
                        if (bufferlen <= 0) {
                                bufferlen = 0;
                        }
                        else {
                                buffer = new char[bufferlen];
                                this->toBinaryBuffer(n, buffer, bufferlen);
                                if (JFile::writeAFileBinary(binfile, buffer, bufferlen))
                                        files.add(binfile);
                                delete [] buffer;
                        }
                        binaryFiles.put(binfile, JString(bufferlen));
                }
                this->setEntry("BinaryFiles", binaryFiles.toXML());
        }

        this->setEntry("OutputFilesWrittenToFile", files.printListLine(","));
        JString xml = this->toXML();
        bool res = JFile::writeAFileASCII(filename, xml);
        return res;
}


bool InfoItem::unitTest() {

        //JString s = "bla\nbla";
        //JString ss = s.xmlStringEncode();
        //JString sss = ss.xmlStringDecode();
        //printf("%s\n%s\n%s\n\n", (char*) s, (char*) ss, (char*) sss);

        InfoItem* i = new InfoItem();
        i->setEntry("Test", "bla\nbla");
        JString xml = i->toXML();
        delete(i);
        i = new InfoItem(xml);
        JString test = i->getEntry("Test");
        if (!test.equals("bla\nbla"))
                return false;
        delete(i);
        return true;
}


} // namespace cmlabs

---