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

************************************************************************/
// Specs.cpp: implementation of the Specs classes.
//
//////////////////////////////////////////////////////////////////////

#include "Specs.h"



namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Trigger Spec
//////////////////////////////////////////////////////////////////////

TriggerSpec::TriggerSpec() {
        delayMS = 0;
}

TriggerSpec::TriggerSpec(const JString& xml, JString globalFrom) {
        delayMS = 0;
        fromXML(xml);
        if (globalFrom.length())
                from = globalFrom;
}

TriggerSpec::TriggerSpec(XMLNode* node, JString globalFrom) {
        delayMS = 0;
        fromXML(node);
        if (globalFrom.length())
                from = globalFrom;
}

TriggerSpec::~TriggerSpec() {
}

Object* TriggerSpec::clone() const { 
        TriggerSpec* spec = new TriggerSpec();
        *spec = *this;
        return spec;
}

//! Get total size of payload
unsigned long TriggerSpec::getPayloadSize() const {
        return alias.getPayloadSize() + from.getPayloadSize() + type.getPayloadSize();
}

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

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

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

bool TriggerSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("trigger")) )
                return false;

        from = node->findAttr("from");
        type = node->findAttr("type").toDotString();
        if (node->hasAttribute("alias"))
                alias = node->findAttr("alias");
        else if (node->hasAttribute("name"))
                alias = node->findAttr("name");
        else
                alias = node->findAttr("type");
        delayMS = node->findAttr("after").toInt();
        return true;
}

JString TriggerSpec::toXML() {
        if (alias.equals(type.toText()))
                return JString::format("<trigger after=\"%d\" from=\"%s\" type=\"%s\" />", delayMS, (char*) from.xmlStringEncode(), (char*) type.toText().xmlStringEncode());
        else
                return JString::format("<trigger alias=\"%s\" after=\"%d\" from=\"%s\" type=\"%s\" />", (char*) alias.xmlStringEncode(), delayMS, (char*) from.xmlStringEncode(), (char*) type.toText().xmlStringEncode());
}

JString TriggerSpec::toHTML() {
        return print();
}

JString TriggerSpec::print() {
//      return JString::format("Trigger from <I>%s</I> type <I>%s</I> after <I>%d</I> ms\n", (char*) from, (char*) type.toText(), delayMS);
        return JString::format("%s after %d ms from %s\n", (char*) type.toText(), delayMS, (char*) from);
}

/*
bool TriggerSpec::isSystemTrigger() {
        return ( (type[0].equalsIgnoreCase("System")) || (type[0].equalsIgnoreCase("SoB")) );
}
*/







//////////////////////////////////////////////////////////////////////
// Retrieve Spec
//////////////////////////////////////////////////////////////////////

RetrieveSpec::RetrieveSpec() {
        afterTime.setInvalid();
        untilTime.setInvalid();
        maxCount = minCount = latest = lastMS = -1;
}

RetrieveSpec::RetrieveSpec(const JString& xml, JString globalFrom) {
        afterTime.setInvalid();
        untilTime.setInvalid();
        maxCount = minCount = latest = lastMS = -1;
        fromXML(xml);
        if (globalFrom.length())
                from = globalFrom;
}

RetrieveSpec::RetrieveSpec(XMLNode* node, JString globalFrom) {
        afterTime.setInvalid();
        untilTime.setInvalid();
        maxCount = minCount = latest = lastMS = -1;
        fromXML(node);
        if (globalFrom.length())
                from = globalFrom;
}

RetrieveSpec::~RetrieveSpec() {
}

Object* RetrieveSpec::clone() const { 
        RetrieveSpec* spec = new RetrieveSpec();
        *spec = *this;
        return spec;
}

//! Get total size of payload
unsigned long RetrieveSpec::getPayloadSize() const {
        return from.getPayloadSize() + sender.getPayloadSize() + id.getPayloadSize() +
                type.getPayloadSize() + content.getPayloadSize() + contentmatch.getPayloadSize() +
                beforeContext.getPayloadSize() + duringContext.getPayloadSize() + afterContext.getPayloadSize() +
                afterTime.getPayloadSize() + untilTime.getPayloadSize();
}

ObjectCollection* RetrieveSpec::fromRetrievesXML(const JString& xml) {
        if (xml.length() == 0)
                return false;

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

ObjectCollection* RetrieveSpec::fromRetrievesXML(XMLNode* node) {
        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("retrieves")) )
                return NULL;

        ObjectCollection* specs = new ObjectCollection();
        ObjectCollection* children = node->getChildTags();
        XMLNode* xmlNode;
        if (children != NULL) {
                for (int n=0; n<children->getCount(); n++) {
                        xmlNode = (XMLNode*) children->get(n);
                        if (xmlNode != NULL) {
                                if (xmlNode->getTag().equalsIgnoreCase("retrieve")) {
                                        specs->add(new RetrieveSpec(xmlNode, node->getAttribute("from")));
                                }
                        }
                }
        }

        return specs;
}

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

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

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

bool RetrieveSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("retrieve")) )
                return false;

        afterTime.setInvalid();
        untilTime.setInvalid();

        from = node->findAttr("from");
        sender = node->findAttr("sender");
        id = node->findAttr("id");
        type = node->findAttr("type").toDotString();
        
        content = node->findAttr("content");
        if (node->hasAttribute("contentraw")) {
                content = node->findAttr("contentraw");
                contentmatch = "xml";
        }
        else if (node->hasAttribute("contentmatch")) {
                contentmatch = node->findAttr("contentmatch");
        }

        beforeContext = node->findAttr("beforecontext");
        duringContext = node->findAttr("duringcontext");
        afterContext = node->findAttr("aftercontext");

        bool didSpecifyQuantity = false;

        if (node->hasAttribute("latest")) {
                latest = node->getAttribute("latest").toInt();
                didSpecifyQuantity = true;
        }
        if (node->hasAttribute("lastmsec")) {
                lastMS = node->getAttribute("lastmsec").toInt();
                didSpecifyQuantity = true;
        }

        ObjectCollection* children = node->getChildTags();
        XMLNode* xmlNode;
        if (children != NULL) {
                for (int n=0; n<children->getCount(); n++) {
                        xmlNode = (XMLNode*) children->get(n);
                        if (xmlNode != NULL) {
                                if (xmlNode->getTag().equalsIgnoreCase("latest")) {
                                        latest = xmlNode->getTextContent().toInt();
                                        didSpecifyQuantity = true;
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("afterTime")) {
                                        afterTime = xmlNode->getTextContent().toTime();
                                        didSpecifyQuantity = true;
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("untilTime")) {
                                        untilTime = xmlNode->getTextContent().toTime();
                                        didSpecifyQuantity = true;
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("lastmsec")) {
                                        lastMS = xmlNode->getTextContent().toInt();
                                        didSpecifyQuantity = true;
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("beforecontext")) {
                                        beforeContext = xmlNode->getTextContent().toDotString();
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("duringcontext")) {
                                        duringContext = xmlNode->getTextContent().toDotString();
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("aftercontext")) {
                                        afterContext = xmlNode->getTextContent().toDotString();
                                }
                        }
                }
        }

        if (!didSpecifyQuantity) {
                latest = 1;
        }

        return true;
}

JString RetrieveSpec::toXML() {
        JString xml;
        
        if (latest > 0)
                xml += JString::format("<latest>%d</latest>\n", latest);
        if (afterTime.isValid())
                xml += JString::format("<afterTime>%d</afterTime>\n", (char*) afterTime.asText());
        if (untilTime.isValid())
                xml += JString::format("<untilTime>%d</untilTime>\n", (char*) untilTime.asText());
        if (lastMS > 0)
                xml += JString::format("<lastmsec>%d</lastmsec>\n", lastMS);

        if (beforeContext.getCount() > 0)
                xml += JString::format("<beforecontext>%s</beforecontext>\n", (char*) beforeContext.toText().xmlStringEncode());
        if (duringContext.getCount() > 0)
                xml += JString::format("<duringcontext>%s</duringcontext>\n", (char*) duringContext.toText().xmlStringEncode());
        if (afterContext.getCount() > 0)
                xml += JString::format("<aftercontext>%s</aftercontext>\n", (char*) afterContext.toText().xmlStringEncode());

        if (xml.length() > 0)
                return JString::format("<retrieve from=\"%s\" sender=\"%s\" type=\"%s\" id=\"%s\" content=\"%s\" contentmatch=\"%s\">\n%s</retrieve>",
                (char*) from.xmlStringEncode(), (char*) sender.xmlStringEncode(), (char*) type.toText().xmlStringEncode(), (char*) id.xmlStringEncode(), (char*) content.xmlStringEncode(), (char*) contentmatch.xmlStringEncode(), (char*) xml.indentXML());
        else
                return JString::format("<retrieve from=\"%s\" sender=\"%s\" type=\"%s\" id=\"%s\" content=\"%s\" contentmatch=\"%s\" />",
                (char*) from.xmlStringEncode(), (char*) sender.xmlStringEncode(), (char*) type.toText().xmlStringEncode(), (char*) id.xmlStringEncode(), (char*) content.xmlStringEncode(), (char*) contentmatch.xmlStringEncode());
}

JString RetrieveSpec::toHTML() {
        return print();
}

JString RetrieveSpec::print() {
//      return JString::format("Retrieve from <I>%s</I> type <I>%s</I>\n", (char*) from, (char*) type.toText());
        return JString::format("%s from %s\n", (char*) type.toText(), (char*) from);
}















//////////////////////////////////////////////////////////////////////
// Crank Spec
//////////////////////////////////////////////////////////////////////

CrankSpec::CrankSpec() {
        continuous = false;
//      mediaStreams = new Dictionary();
}

CrankSpec::CrankSpec(const JString& xml) {
        continuous = false;
//      mediaStreams = new Dictionary();
        fromXML(xml);
}

CrankSpec::CrankSpec(XMLNode* node) {
        continuous = false;
//      mediaStreams = new Dictionary();
        fromXML(node);
}

CrankSpec::~CrankSpec() {
//      delete(mediaStreams);
}

Object* CrankSpec::clone() const { 
        CrankSpec* spec = new CrankSpec();
        spec->name = this->name;
        spec->continuous = continuous;
//      spec->mediaStreams->addAll(*mediaStreams);
        return spec;
}

//! Get total size of payload
unsigned long CrankSpec::getPayloadSize() const {
        return name.getPayloadSize();
}

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

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

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

bool CrankSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("crank")) )
                return false;

        name = node->findAttr("name");

        if (node->getAttribute("type").startsWithIgnoreCase("cont")) {
                continuous = true;
        }
        else
                continuous = false;

        ObjectCollection* children = node->getChildTags();
        if ( (children == NULL) || (children->getCount() == 0))
                return true;

/*
        XMLNode* xmlNode;
        JString name, source;
        for (int n=0; n<children.getCount(); n++) {
                xmlNode = (XMLNode*) children.get(n);
                if (xmlNode != NULL) {
                        if (xmlNode->getTag().containsIgnoreCase("stream")) {
                                name = xmlNode->getAttribute("name");
                                source = xmlNode->getAttribute("source");
                                if ( (name.length() > 0) && (source.length() > 0) )
                                        mediaStreams->put(name, source);
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("mediaconnection")) {
                                name = xmlNode->getAttribute("alias");
                                source = xmlNode->getAttribute("source");
                                if ( (name.length() > 0) && (source.length() > 0) )
                                        mediaStreams->put(name, source);
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("mediastream")) {
                                name = xmlNode->getAttribute("name");
                                source = xmlNode->getAttribute("source");
                                if ( (name.length() > 0) && (source.length() > 0) )
                                        mediaStreams->put(name, source);
                        }
                }
        }
*/      
        return true;
}

JString CrankSpec::toXML() {

//      JString xml;
/*
        JString mediaName, source;
        for (int m=0; m<mediaStreams->getCount(); m++) {
                mediaName = mediaStreams->getKey(m);
                source = mediaStreams->get(mediaName);
                if ((mediaName.length() > 0) && (source.length() > 0))
                        xml += JString::format("<stream name=\"%s\" source=\"%s\" />\n", (char*) mediaName.xmlStringEncode(), (char*) source.xmlStringEncode());
//                      xml += JString::format("<mediaconnection source=\"%s\" alias=\"%s\" />\n", (char*) source.xmlStringEncode(), (char*) mediaName.xmlStringEncode());
//                      xml += JString::format("<stream name=\"%s\" source=\"%s\" />\n", (char*) mediaName, (char*) source);
        }
*/
        JString type;
        if (continuous)
                type = "type=\"continuous\"";

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

JString CrankSpec::toHTML() {
        return print();
}

JString CrankSpec::print() {
        return JString::format("Crank '%s'\n", (char*) name);
}




















//////////////////////////////////////////////////////////////////////
// Post Spec
//////////////////////////////////////////////////////////////////////

PostSpec::PostSpec() {
        priority = 1;
        useInReplyTo = true;
        noreply = false;
        object = NULL;
}

PostSpec::PostSpec(const JString& xml, JString globalTo) {
        priority = 1;
        useInReplyTo = true;
        noreply = false;
        object = NULL;
        fromXML(xml);
        if (globalTo.length())
                to = globalTo;
}

PostSpec::PostSpec(XMLNode* node, JString globalTo) {
        priority = 1;
        useInReplyTo = true;
        noreply = false;
        object = NULL;
        fromXML(node);
        if (globalTo.length())
                to = globalTo;
}

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

Object* PostSpec::clone() const { 
        PostSpec* spec = new PostSpec();
        *spec = *this;
        if (object != NULL)
                spec->object = object->clone();
        return spec;
}

//! Get total size of payload
unsigned long PostSpec::getPayloadSize() const {
        unsigned long payloadSize = from.getPayloadSize() + alias.getPayloadSize() + to.getPayloadSize() +
                cc.getPayloadSize() + phasechange.getPayloadSize() + type.getPayloadSize() +
                content.getPayloadSize() + language.getPayloadSize();
        if (object != NULL) payloadSize += object->getPayloadSize();
        return payloadSize;
}

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

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

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

bool PostSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("post")) )
                return false;

        from = node->findAttr("from");
        to = node->findAttr("to");
        cc = node->findAttr("cc");
        type = node->findAttr("type").toDotString();
        language = node->findAttr("language");
        phasechange = node->findAttr("phasechange");
        if (node->hasAttribute("content"))
                content = node->getAttribute("content");
        else {
                if (language.equalsIgnoreCase("xml")) {
                        object = Object::createObjectFromXML(node->getTextContent());
                }
                else {
                        content = node->getTextContent();
                }
        }
        if (node->hasAttribute("alias"))
                alias = node->findAttr("alias");
        else if (node->hasAttribute("name"))
                alias = node->findAttr("name");
        else
                alias = node->findAttr("type");

        if (node->hasAttribute("priority"))
                priority = node->getAttribute("priority").toDouble();

        if (node->getAttribute("useinreplyto").equalsIgnoreCase("no")) {
                useInReplyTo = false;
        }

        if (node->getAttribute("noreply").length() > 0) {
                noreply = true;
        }

        return true;
}

JString PostSpec::toXML() {
        
        JString xml;
        if (object != NULL) {
                xml = object->toXML();
                language = "xml";
        }
        else if (content.contains("\n"))
                xml = content;

        JString inreplytext;
        if (!useInReplyTo)
                inreplytext = " useinreplyto=\"no\"";
        if (noreply)
                inreplytext += " noreply=\"yes\"";

        JString nameparm;
        if (!nameparm.equals(type.toText()))
                nameparm = JString::format("alias=\"%s\" ", (char*) alias.xmlStringEncode());

        if (xml.length() > 0) {
                return JString::format("<post %sfrom=\"%s\" to=\"%s\" cc=\"%s\" type=\"%s\" phasechange=\"%s\" language=\"%s\" priority=\"%f\" %s>\n%s</post>",
                        (char*) nameparm, (char*) from.xmlStringEncode(), (char*) to.xmlStringEncode(), (char*) cc.xmlStringEncode(), (char*) type.toText().xmlStringEncode(), (char*) phasechange.xmlStringEncode(),
                        (char*) language.xmlStringEncode(), priority, (char*) inreplytext, (char*) xml.indentXML());
        }
        else
                return JString::format("<post %sfrom=\"%s\" to=\"%s\" cc=\"%s\" type=\"%s\" phasechange=\"%s\" language=\"%s\" priority=\"%f\" content=\"%s\" %s />",
                        (char*) nameparm, (char*) from.xmlStringEncode(), (char*) to.xmlStringEncode(), (char*) cc.xmlStringEncode(), (char*) type.toText().xmlStringEncode(), (char*) phasechange.xmlStringEncode(),
                        (char*) language.xmlStringEncode(), priority, (char*) content.xmlStringEncode(), (char*) inreplytext);
}

JString PostSpec::toHTML() {
        return print();
}

JString PostSpec::print() {
//      return JString::format("Post to <I>%s</I> type <I>%s</I> from <I>%s</I>\n", (char*) to, (char*) type.toText(), (char*) from);
        JString extra;
        if (cc.length() > 0)
                extra = JString::format(" (cc: %s)", (char*) cc);
        if (phasechange.equalsIgnoreCase("yes"))
                extra = JString::format("%s [phasechange]", (char*) extra);
        return JString::format("%s to %s%s\n", (char*) type.toText(), (char*) to, (char*) extra);
}

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


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

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

//! Get a pointer to the binary data at chunk number 'chunk'
long PostSpec::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 PostSpec::fromBinaryBuffer(int chunk, char* buffer, long len) {
        if (object == NULL)
                return false;
        return object->fromBinaryBuffer(chunk, buffer, len);
}














//////////////////////////////////////////////////////////////////////
// Phase Spec
//////////////////////////////////////////////////////////////////////

PhaseSpec::PhaseSpec() {
        triggers = new ObjectCollection();
//      systriggers = new ObjectCollection();
        retrieves = new ObjectCollection();
        cranks = new ObjectCollection();
        posts = new ObjectCollection();
        streams = new ObjectCollection();
        currentContexts = NULL;
        allowSelfTriggering = false;
        name = "";
        moduleName = "";
        context = "";
        priority = 1;
        activationTime.setInvalid();
        pid = createUniqueID();
}

PhaseSpec::PhaseSpec(const JString& xml) {
        triggers = new ObjectCollection();
//      systriggers = new ObjectCollection();
        retrieves = new ObjectCollection();
        cranks = new ObjectCollection();
        posts = new ObjectCollection();
        streams = new ObjectCollection();
        currentContexts = NULL;
        name = "";
        moduleName = "";
        context = "";
        allowSelfTriggering = false;
        priority = 1;
        activationTime.setInvalid();
        pid = createUniqueID();
        fromXML(xml);
}

PhaseSpec::PhaseSpec(XMLNode* node) {
        triggers = new ObjectCollection();
//      systriggers = new ObjectCollection();
        retrieves = new ObjectCollection();
        cranks = new ObjectCollection();
        posts = new ObjectCollection();
        streams = new ObjectCollection();
        currentContexts = NULL;
        name = "";
        moduleName = "";
        context = "";
        allowSelfTriggering = false;
        priority = 1;
        activationTime.setInvalid();
        pid = createUniqueID();
        fromXML(node);
}

PhaseSpec::~PhaseSpec() {
        delete(triggers);
//      delete(systriggers);
        delete(retrieves);
        delete(cranks);
        delete(posts);
        delete(streams);
        delete(currentContexts);
//      int i = 0;
}

Object* PhaseSpec::clone() const { 
        PhaseSpec* spec = new PhaseSpec();
        spec->priority = priority;
        spec->name = this->name;
        spec->moduleName = this->moduleName;
        spec->context = this->context;
        spec->allowSelfTriggering = this->allowSelfTriggering;
        spec->triggers->copyAll(triggers);
//      spec->systriggers->copyAll(systriggers);
        spec->retrieves->copyAll(retrieves);
        spec->cranks->copyAll(cranks);
        spec->posts->copyAll(posts);
        spec->streams->copyAll(streams);
        spec->activationTime = activationTime;
        if (currentContexts != NULL)
                spec->currentContexts = (ObjectDictionary*) currentContexts->clone();
        spec->pid = pid;
        return spec;
}

//! Get total size of payload
unsigned long PhaseSpec::getPayloadSize() const {
        unsigned long payloadSize = activationTime.getPayloadSize() + name.getPayloadSize() + pid.getPayloadSize() +
                moduleName.getPayloadSize() + context.getPayloadSize() + lastTriggerName.getPayloadSize();

        if (currentContexts != NULL) payloadSize += currentContexts->getPayloadSize();
        if (triggers != NULL) payloadSize += triggers->getPayloadSize();
        if (retrieves != NULL) payloadSize += retrieves->getPayloadSize();
        if (cranks != NULL) payloadSize += cranks->getPayloadSize();
        if (posts != NULL) payloadSize += posts->getPayloadSize();
        if (streams != NULL) payloadSize += streams->getPayloadSize();

        return payloadSize;
}

bool PhaseSpec::equals(const Object *o2) {
        if (!this->isSameClass(o2))
                return false;
        return ( ((PhaseSpec*)o2)->pid.equalsIgnoreCase(pid) );
//      return ( (!((PhaseSpec*)o2)->moduleName.equals(moduleName)) || (!((PhaseSpec*)o2)->context.equals(context)) );
}

int PhaseSpec::compare(const Object *o2) {
        if (!this->isSameClass(o2))
                return false;
        if (!((PhaseSpec*)o2)->activationTime.isValid())
                return 1;
        else if (!activationTime.isValid())
                return -1;
        else
                return activationTime.compare(&((PhaseSpec*)o2)->activationTime);
}

bool PhaseSpec::isNewerThan(const PhaseSpec* spec) {
        if (!spec->activationTime.isValid())
                return true;
        else if (!activationTime.isValid())
                return false;
        else
                return (activationTime > spec->activationTime);
}

bool PhaseSpec::isOlderThan(const PhaseSpec* spec) {
        if (!activationTime.isValid())
                return true;
        else if (!spec->activationTime.isValid())
                return false;
        else
                return (activationTime < spec->activationTime);
}


bool PhaseSpec::containsGlobalTrigger() {
        
        TriggerSpec* trigger;
        for (int n=0; n<triggers->getCount(); n++) {
                if ( (trigger = (TriggerSpec*) triggers->get(n)) != NULL ) {
                        if ( (trigger->from.equalsIgnoreCase("any")) || (trigger->from.equalsIgnoreCase("*")) || (trigger->from.length() == 0) )
                                return true;
                }
        }
        return false;
}


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

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

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

bool PhaseSpec::fromXML(XMLNode* node) {

        if (node == NULL)
                return false;

        triggers->removeAll();
//      systriggers->removeAll();
        retrieves->removeAll();
        cranks->removeAll();
        posts->removeAll();

        XMLNode* xmlNode;
        if (node->getTag().equalsIgnoreCase("phase")) {
                if (node->hasAttribute("priority"))
                        priority = node->findAttr("priority").toDouble();
                if (node->hasAttribute("id"))
                        name = node->findAttr("id");
                else
                        name = node->findAttr("name");
                if (node->hasAttribute("pid")) {
                        if (node->getAttribute("pid").length() > 0)
                                pid = node->getAttribute("pid");
                }
                JString str = node->findAttr("module");
                if (str.length() > 0)
                        moduleName = str;
                str = node->findAttr("context");
                if (str.length() > 0)
                        context = str;
                xmlNode = node->getChildNode("allowselftriggering");
                if ((xmlNode != NULL) && (xmlNode->getTextContent().equalsIgnoreCase("yes"))) {
                        allowSelfTriggering = true;
                }
                else if ((xmlNode != NULL) && (xmlNode->getTextContent().equalsIgnoreCase("no"))) {
                        allowSelfTriggering = false;
                }
                lastTriggerName = node->findAttr("lasttrigger");
        }

        ObjectCollection* children = node->getChildTags();
        if ( (children == NULL) || (children->getCount() == 0))
                return true;

        XMLNode* subNode, *streamNode;
        ObjectCollection* subNodes;
        ObjectCollection *streamNodes;
        TriggerSpec* triggerSpec;
        PostSpec* postSpec;

        for (int n=0; n<children->getCount(); n++) {
                xmlNode = (XMLNode*) children->get(n);
                if (xmlNode != NULL) {
                        if (xmlNode->getTag().equalsIgnoreCase("triggers")) {
                                if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<subNodes->getCount(); m++) {
                                                subNode = (XMLNode*) subNodes->get(m);
                                                if ( (subNode != NULL) && (subNode->getTag().equalsIgnoreCase("trigger")) ) {
                                                        triggerSpec = new TriggerSpec(subNode, xmlNode->findAttr("from"));
                                                        //if (triggerSpec->isSystemTrigger())
                                                        //      systriggers->add(triggerSpec->clone());
                                                        triggers->add(triggerSpec);
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("retrieves")) {
                                if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<subNodes->getCount(); m++) {
                                                subNode = (XMLNode*) subNodes->get(m);
                                                if ( (subNode != NULL) && (subNode->getTag().equalsIgnoreCase("retrieve")) ) {
                                                        retrieves->add(new RetrieveSpec(subNode, xmlNode->findAttr("from")));
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("cranks")) {
                                if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<subNodes->getCount(); m++) {
                                                subNode = (XMLNode*) subNodes->get(m);
                                                if ( (subNode != NULL) && (subNode->getTag().equalsIgnoreCase("crank")) ) {
                                                        cranks->add(new CrankSpec(subNode));
                                                        if ( (streamNodes = subNode->getChildTags()) != NULL) {
                                                                for (int mm=0; mm<streamNodes->getCount(); mm++) {
                                                                        streamNode = (XMLNode*) streamNodes->get(mm);
                                                                        if ( (streamNode != NULL) && (streamNode->getTag().containsIgnoreCase("stream")) ) {
                                                                                streams->add(new StreamAccess(streamNode));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("posts")) {
                                if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<subNodes->getCount(); m++) {
                                                subNode = (XMLNode*) subNodes->get(m);
                                                if ( (subNode != NULL) && (subNode->getTag().equalsIgnoreCase("post")) ) {
                                                        postSpec = new PostSpec(subNode, xmlNode->findAttr("to"));
                                                        if (!subNode->hasAttribute("priority"))
                                                                postSpec->priority = priority;
                                                        posts->add(postSpec);
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("streams")) {
                                if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<subNodes->getCount(); m++) {
                                                subNode = (XMLNode*) subNodes->get(m);
                                                if ( (subNode != NULL) && (subNode->getTag().containsIgnoreCase("stream")) ) {
                                                        streams->add(new StreamAccess(subNode));
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("currentcontexts")) {
                                currentContexts = new ObjectDictionary();
                                if (!currentContexts->fromXML(xmlNode->getFirstChildNode())) {
                                        delete(currentContexts);
                                        currentContexts = NULL;
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("trigger")) {
                                triggers->add(new TriggerSpec(xmlNode));
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("retrieve")) {
                                retrieves->add(new RetrieveSpec(xmlNode));
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("crank")) {
                                cranks->add(new CrankSpec(xmlNode));
                                if ( (streamNodes = xmlNode->getChildTags()) != NULL) {
                                        for (int m=0; m<streamNodes->getCount(); m++) {
                                                streamNode = (XMLNode*) streamNodes->get(m);
                                                if ( (streamNode != NULL) && (streamNode->getTag().containsIgnoreCase("stream")) ) {
                                                        streams->add(new StreamAccess(streamNode));
                                                }
                                        }
                                }
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("post")) {
                                postSpec = new PostSpec(xmlNode);
                                if (!xmlNode->hasAttribute("priority"))
                                        postSpec->priority = priority;
                                posts->add(postSpec);
                        }
                        else if (xmlNode->getTag().containsIgnoreCase("stream")) {
                                streams->add(new StreamAccess(xmlNode));
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("activationtime")) {
                                activationTime = JTime(xmlNode);
                        }
                }
        }

/*      if (DEBUGLEVEL(DEBUG)) {
                printf("[ContextOracle] Module '%s' with context '%s': Phase '%s' has:\n\t%d triggers\n\t%d retrieves\n\t%d cranks\n\t%d posts\n",
                        (char*) moduleName, (char*) context, (char*) id, triggers->getCount(), retrieves->getCount(), cranks->getCount(), posts->getCount());
        }
*/
        return true;
}

JString PhaseSpec::toXML() {
        JString xml, subXML;
        int n;

        if (allowSelfTriggering)
                xml += JString::format("<allowselftriggering>Yes</allowselftriggering>\n");

        TriggerSpec* triggerSpec;
        if (triggers->getCount() > 0) {
                subXML = "";
        /*      for (n=0; n<systriggers->getCount(); n++) {
                        triggerSpec = (TriggerSpec*) systriggers->get(n);
                        if (triggerSpec != NULL)
                                subXML += triggerSpec->toXML() + "\n";
                }*/
                for (n=0; n<triggers->getCount(); n++) {
                        triggerSpec = (TriggerSpec*) triggers->get(n);
                        if (triggerSpec != NULL)
                                subXML += triggerSpec->toXML() + "\n";
                }
                xml += JString::format("<triggers>\n%s</triggers>\n", (char*) subXML.indentXML());
        }

        RetrieveSpec* retrieveSpec;
        if (retrieves->getCount() > 0) {
                subXML = "";
                for (n=0; n<retrieves->getCount(); n++) {
                        retrieveSpec = (RetrieveSpec*) retrieves->get(n);
                        if (retrieveSpec != NULL)
                                subXML += retrieveSpec->toXML() + "\n";
                }
                xml += JString::format("<retrieves>\n%s</retrieves>\n", (char*) subXML.indentXML());
        }

        CrankSpec* crankSpec;
        if (cranks->getCount() > 0) {
                subXML = "";
                for (n=0; n<cranks->getCount(); n++) {
                        crankSpec = (CrankSpec*) cranks->get(n);
                        if (crankSpec != NULL)
                                subXML += crankSpec->toXML() + "\n";
                }
                xml += JString::format("<cranks>\n%s</cranks>\n", (char*) subXML.indentXML());
        }

        PostSpec* postSpec;
        if (posts->getCount() > 0) {
                subXML = "";
                for (n=0; n<posts->getCount(); n++) {
                        postSpec = (PostSpec*) posts->get(n);
                        if (postSpec != NULL)
                                subXML += postSpec->toXML() + "\n";
                }
                xml += JString::format("<posts>\n%s</posts>\n", (char*) subXML.indentXML());
        }

        StreamAccess* streamSpec;
        if (streams->getCount() > 0) {
                subXML = "";
                for (n=0; n<streams->getCount(); n++) {
                        streamSpec = (StreamAccess*) streams->get(n);
                        if (streamSpec != NULL)
                                subXML += streamSpec->toXML() + "\n";
                }
                xml += JString::format("<streams>\n%s</streams>\n", (char*) subXML.indentXML());
        }

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

        xml += activationTime.toXML("activationtime") + "\n";

//      JFile::writeAFileASCII("t:\\phase.xml", (char*) JString::format("<phase id=\"%s\" module=\"%s\" context=\"%s\">\n%s</phase>", (char*) id, (char*) moduleName, (char*) context, (char*) xml));

        return JString::format("<phase name=\"%s\" module=\"%s\" context=\"%s\" lasttrigger=\"%s\" pid=\"%s\" priority=\"%.3f\">\n%s</phase>",
                (char*) name.xmlStringEncode(), (char*) moduleName.xmlStringEncode(), (char*) context.xmlStringEncode(), (char*) lastTriggerName.xmlStringEncode(), (char*) pid.xmlStringEncode(), priority, (char*) xml.indentXML());
}

JString PhaseSpec::print() {
        int n;
        JString html = JString::format("Phase %s:   [%s]   %s\n", (char*) name, (char*) context, (char*) moduleName);

        if (triggers->getCount() > 0) {
                html += "Triggers:\n";
                TriggerSpec* triggerSpec;
                for (n=0; n<triggers->getCount(); n++) {
                        triggerSpec = (TriggerSpec*) triggers->get(n);
                        if (triggerSpec != NULL) {
                                html += JString("- ") + triggerSpec->toHTML() + "\n";
                        }
                }
        }

        if (retrieves->getCount() > 0) {
                html += "Retrieves:\n";
                RetrieveSpec* retrieveSpec;
                for (n=0; n<retrieves->getCount(); n++) {
                        retrieveSpec = (RetrieveSpec*) retrieves->get(n);
                        if (retrieveSpec != NULL) {
                                html += JString("- ") + retrieveSpec->toHTML() + "\n";
                        }
                }
        }

        if (cranks->getCount() > 0) {
                html += "Cranks:\n";
                CrankSpec* crankSpec;
                for (n=0; n<cranks->getCount(); n++) {
                        crankSpec = (CrankSpec*) cranks->get(n);
                        if (crankSpec != NULL) {
                                html += JString("- ") + crankSpec->toHTML() + "\n";
                        }
                }
        }

        if (posts->getCount() > 0) {
                html += "Posts:\n";
                PostSpec* postSpec;
                for (n=0; n<posts->getCount(); n++) {
                        postSpec = (PostSpec*) posts->get(n);
                        if (postSpec != NULL) {
                                html += JString("- ") + postSpec->toHTML() + "\n";
                        }
                }
        }

        if (streams->getCount() > 0) {
                html += "Streams:\n";
                StreamAccess* streamSpec;
                for (n=0; n<streams->getCount(); n++) {
                        streamSpec = (StreamAccess*) streams->get(n);
                        if (streamSpec != NULL) {
                                html += JString("- ") + streamSpec->toHTML() + "\n";
                        }
                }
        }

        return html;
}

JString PhaseSpec::toHTML() {

        int n;
        JString html;

        if (triggers->getCount() > 0) {
                html += "<tr><td class=\"MessageShowDataName\" align=\"right\" valign=\"top\">Triggers</td><td colspan=\"3\" class=\"MessageShowDataValue\">";
                TriggerSpec* triggerSpec;
                for (n=0; n<triggers->getCount(); n++) {
                        triggerSpec = (TriggerSpec*) triggers->get(n);
                        if (triggerSpec != NULL) {
                                html += triggerSpec->toHTML() + "<br>";
                        }
                }
                html += "</td></tr>\n";
        }

        if (retrieves->getCount() > 0) {
                html += "<tr><td class=\"MessageShowDataName\" align=\"right\" valign=\"top\">Retrieves</td><td colspan=\"3\" class=\"MessageShowDataValue\">";
                RetrieveSpec* retrieveSpec;
                for (n=0; n<retrieves->getCount(); n++) {
                        retrieveSpec = (RetrieveSpec*) retrieves->get(n);
                        if (retrieveSpec != NULL) {
                                html += retrieveSpec->toHTML() + "<br>";
                        }
                }
                html += "</td></tr>\n";
        }

        if (cranks->getCount() > 0) {
                html += "<tr><td class=\"MessageShowDataName\" align=\"right\" valign=\"top\">Cranks</td><td colspan=\"3\" class=\"MessageShowDataValue\">";
                CrankSpec* crankSpec;
                for (n=0; n<cranks->getCount(); n++) {
                        crankSpec = (CrankSpec*) cranks->get(n);
                        if (crankSpec != NULL) {
                                html += crankSpec->toHTML() + "<br>";
                        }
                }
                html += "</td></tr>\n";
        }

        if (posts->getCount() > 0) {
                html += "<tr><td class=\"MessageShowDataName\" align=\"right\" valign=\"top\">Posts</td><td colspan=\"3\" class=\"MessageShowDataValue\">";
                PostSpec* postSpec;
                for (n=0; n<posts->getCount(); n++) {
                        postSpec = (PostSpec*) posts->get(n);
                        if (postSpec != NULL) {
                                html += postSpec->toHTML() + "<br>";
                        }
                }
                html += "</td></tr>\n";
        }

        if (streams->getCount() > 0) {
                html += "<tr><td class=\"MessageShowDataName\" align=\"right\" valign=\"top\">Streams</td><td colspan=\"3\" class=\"MessageShowDataValue\">";
                StreamAccess* streamSpec;
                for (n=0; n<streams->getCount(); n++) {
                        streamSpec = (StreamAccess*) streams->get(n);
                        if (streamSpec != NULL) {
                                html += streamSpec->toHTML() + "<br>";
                        }
                }
                html += "</td></tr>\n";
        }

        return JString::format("<table class=\"MessageShowTable\" width=\"100%%\">\
<tr><td class=\"MessageShowDataName\" align=\"right\">CONTEXT</td><td colspan=\"3\" class=\"MessageShowDataValue\">%s</td></tr>\
<tr><td class=\"MessageShowDataName\" align=\"right\">Phase</td><td colspan=\"3\" class=\"MessageShowDataValue\">%s</td></tr>\
%s</table>",
        (char*) context, (char*) name, (char*) html);
}

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


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

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

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

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



















//////////////////////////////////////////////////////////////////////
// Context Spec
//////////////////////////////////////////////////////////////////////

ContextSpec::ContextSpec() {
        currentContexts = new ObjectDictionary();
        phases = new ObjectCollection();
        currentActivePhases = new ObjectCollection();
        currentActivePhases->noDelete();
        currentPhaseNum = 0;
        currentPhase = NULL;
        wasActive = false;
        allowSelfTriggering = false;
        priority = 1;
}

ContextSpec::ContextSpec(const JString& xml) {
        currentContexts = new ObjectDictionary();
        phases = new ObjectCollection();
        currentActivePhases = new ObjectCollection();
        currentActivePhases->noDelete();
        currentPhaseNum = 0;
        currentPhase = NULL;
        allowSelfTriggering = false;
        priority = 1;
        fromXML(xml);
        wasActive = false;
}

ContextSpec::ContextSpec(XMLNode* node) {
        currentContexts = new ObjectDictionary();
        phases = new ObjectCollection();
        currentActivePhases = new ObjectCollection();
        currentActivePhases->noDelete();
        currentPhaseNum = 0;
        currentPhase = NULL;
        allowSelfTriggering = false;
        priority = 1;
        fromXML(node);
        wasActive = false;
}

ContextSpec::~ContextSpec() {
        delete(currentContexts);
        delete(currentActivePhases);
        delete(phases);
}

Object* ContextSpec::clone() const { 
        ContextSpec* spec = new ContextSpec();
        spec->name = this->name;
        spec->moduleName = this->moduleName;
        spec->currentPhaseNum = this->currentPhaseNum;
        spec->ownContext = this->ownContext;
        spec->allowSelfTriggering = this->allowSelfTriggering;
        spec->phases->copyAll(phases);
//      spec->currentPhase = (PhaseSpec*) spec->phases->get(currentPhaseNum);
        spec->reset();
        return spec;
}

//! Get total size of payload
unsigned long ContextSpec::getPayloadSize() const {
        unsigned long payloadSize = name.getPayloadSize() + moduleName.getPayloadSize() + ownContext.getPayloadSize();

        if (currentPhase != NULL) payloadSize += currentPhase->getPayloadSize();
        if (currentActivePhases != NULL) payloadSize += currentActivePhases->getPayloadSize();
        if (phases != NULL) payloadSize += phases->getPayloadSize();
        if (currentContexts != NULL) payloadSize += currentContexts->getPayloadSize();

        return payloadSize;
}

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

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

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

bool ContextSpec::fromXML(XMLNode* node) {

        if (node == NULL)
                return false;

        phases->removeAll();
        currentPhaseNum = 0;

        XMLNode* xmlNode;
        if (node->getTag().equalsIgnoreCase("context")) {
                name = node->findAttr("name");
                ownContext = name.toDotString();
                JString str = node->findAttr("module");
                if (str.length() > 0)
                        moduleName = str;

                xmlNode = node->getChildNode("allowselftriggering");
                if ((xmlNode != NULL) && (xmlNode->getTextContent().equalsIgnoreCase("yes"))) {
                        allowSelfTriggering = true;
                }
                else if ((xmlNode != NULL) && (xmlNode->getTextContent().equalsIgnoreCase("no"))) {
                        allowSelfTriggering = false;
                }
        }

        ObjectCollection* children = node->getChildTags();
        if ((children == NULL) || (children->getCount() == 0))
                return true;

        PhaseSpec* phaseSpec;
        JString tag;
        for (int n=0; n<children->getCount(); n++) {
                xmlNode = (XMLNode*) children->get(n);
                if (xmlNode != NULL) {
                        tag = xmlNode->getTag();
                        if (tag.equalsIgnoreCase("phase")) {
                                phaseSpec = new PhaseSpec();
                                phaseSpec->priority = priority;
                                phaseSpec->allowSelfTriggering = allowSelfTriggering;
                                phaseSpec->fromXML(xmlNode);
                                phaseSpec->moduleName = moduleName;
                                phaseSpec->context = name;
                                phases->add(phaseSpec);
                        }
                        else if (tag.containsIgnoreCase("trigger") || tag.containsIgnoreCase("retrieve") ||
                                        tag.containsIgnoreCase("crank") || tag.containsIgnoreCase("post") || tag.containsIgnoreCase("stream") ) {
                                // OK, we have no context and no phases, assume default context and phase
                                phaseSpec = new PhaseSpec();
                                phaseSpec->priority = priority;
                                phaseSpec->allowSelfTriggering = allowSelfTriggering;
                                phaseSpec->name = "Default";
                                phaseSpec->moduleName = moduleName;
                                phaseSpec->context = name;
                                phases->add(phaseSpec);
                                phaseSpec->fromXML(node);
                                break;
                        }
                }
        }

        currentPhase = (PhaseSpec*) phases->get(currentPhaseNum);
        return true;
}

JString ContextSpec::toXML() {

        JString xml;

        if (allowSelfTriggering)
                xml += JString::format("<allowselftriggering>Yes</allowselftriggering>\n");

        PhaseSpec* phaseSpec;
        for (int n=0; n<phases->getCount(); n++) {
                phaseSpec = (PhaseSpec*) phases->get(n);
                if (phaseSpec != NULL) {
                        xml += phaseSpec->toXML() + "\n";
                }
        }

        return JString::format("<context name=\"%s\" module=\"%s\">\n%s</context>",
                (char*) name.xmlStringEncode(), (char*) moduleName.xmlStringEncode(), (char*) xml.indentXML());
}

bool ContextSpec::reset() {
        currentPhaseNum = 0;
        calcCurrentPhases();
        return true;
}

bool ContextSpec::calcCurrentPhases() {
//      currentPhase = (PhaseSpec*) phases->get(currentPhaseNum);
//      if (currentPhase != NULL) {
//              currentActivePhases->add(currentPhase);
//      }
        
        currentActivePhases->removeAll();
        PhaseSpec* spec;
        for (int n=0; n<phases->getCount(); n++) {
                if ( (spec = (PhaseSpec*) phases->get(n)) != NULL) {
                        if ( (n == currentPhaseNum) || (spec->containsGlobalTrigger()) )
                                currentActivePhases->add(spec);
                }
        }

        return true;
}


bool ContextSpec::setCurrentContexts(ObjectDictionary* newContexts) {

//      bool activeBefore = wasActive;
        currentContexts->removeAll();
        currentContexts->copyAll(newContexts);
        if ( (!wasActive) && (isActive()) ) {
                wasActive = true;
                reset();
        }
        return true;
}

bool ContextSpec::isActive() {
        if (currentContexts == NULL) {
        //      wasActive = false;
                return false;
        }
        JString key = ownContext[0];
        if (!currentContexts->contains(key)) {
        //      wasActive = false;
                return false;
        }
        DotString* cname = (DotString*) currentContexts->get(key);
        if (cname == NULL)
                return false;
        return ownContext.isPartOf(*cname);
        // return (wasActive = ownContext.isPartOf(*cname));
}

ObjectCollection* ContextSpec::getActivePhases() {
        if (currentActivePhases->getCount() == 0)
                return NULL;
        ObjectCollection* coll = new ObjectCollection();
        coll->noDelete();
        coll->addAll(currentActivePhases);
        return coll;
//      return (PhaseSpec*) phases->get(currentPhaseNum);
}

ObjectCollection* ContextSpec::getAllPhases() {
        if (phases->getCount() == 0)
                return NULL;
        ObjectCollection* coll = new ObjectCollection();
        coll->noDelete();
        coll->addAll(phases);
        return coll;
//      return (PhaseSpec*) phases->get(currentPhaseNum);
}

bool ContextSpec::switchPhase() {

        if (!isActive()) return false;

        currentPhaseNum++;

        if (currentPhaseNum >= phases->getCount())
                currentPhaseNum = 0;

        calcCurrentPhases();

        return true;
}


JString ContextSpec::toHTML() {

        JString html = JString::format("Context Name: <I>%s</I>", (char*) name);

        PhaseSpec* phaseSpec;
        ObjectCollection* activePhases = getActivePhases();

        if (activePhases == NULL) {
                html += "No Active Phase\n";
        }
        else if (activePhases->getCount() == 0) {
                html += "No Active Phase\n";
                delete(activePhases);
        }
        else {
                for (int n=0; n<activePhases->getCount(); n++) {
                        phaseSpec = (PhaseSpec*) activePhases->get(n);
                        if (phaseSpec != NULL) {
                                html += JString("<BR>\n") + phaseSpec->toHTML();
                        }
                }
        }

        return html;
}


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


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

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

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

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
















//////////////////////////////////////////////////////////////////////
// Module Spec
//////////////////////////////////////////////////////////////////////

ModuleSpec::ModuleSpec() {
        exec = NULL;
        currentContexts = new ObjectDictionary();
        contexts = new ObjectDictionary();
        priority = 0;
        allowSelfTriggering = false;
        getTriggersCache = new ObjectDictionary();
        // getTriggersCache->noDelete();
        parameters = new ObjectDictionary();
        verbose = 0;
        recordOverwrite = false;
}

ModuleSpec::ModuleSpec(const JString& xml) {
        exec = NULL;
        currentContexts = new ObjectDictionary();
        contexts = new ObjectDictionary();
        priority = 0;
        allowSelfTriggering = false;
        getTriggersCache = new ObjectDictionary();
        // getTriggersCache->noDelete();
        parameters = new ObjectDictionary();
        verbose = 0;
        recordOverwrite = false;
        fromXML(xml);
}

ModuleSpec::ModuleSpec(XMLNode* node) {
        exec = NULL;
        currentContexts = new ObjectDictionary();
        contexts = new ObjectDictionary();
        priority = 0;
        allowSelfTriggering = false;
        getTriggersCache = new ObjectDictionary();
        // getTriggersCache->noDelete();
        parameters = new ObjectDictionary();
        verbose = 0;
        recordOverwrite = false;
        fromXML(node);
}

ModuleSpec::~ModuleSpec() {
        delete(currentContexts);
        delete(contexts);
        delete(parameters);
        // getTriggersCache->doDelete();
        delete(getTriggersCache);
        delete(exec);
}

//! Get total size of payload
unsigned long ModuleSpec::getPayloadSize() const {
        unsigned long payloadSize = moduleName.getPayloadSize() + description.getPayloadSize() + type.getPayloadSize() +
                remote.getPayloadSize() + share.getPayloadSize() + configXML.getPayloadSize() +
                plugFunction.getPayloadSize() + currentContextsCacheString.getPayloadSize();

        if (getTriggersCache != NULL) payloadSize += getTriggersCache->getPayloadSize();
        if (currentContexts != NULL) payloadSize += currentContexts->getPayloadSize();
        if (parameters != NULL) payloadSize += parameters->getPayloadSize();
        if (exec != NULL) payloadSize += exec->getPayloadSize();

        return payloadSize;
}

Object* ModuleSpec::clone() const { 
        ModuleSpec* spec = new ModuleSpec();
        spec->description = this->description;
        spec->type = this->type;
        spec->moduleName = this->moduleName;
        spec->remote = this->remote;
        spec->share = this->share;
        spec->priority = this->priority;
        spec->verbose = this->verbose;
        spec->configXML = this->configXML;
        spec->recordStorage = this->recordStorage;
        spec->recordOverwrite = this->recordOverwrite;
        spec->allowSelfTriggering = this->allowSelfTriggering;
        spec->contexts->copyAll(contexts);
        spec->parameters->copyAll(parameters);
        if (exec != NULL)
                spec->exec = (ExecutableSpec*) this->exec->clone();
        return spec;
}

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

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

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

bool ModuleSpec::resetCache() {
        getTriggersCache->removeAll();
        return true;
}

bool ModuleSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) ||
                ( (!node->getTag().equalsIgnoreCase("module")) && (!node->getTag().equalsIgnoreCase("serviceprovider")) ) )
                return false;

        parameters->removeAll();
        contexts->removeAll();
        getTriggersCache->removeAll();

        moduleName = node->findAttr("name");
        
        type = node->findAttr("type");

        if (node->hasAttribute("share"))
                share = node->findAttr("share");
        else
                share = node->findAttr("shareresources");

        if (node->hasAttribute("remote"))
                remote = node->findAttr("remote");
        else
                remote = node->findAttr("satellite");

        if (node->hasAttribute("priority"))
                priority = node->findAttr("priority").toDouble();

        plugFunction = node->findAttr("plug");

        if (node->hasAttribute("verbose"))
                verbose = node->findAttr("verbose").toInt();

        XMLNode* xmlNode = node->getChildNode("description");
        if (xmlNode == NULL)
                description = "";
        else
                description = xmlNode->getTextContent();

        xmlNode = node->getChildNode("record");
        if (xmlNode == NULL)
                recordStorage = "";
        else {
                recordStorage = xmlNode->getAttribute("storage");
                recordOverwrite = xmlNode->getAttribute("overwrite").toBool();
        }

        configXML = "";
        xmlNode = node->getChildNode("config");
        if (xmlNode == NULL)
                xmlNode = node->getChildNode("setup");
        if (xmlNode != NULL) {
                // Check for <config file="filename">
                if (xmlNode->hasAttribute("file"))
                        configXML = JFile::readAFileASCII(xmlNode->getAttribute("file"));
                else
                        configXML = xmlNode->toXMLChildrenOnly();
        }

        ObjectDictionary* moduleParameters = Parameter::getParameterCollectionFromNode(node->getChildNode("parameters"));
        if (moduleParameters != NULL) {
                delete(parameters);
                parameters = moduleParameters;
        }
        moduleParameters = Parameter::getParameterCollectionFromNode(node->getChildNode("parameters"));
        if (moduleParameters != NULL) {
                parameters->addAll(moduleParameters);
                moduleParameters->removeAllNoDelete();
                delete(moduleParameters);
        }
        Parameter* parameter;
        ObjectCollection paramNodes = node->getChildNodes("parameter");
        for (XMLNode* paramNode = (XMLNode*) paramNodes.getFirst(); paramNode != NULL; paramNode = (XMLNode*) paramNodes.getNext()) {
                parameter = new Parameter(paramNode);
                if (parameter->name.length() > 0) {
                        parameters->put(parameter->name, parameter);
                }
                else {
                        delete(parameter);
                }
        }

        if (node->getAttribute("allowselftriggering").equalsIgnoreCase("yes")) {
                allowSelfTriggering = true;
        }
        else {
                xmlNode = node->getChildNode("allowselftriggering");
                if ((xmlNode != NULL) && (xmlNode->getTextContent().equalsIgnoreCase("yes"))) {
                        allowSelfTriggering = true;
                }
        }

        xmlNode = node->getChildNode("executable");
        if (xmlNode != NULL) {
                this->exec = new ExecutableSpec(xmlNode);
        }

        XMLNode* specNode = node->getChildNode("spec");
        if (specNode == NULL) {
                specNode = node;
        //      printf("[%s] Warning: Module XML did not contain the <spec> node, ignored...\n", (char*) moduleName);
        //      return true;
        }

        ObjectCollection* children = specNode->getChildTags();
        if ((children == NULL) || (children->getCount() == 0)) {
                // printf("[%s] Warning: Module XML did not contain the <context> nodes, ignored...\n", (char*) moduleName);
                return true;
        }

        JString tag;
        JString contextName; //, phaseName;
//      ObjectCollection phaseNodes;
        ContextSpec* contextSpec = NULL;
        PhaseSpec* phaseSpec = NULL;

        for (int n=0; n<children->getCount(); n++) {
                xmlNode = (XMLNode*) children->get(n);
                if (xmlNode != NULL) {
                        tag = xmlNode->getTag();
                        if (tag.equalsIgnoreCase("context")) {
                                // OK, we have a context in here
                                contextName = xmlNode->findAttr("name");
                                if (contextName.length() > 0) {
                                        contextSpec = new ContextSpec();
                                        contextSpec->priority = priority;
                                        // We need to set the moduleName before parsing XML
                                        // to be able to pass this on to the PhaseSpecs
                                        contextSpec->moduleName = moduleName;
                                        if (!contextSpec->allowSelfTriggering)
                                                contextSpec->allowSelfTriggering = allowSelfTriggering;
                                        contextSpec->fromXML(xmlNode);
                                        contexts->put(contextName, contextSpec);
                                }
                        }
                        else if (tag.equalsIgnoreCase("phase")) {
                                // OK, we have no context, but phase specs, assume default context
                                if (contextSpec == NULL) {
                                        contextSpec = new ContextSpec();
                                        contextSpec->priority = priority;
                                        contextSpec->name = "Psyclone.System.Ready";
                                        contextSpec->ownContext = contextSpec->name.toDotString();
                                        contextSpec->moduleName = moduleName;
                                        contextSpec->allowSelfTriggering = allowSelfTriggering;
                                        contexts->put(contextSpec->name, contextSpec);
                                }
                                // phaseName = xmlNode->findAttr("name");
                                phaseSpec = new PhaseSpec();
                                phaseSpec->priority = priority;
                                phaseSpec->allowSelfTriggering = allowSelfTriggering;
                                phaseSpec->fromXML(xmlNode);
                                phaseSpec->moduleName = moduleName;
                                phaseSpec->context = contextSpec->name;
                                contextSpec->phases->add(phaseSpec);
                        }
                        else if (tag.containsIgnoreCase("trigger") || tag.containsIgnoreCase("retrieve") ||
                                        tag.containsIgnoreCase("crank") || tag.containsIgnoreCase("post") || tag.containsIgnoreCase("stream") || tag.containsIgnoreCase("streams") ) {
                                // OK, we have no context and no phases, assume default context and phase
                                if (contextSpec == NULL) {
                                        contextSpec = new ContextSpec();
                                        contextSpec->priority = priority;
                                        contextSpec->name = "Psyclone.System.Ready";
                                        contextSpec->ownContext = contextSpec->name.toDotString();
                                        contextSpec->moduleName = moduleName;
                                        contextSpec->allowSelfTriggering = allowSelfTriggering;
                                        contexts->put(contextSpec->name, contextSpec);
                                        phaseSpec = new PhaseSpec();
                                        phaseSpec->priority = priority;
                                        phaseSpec->allowSelfTriggering = allowSelfTriggering;
                                        phaseSpec->name = "Default";
                                        phaseSpec->moduleName = moduleName;
                                        phaseSpec->context = contextSpec->name;
                                        contextSpec->phases->add(phaseSpec);
                                }
                                phaseSpec->fromXML(specNode);
                                return true;
                        }
                }
        }

        return true;
}

Collection ModuleSpec::getContextNames() {
        Collection names;
        ContextSpec* contextSpec;
        for (int n=0; n<contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) contexts->get(n);
                if (contextSpec != NULL) {
                        names.add(contextSpec->name);
                }
        }
        return names;
}

bool ModuleSpec::hasCranks() {

        ContextSpec* contextSpec;
        PhaseSpec* phaseSpec;
        for (int n=0; n<contexts->getCount(); n++) {
                if ( (contextSpec = (ContextSpec*) contexts->get(n)) != NULL) {
                        for (int m=0; n<contextSpec->phases->getCount(); n++) {
                                if ( (phaseSpec = (PhaseSpec*) contextSpec->phases->get(n)) != NULL) {
                                        if (phaseSpec->cranks->getCount() > 0)
                                                return true;
                                }
                        }
                }
        }
        return false;
}


JString ModuleSpec::toXML() {
        JString xml, subxml;
        int n;

        if (exec != NULL)
                xml += exec->toXML() + "\n";

        if (description.length() > 0)
                xml += JString::format("<description>%s</description>\n", (char*) description.xmlStringEncode());

        if (allowSelfTriggering)
                xml += JString::format("<allowselftriggering>Yes</allowselftriggering>\n");

        if (recordStorage.length() > 0)
                xml += JString::format("<record storage=\"%s\" overwrite=\"%s\">\n", (char*) recordStorage, (char*) JString(recordOverwrite));

        Parameter* parameter;
        for (n=0; n<parameters->getCount(); n++) {
                parameter = (Parameter*) parameters->get(n);
                if (parameter != NULL)
                        xml += JString::format("%s\n", (char*) parameter->toXML());
                //      subxml += JString::format("%s\n", (char*) parameter->toXML());
        }

//      if (subxml.length() > 0) {
//              xml += JString::format("<parameters>\n%s</parameters>\n", (char*) subxml.indentXML());
//      }

        subxml = "";
        ContextSpec* contextSpec;
        for (n=0; n<contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) contexts->get(n);
                if (contextSpec != NULL) {
                        subxml += contextSpec->toXML() + "\n";
                }
        }

        JString location;
        if (remote.length() > 0)
                location = JString::format("satellite=\"%s\" ", (char*) remote.xmlStringEncode());
        if (share.length() > 0)
                location += JString::format("shareresources=\"%s\" ", (char*) share.xmlStringEncode());

        xml += JString::format("<spec>\n%s</spec>", (char*) subxml.indentXML());

        if (configXML.length() > 0) {
                xml += JString::format("\n<config>\n%s</config>", (char*) configXML.indentXML());
        }

        if (plugFunction.length() > 0)
                return JString::format("<module name=\"%s\" type=\"%s\" plug=\"%s\" priority=\"%.1f\" verbose=\"%d\" %s>\n%s</module>",
                (char*) moduleName.xmlStringEncode(), (char*) type.xmlStringEncode(), (char*) plugFunction.xmlStringEncode(), priority, verbose, (char*) location, (char*) xml.indentXML());
        else
                return JString::format("<module name=\"%s\" type=\"%s\" priority=\"%.1f\" verbose=\"%d\" %s>\n%s</module>",
                (char*) moduleName.xmlStringEncode(), (char*) type.xmlStringEncode(), priority, verbose, (char*) location, (char*) xml.indentXML());
}

bool ModuleSpec::switchPhase() {

        ContextSpec* contextSpec;
        ObjectCollection* activeContexts = getActiveContexts();
        for (int n=0; n<activeContexts->getCount(); n++) {
                contextSpec = (ContextSpec*) activeContexts->get(n);
                if (contextSpec != NULL)
                        contextSpec->switchPhase();
        }
        delete(activeContexts);
        resetCache();
        return true;
}

bool ModuleSpec::setCurrentContexts(ObjectDictionary* newContexts) {

        currentContexts->removeAll();
        currentContexts->copyAll(newContexts);
        ContextSpec* contextSpec;
//      ObjectCollection activeContexts = getActiveContexts();
        for (int n=0; n<contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) contexts->get(n);
                if (contextSpec != NULL)
                        contextSpec->setCurrentContexts(newContexts);
        }
        currentContextsCacheString = currentContexts->printListLine("-");
        return true;
}

bool ModuleSpec::isCurrentlyTriggeredBy(JString wb, JString type) {

        ObjectCollection* phases = getTriggersFor(wb, type);
        if (phases->getCount() == 0) {
                delete(phases);
                return false;
        }
        else {
                delete(phases);
                return true;
        }
}

ObjectCollection* ModuleSpec::getTriggersFor(JString wb, JString type) {

        if (currentContexts == NULL)
                return NULL;

/*      if (type.startsWithIgnoreCase("Psyclone.Context")) {
                int pos = type.lastIndexOf(':');
                if (pos > 0)
                        type = type.substring(pos+1);
        }
*/              
//      JTime t;

        JString cacheString = JString::format("%s+%s+%s", (char*) currentContextsCacheString, (char*) wb, (char*) type);

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

        ObjectCollection* phases = (ObjectCollection*) getTriggersCache->get(cacheString);
        if (phases != NULL) {
                copy->addAll(phases);
                return copy;
        }

        phases = new ObjectCollection();
        phases->noDelete();

        ObjectCollection* activePhases;
        if (wb.length() > 0)
                activePhases = getActivePhases();
        else
                activePhases = getAllPhases();

//      JTime t2;
//      JString logstr = JString::format("getTrig: getActPhases: %f [%d]  ", t2.microDifference(t)/1000.0, activePhases->getCount());

//      t = JTime();
        PhaseSpec* phaseSpec;
        // DotString dstr = type.toDotString();
        TriggerSpec* trigger;
        for (int i=0; i < activePhases->getCount(); i++) {
                phaseSpec = (PhaseSpec*) activePhases->get(i);
                if (phaseSpec != NULL) {
                        for (int n=0; n<phaseSpec->triggers->getCount(); n++) {
                                trigger = (TriggerSpec*) phaseSpec->triggers->get(n);
                                if (trigger != NULL) {
                                        if ( ( (wb.length() == 0) ||
                                                   (trigger->from.length() == 0) ||
                                                   (trigger->from.equalsIgnoreCase("any")) ||
                                                   (trigger->from.equalsIgnoreCase("*")) ||
                                                   (trigger->from.equalsIgnoreCase(wb))    ) &&
                                                 (trigger->type.equals(type)) ) {
                                        // if ( (trigger->from.equalsIgnoreCase(wb)) && (trigger->type.equals(type.toDotString())) ) {
                                                phases->add(phaseSpec);
                                        }
                                }
                        }
                }
        }
//      t2 = JTime();
//      logstr += JString::format("getTriggers: %f [%d] ", t2.microDifference(t)/1000.0, phases->getCount());
//      printf("    %s\n", (char*) logstr);

        delete(activePhases);

        copy->addAll(phases);
        getTriggersCache->put(cacheString, copy);
        if (getTriggersCache->getCount() > 100)
                getTriggersCache->removeFirst();

        return phases;
}

ObjectCollection* ModuleSpec::getActiveContexts() {

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

        ContextSpec* contextSpec;
        for (int n=0; n<contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) contexts->get(n);
                if (contextSpec != NULL) {
                        if (contextSpec->isActive()) {
                                activeContexts->add(contextSpec);
                        }
                }
        }

/*
        // If we only allow one active context at a time, do the following
        if (activeContexts->getCount() > 1) {
                
                ObjectCollection* activeContexts2 = new ObjectCollection();
                activeContexts2->noDelete();
                DotString currentDot = currentContext.toDotString();
                DotString matchDot;

                for (int i=currentDot.getCount(); i>0; i--) {
                        // for x.y.z, first try x.y.z, then x.y, then x
                        matchDot = currentDot.getFirst(i);
                        for (int m=0; m<activeContexts->getCount(); m++) {
                                contextSpec = (ContextSpec*) activeContexts->get(m);
                                if (contextSpec != NULL) {
                                        if (contextSpec->ownContext.equals(matchDot)) {
                                                activeContexts2->add(contextSpec);
                                                delete(activeContexts);
                                                return activeContexts2;
                                        }
                                }
                        }
                }
                delete(activeContexts2);
        }
*/
        return activeContexts;
}

PhaseSpec* ModuleSpec::getFirstActivePhase() {
        ObjectCollection* activeContexts = getActiveContexts();

        PhaseSpec* phaseSpec = NULL;
        ObjectCollection* localPhases;
        ContextSpec* contextSpec;
        for (int n=0; n<activeContexts->getCount(); n++) {
                contextSpec = (ContextSpec*) activeContexts->get(n);
                if (contextSpec != NULL) {
                        localPhases = contextSpec->getActivePhases();
                        if (localPhases != NULL) {
                                phaseSpec = (PhaseSpec*) localPhases->getFirst();
                                delete(localPhases);
                                if (phaseSpec != NULL)
                                        break;
                        }
                }
        }
        delete(activeContexts); 
        return phaseSpec;
}

ObjectCollection* ModuleSpec::getActivePhases() {

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

        ObjectCollection* localPhases;

        ObjectCollection* activeContexts = getActiveContexts();

        ContextSpec* contextSpec;
        for (int n=0; n<activeContexts->getCount(); n++) {
                contextSpec = (ContextSpec*) activeContexts->get(n);
                if (contextSpec != NULL) {
                        localPhases = contextSpec->getActivePhases();
                        if (localPhases != NULL) {
                                activePhases->addAll(localPhases);
                                delete(localPhases);
                        }
                }
        }
        delete(activeContexts); 
        return activePhases;
}

ObjectCollection* ModuleSpec::getAllPhases() {

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

        ObjectCollection* localPhases;

        ObjectCollection* activeContexts = getActiveContexts();

        ContextSpec* contextSpec;
        for (int n=0; n<activeContexts->getCount(); n++) {
                contextSpec = (ContextSpec*) activeContexts->get(n);
                if (contextSpec != NULL) {
                        localPhases = contextSpec->getAllPhases();
                        if (localPhases != NULL) {
                                allPhases->addAll(localPhases);
                                delete(localPhases);
                        }
                }
        }
        delete(activeContexts); 
        return allPhases;
}

Collection ModuleSpec::getReferredWhiteboards() {

        Collection whiteboardNames;

        int i, j, n;
        ContextSpec* contextSpec;
        PhaseSpec* phaseSpec;
        TriggerSpec* trigger;
        RetrieveSpec* retrieve;
        PostSpec* post;
        for (j=0; j < contexts->getCount(); j++) {
                if ( (contextSpec = (ContextSpec*) contexts->get(j)) != NULL) {
                        for (i=0; i < contextSpec->phases->getCount(); i++) {
                                if ( (phaseSpec = (PhaseSpec*) contextSpec->phases->get(i)) != NULL) {
                                        for (n=0; n<phaseSpec->triggers->getCount(); n++) {
                                                if ( (trigger = (TriggerSpec*) phaseSpec->triggers->get(n)) != NULL) {
                                                        if (trigger->from.length() > 0)
                                                                if (!whiteboardNames.contains(trigger->from))
                                                                        whiteboardNames.add(trigger->from);
                                                }
                                        }
                                        for (n=0; n<phaseSpec->retrieves->getCount(); n++) {
                                                if ( (retrieve = (RetrieveSpec*) phaseSpec->retrieves->get(n)) != NULL) {
                                                        if (retrieve->from.length() > 0)
                                                                if (!whiteboardNames.contains(retrieve->from))
                                                                        whiteboardNames.add(retrieve->from);
                                                }
                                        }
                                        for (n=0; n<phaseSpec->posts->getCount(); n++) {
                                                if ( (post = (PostSpec*) phaseSpec->posts->get(n)) != NULL) {
                                                        if (post->to.length() > 0)
                                                                if (!whiteboardNames.contains(post->to))
                                                                        whiteboardNames.add(post->to);
                                                }
                                        }
                                }
                        }
                }
        }

        return whiteboardNames;
}

Collection ModuleSpec::getReferredStreams() {

        Collection streamNames;

        int i, j, n;
        ContextSpec* contextSpec;
        PhaseSpec* phaseSpec;
        StreamAccess* streamAccess;
        for (j=0; j < contexts->getCount(); j++) {
                if ( (contextSpec = (ContextSpec*) contexts->get(j)) != NULL) {
                        for (i=0; i < contextSpec->phases->getCount(); i++) {
                                if ( (phaseSpec = (PhaseSpec*) contextSpec->phases->get(i)) != NULL) {
                                        for (n=0; n<phaseSpec->streams->getCount(); n++) {
                                                if ( (streamAccess = (StreamAccess*) phaseSpec->streams->get(n)) != NULL) {
                                                        if (streamAccess->source.length() > 0)
                                                                if (!streamNames.contains(streamAccess->source))
                                                                        streamNames.add(streamAccess->source);
                                                }
                                        }
                                }
                        }
                }
        }

        return streamNames;
}

JString ModuleSpec::toHTML() {
        
        JString html;
        
        if (contexts->getCount() == 0)
                html = JString::format("Module: <I>%s</I> has no contexts\n", (char*) moduleName);
        else if (contexts->getCount() == 1)
                html = JString::format("Module: <I>%s</I> has %d parameters and one context\n", (char*) moduleName, parameters->getCount());
        else
                html = JString::format("Module: <I>%s</I> has %d parameters and %d contexts\n", (char*) moduleName, parameters->getCount(), contexts->getCount());


        ContextSpec* contextSpec;
        PhaseSpec *phaseSpec;
        JString contextName;
        ObjectCollection phases;

        for (int n=0; n<contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) contexts->get(n);
                if (contextSpec != NULL) {
//                      phases = contextSpec->phases;

                        if (contextSpec->phases->getCount() == 0)
                                html += JString::format("Context: <I>%s</I> has no phases\n", (char*) contextName);
                        else if (contextSpec->phases->getCount() == 1)
                                html += JString::format("Context: <I>%s</I> has one phase\n", (char*) contextName);
                        else
                                html += JString::format("Context: <I>%s</I> has %d phases\n", (char*) contextName, contextSpec->phases->getCount());

                        for (int m=0; m<contextSpec->phases->getCount(); m++) {
                                phaseSpec = (PhaseSpec*) contextSpec->phases->get(m);
                                if (phaseSpec != NULL) {
                                        html += phaseSpec->toHTML();
                                        html += "<hr>";
                                }
                        }
                }
        }

        return html;
}


JString ModuleSpec::toHTMLCurrent() {
        
        // Not currently in use

        JString html;

        html += "<table width=\"100%\" border=\"0\">";
        html += "<tr><td width=\"10\"></td><td width=\"15\"></td><td width=\"8000\"></td><td width=\"20\"></td></tr>";
        
        html += "<tr><td></td>";

        ObjectCollection* activeContexts = getActiveContexts();
        if (activeContexts->getCount() == 0) {
                html += "<td colspan=\"3\" bgcolor=\"#eeeeee\">";
                html += JString::format("<font color=\"#0000ff\" size=\"4\">Module: <I>%s</I> is currently out of context</font>\n", (char*) moduleName);
                html += "</td></tr></table>";
                delete(activeContexts);
                return html;
        }

        html += "<td colspan=\"2\" bgcolor=\"#eeeeee\">";
        html += JString::format("<font color=\"#0000ff\" size=\"4\">Module: <I>%s</I></font></td>\n", (char*) moduleName);
        
        html += JString::format("<td align=\"right\"><input type=\"submit\" name=\"switchphase_%s\" value=\"Change Phase\"></td></tr>\n", (char*) moduleName);

        ObjectCollection* activePhases = getActivePhases();
        if (activePhases->getCount() == 0) {
                html += JString::format("<tr><td></td><td></td><td><font color=\"#00ff00\" size=\"4\">No active contexts...</font>\n");
                html += "</td><td></td></tr></table>";
                delete(activePhases);
                delete(activeContexts);
                return html;
        }

        PhaseSpec *phaseSpec;
        for (int i=0; i<activePhases->getCount(); i++) {
                phaseSpec = (PhaseSpec*) activePhases->get(i);
                if (phaseSpec != NULL) {
                        html += "<tr><td></td><td></td><td colspan=\"2\">";
                //      html += JString::format("<font color=\"#0000ff\" size=\"4\">Active Context: <I>%s</I><br></font>\n");
                        html += JString("<font color=\"#0000ff\" size=\"3\">Active ") + phaseSpec->toHTML();
                        html += "</font></td></tr>";
                }
        }
        html += "</table>";

        delete(activePhases);
        delete(activeContexts);
        return html;
}


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


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

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

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

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





















//////////////////////////////////////////////////////////////////////
// Whiteboard Spec
//////////////////////////////////////////////////////////////////////

WhiteboardSpec::WhiteboardSpec() {
        streamSpecs = new ObjectDictionary();
        catalogSpecs = new ObjectDictionary();
        parameters = new ObjectDictionary();
        priority = 0;
        useLocalSystemInfo = false;
}

WhiteboardSpec::WhiteboardSpec(const JString& xml) {
        streamSpecs = new ObjectDictionary();
        catalogSpecs = new ObjectDictionary();
        parameters = new ObjectDictionary();
        priority = 0;
        useLocalSystemInfo = false;
        fromXML(xml);
}

WhiteboardSpec::WhiteboardSpec(XMLNode* node) {
        streamSpecs = new ObjectDictionary();
        catalogSpecs = new ObjectDictionary();
        parameters = new ObjectDictionary();
        priority = 0;
        useLocalSystemInfo = false;
        fromXML(node);
}

WhiteboardSpec::~WhiteboardSpec() {
        delete(streamSpecs);
        delete(catalogSpecs);
        delete(parameters);
}

//! Get total size of payload
unsigned long WhiteboardSpec::getPayloadSize() const {
        unsigned long payloadSize = whiteboardName.getPayloadSize() + description.getPayloadSize() + remote.getPayloadSize();

        if (streamSpecs != NULL) payloadSize += streamSpecs->getPayloadSize();
        if (catalogSpecs != NULL) payloadSize += catalogSpecs->getPayloadSize();

        return payloadSize;
}

Object* WhiteboardSpec::clone() const { 
        WhiteboardSpec* spec = new WhiteboardSpec();
        spec->description = this->description;
        spec->whiteboardName = this->whiteboardName;
//      spec->maxCount = this->maxCount;
        spec->remote = this->remote;
        spec->priority = this->priority;
        spec->streamSpecs->copyAll(streamSpecs);
        spec->catalogSpecs->copyAll(catalogSpecs);
        spec->parameters->copyAll(parameters);
        spec->useLocalSystemInfo = useLocalSystemInfo;
        return spec;
}

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

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

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

bool WhiteboardSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("whiteboard")) )
                return false;

        streamSpecs->removeAll();

        whiteboardName = node->findAttr("name");
        if (node->hasAttribute("remote"))
                remote = node->findAttr("remote");
        else
                remote = node->findAttr("satellite");
        if (node->hasAttribute("priority"))
                priority = node->findAttr("priority").toDouble();

        if (node->getAttribute("cachedglobalstate").equalsIgnoreCase("yes"))
                useLocalSystemInfo = true;

        XMLNode* xmlNode = node->getChildNode("description");
        if (xmlNode == NULL)
                description = "";
        else
                description = xmlNode->getTextContent();

        ObjectDictionary* myParameters = Parameter::getParameterCollectionFromNode(node->getChildNode("parameters"));
        if (myParameters != NULL) {
                delete(parameters);
                parameters = myParameters;
        }
        myParameters = Parameter::getParameterCollectionFromNode(node->getChildNode("parameters"));
        if (myParameters != NULL) {
                if (parameters == NULL)
                        parameters = myParameters;
                else {
                        parameters->addAll(myParameters);
                        myParameters->removeAllNoDelete();
                        delete(myParameters);
                }
        }
        Parameter* parameter;
        ObjectCollection paramNodes = node->getChildNodes("parameter");
        for (XMLNode* paramNode = (XMLNode*) paramNodes.getFirst(); paramNode != NULL; paramNode = (XMLNode*) paramNodes.getNext()) {
                parameter = new Parameter(paramNode);
                if (parameter->name.length() > 0) {
                        if (parameters == NULL)
                                parameters = new ObjectDictionary();
                        parameters->put(parameter->name, parameter);
                }
                else {
                        delete(parameter);
                }
        }

        if (node->hasAttribute("maxcount")) {
                JString maxCount = node->findAttr("maxcount");
                if (maxCount.length() > 0) {
                        parameter = (Parameter*) parameters->get("maxMessages");
                        if (parameter == NULL) {
                                parameter = new Parameter("maxMessages", "Integer", maxCount, maxCount);
                                parameters->put("maxMessages", parameter);
                        }
                        else {
                                parameter->set(maxCount);
                        }
                }
        }

        StreamSpec* streamSpec;
        xmlNode = node->getChildNode("streams");
        if (xmlNode == NULL)
                xmlNode = node->getChildNode("mediastreams");
        if (xmlNode != NULL) {
                ObjectCollection* col = xmlNode->getChildTags();
                if (col != NULL) {
                        for (int m=0; m<col->getCount(); m++) {
                                xmlNode = (XMLNode*) col->get(m);
                                if (xmlNode != NULL) {
                                        streamSpec = new StreamSpec(xmlNode);
                                        streamSpec->parent = whiteboardName;
                                        streamSpecs->put(streamSpec->streamName, streamSpec);
                                }
                        }
                }
        }

        ObjectCollection streamsNodes = node->getChildNodes("stream");
        for (XMLNode* streamsNode = (XMLNode*) streamsNodes.getFirst(); streamsNode != NULL; streamsNode = (XMLNode*) streamsNodes.getNext()) {
                streamSpec = new StreamSpec(streamsNode);
                streamSpec->parent = whiteboardName;
                streamSpecs->put(streamSpec->streamName, streamSpec);
        }

        CatalogSpec* catalogSpec = NULL;
        xmlNode = node->getChildNode("catalogs");
        if (xmlNode != NULL) {
                ObjectCollection* col = xmlNode->getChildTags();
                if (col != NULL) {
                        for (int m=0; m<col->getCount(); m++) {
                                xmlNode = (XMLNode*) col->get(m);
                                if (xmlNode != NULL) {
                                        catalogSpec = new CatalogSpec(xmlNode);
                                        catalogSpec->parent = whiteboardName;
                                        catalogSpecs->put(catalogSpec->name, catalogSpec);
                                }
                        }
                }
        }

        ObjectCollection catalogsNodes = node->getChildNodes("catalog");
        for (XMLNode* catalogsNode = (XMLNode*) catalogsNodes.getFirst(); catalogsNode != NULL; catalogsNode = (XMLNode*) catalogsNodes.getNext()) {
                catalogSpec = new CatalogSpec(catalogsNode);
                catalogSpec->parent = whiteboardName;
                catalogSpecs->put(catalogSpec->name, catalogSpec);
        }

        return true;
}

JString WhiteboardSpec::toXML() {
        JString xml, subxml;
        int n;

        if (description.length() > 0)
                xml += JString::format("<description>%s</description>\n", (char*) description.xmlStringEncode());

        Parameter* parameter;
        for (n=0; n<parameters->getCount(); n++) {
                parameter = (Parameter*) parameters->get(n);
                if (parameter != NULL)
                        xml += JString::format("%s\n", (char*) parameter->toXML());
                //      subxml += JString::format("%s\n", (char*) parameter->toXML());
        }

//      if (subxml.length() > 0) {
//              xml += JString::format("<parameters>\n%s</parameters>\n", (char*) subxml.indentXML());
//      }

        subxml = "";
        StreamSpec* streamSpec;
        for (n=0; n<streamSpecs->getCount(); n++) {
                streamSpec = (StreamSpec*) streamSpecs->get(n);
                if (streamSpec != NULL) {
                        subxml += streamSpec->toXML() + "\n";
                }
        }
        if (subxml.length() > 0)
                xml += JString::format("<streams>\n%s</streams>", (char*) subxml.indentXML());

        subxml = "";
        CatalogSpec* catalogSpec;
        for (n=0; n<catalogSpecs->getCount(); n++) {
                catalogSpec = (CatalogSpec*) catalogSpecs->get(n);
                if (catalogSpec != NULL) {
                        subxml += catalogSpec->toXML() + "\n";
                }
        }
        if (subxml.length() > 0)
                xml += JString::format("<catalogs>\n%s</catalogs>", (char*) subxml.indentXML());

        JString location;
        if (remote.length() > 0)
                location = JString::format("satellite=\"%s\" ", (char*) remote.xmlStringEncode());
        if (useLocalSystemInfo)
                location += "cachedglobalstate=\"yes\" ";

        if (xml.length() > 0) {
                return JString::format("<whiteboard name=\"%s\" priority=\"%.1f\" %s>\n%s</whiteboard>",
                        (char*) whiteboardName.xmlStringEncode(), priority, (char*) location, (char*) xml.indentXML());
        }

//      return JString::format("<whiteboard name=\"%s\" priority=\"%.1f\" maxcount=\"%ld\" %s></whiteboard>", (char*) whiteboardName, priority, maxCount, (char*) location);
        return JString::format("<whiteboard name=\"%s\" priority=\"%.1f\" %s></whiteboard>", (char*) whiteboardName.xmlStringEncode(), priority, (char*) location);
}



JString WhiteboardSpec::toHTML() {
        JString html;
        return html;
}


















//////////////////////////////////////////////////////////////////////
// Stream Spec
//////////////////////////////////////////////////////////////////////

StreamSpec::StreamSpec() {
        allowMultipleWriters = false;
        maxSize = 0;
        maxCount = 0;
        maxBackupCount = 0;
}

StreamSpec::StreamSpec(const JString& xml) {
        allowMultipleWriters = false;
        maxSize = 0;
        maxCount = 0;
        maxBackupCount = 0;
        fromXML(xml);
}

StreamSpec::StreamSpec(XMLNode* node) {
        allowMultipleWriters = false;
        maxSize = 0;
        maxCount = 0;
        maxBackupCount = 0;
        fromXML(node);
}

StreamSpec::~StreamSpec() {
}

//! Get total size of payload
unsigned long StreamSpec::getPayloadSize() const {
        unsigned long payloadSize = streamName.getPayloadSize() + description.getPayloadSize() + parent.getPayloadSize() + remote.getPayloadSize();
        return payloadSize;
}

Object* StreamSpec::clone() const { 
        StreamSpec* spec = new StreamSpec();
        spec->description = this->description;
        spec->streamName = this->streamName;
        spec->maxSize = this->maxSize;
        spec->maxCount = this->maxCount;
        spec->maxBackupCount = this->maxBackupCount;
        spec->parent = this->parent;
        spec->remote = this->remote;
        spec->allowMultipleWriters = this->allowMultipleWriters;
        return spec;
}

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

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

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

bool StreamSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("stream")) )
                return false;

        streamName = node->findAttr("name");
        maxSize = node->findAttr("maxsize").toLong();
        maxCount = node->findAttr("maxcount").toLong();
        maxBackupCount = node->findAttr("maxbackupcount").toLong();
        allowMultipleWriters = node->getAttribute("allowmultiplewriters").equalsIgnoreCase("yes");

        if (node->hasAttribute("remote"))
                remote = node->findAttr("remote");
        else
                remote = node->findAttr("satellite");

        XMLNode* xmlNode = node->getChildNode("description");
        if (xmlNode == NULL)
                description = "";
        else
                description = xmlNode->getTextContent();

        return true;
}

JString StreamSpec::toXML() {
        JString xml;

        if (description.length() > 0)
                xml += JString::format("<description>%s</description>\n", (char*) description.xmlStringEncode());

        JString params;
        if (allowMultipleWriters)
                params = " allowmultiplewriters=\"yes\"";

        if (xml.length() > 0) {
                return JString::format("<stream name=\"%s\" maxsize=\"%ld\" maxcount=\"%ld\" maxbackupcount=\"%ld\" satellite=\"%s\"%s>\n%s</stream>",
                        (char*) streamName.xmlStringEncode(), maxSize, maxCount, maxBackupCount, (char*) remote, (char*) params, (char*) xml.indentXML());
        }

        return JString::format("<stream name=\"%s\" maxsize=\"%ld\" maxcount=\"%ld\" maxbackupcount=\"%ld\" satellite=\"%s\"%s />",
                (char*) streamName.xmlStringEncode(), maxSize, maxCount, maxBackupCount, (char*) remote, (char*) params);
}



JString StreamSpec::toHTML() {
        JString html;
        return html;
}











//////////////////////////////////////////////////////////////////////
// Stream Spec
//////////////////////////////////////////////////////////////////////

StreamAccess::StreamAccess() {
}

StreamAccess::StreamAccess(const JString& xml) {
        fromXML(xml);
}

StreamAccess::StreamAccess(XMLNode* node) {
        fromXML(node);
}

StreamAccess::~StreamAccess() {
}

//! Get total size of payload
unsigned long StreamAccess::getPayloadSize() const {
        return alias.getPayloadSize() + source.getPayloadSize() + mode.getPayloadSize();
}

Object* StreamAccess::clone() const { 
        StreamAccess* spec = new StreamAccess();
        spec->alias = this->alias;
        spec->source = this->source;
        spec->mode = this->mode;
        return spec;
}

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

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

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

bool StreamAccess::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().containsIgnoreCase("stream")) )
                return false;

        mode = node->getTag();
        if (node->hasAttribute("alias"))
                alias = node->findAttr("alias");
        else
                alias = node->findAttr("name");
        source = node->findAttr("source");
        return true;
}

JString StreamAccess::toXML() {
        return JString::format("<%s alias=\"%s\" source=\"%s\" />", (char*) mode, (char*) alias.xmlStringEncode(), (char*) source.xmlStringEncode());
}



JString StreamAccess::toHTML() {
        JString html;
        return html;
}









//////////////////////////////////////////////////////////////////////
// Catalog Spec
//////////////////////////////////////////////////////////////////////

CatalogSpec::CatalogSpec() {
}

CatalogSpec::CatalogSpec(const JString& xml) {
        fromXML(xml);
}

CatalogSpec::CatalogSpec(XMLNode* node) {
        fromXML(node);
}

CatalogSpec::~CatalogSpec() {
}

//! Get total size of payload
unsigned long CatalogSpec::getPayloadSize() const {
        return name.getPayloadSize() + remote.getPayloadSize() + description.getPayloadSize() +
                parent.getPayloadSize() + queryhandler.getPayloadSize() + plug.getPayloadSize() +
                parameters.getPayloadSize();
}

Object* CatalogSpec::clone() const { 
        CatalogSpec* spec = new CatalogSpec();
        spec->description = this->description;
        spec->name = this->name;
        spec->remote = this->remote;
        spec->parent = this->parent;
        spec->queryhandler = this->queryhandler;
        spec->plug = this->plug;
        spec->parameters.copyAll(this->parameters);
        return spec;
}

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

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

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

bool CatalogSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("Catalog")) )
                return false;

        Dictionary* attr = node->getAttributes();
        if (attr == NULL)
                return false;

        JString key;
        Parameter* parameter;
        for (int n=0; n<attr->getCount(); n++) {
                key = attr->getKey(n);
                if (key.equalsIgnoreCase("name"))
                        name = attr->get(n);
                else if (key.equalsIgnoreCase("remote"))
                        remote = attr->get(n);
                else if (key.equalsIgnoreCase("plug"))
                        plug = attr->get(n);
                else if (key.equalsIgnoreCase("queryhandler"))
                        queryhandler = attr->get(n);
                else if (key.equalsIgnoreCase("category"))
                        queryhandler = attr->get(n);
                else if (key.equalsIgnoreCase("query"))
                        queryhandler = attr->get(n);
                else if (key.length() > 0) {
                        parameter = new Parameter(key, "String", attr->get(n));
                        parameters.put(key, parameter);
                }
        }

        //name = node->findAttr("name");
        //remote = node->findAttr("remote");
        //if (node->hasAttribute("plug"))
        //      plug = node->getAttribute("plug");
        //else if (node->hasAttribute("queryhandler"))
        //      queryhandler = node->getAttribute("queryhandler");
        //else if (node->hasAttribute("category"))
        //      queryhandler = node->getAttribute("category");

        XMLNode* xmlNode = node->getChildNode("description");
        if (xmlNode == NULL)
                description = "";
        else
                description = xmlNode->getTextContent();

        ObjectCollection paramNodes = node->getChildNodes("parameter");
        for (XMLNode* paramNode = (XMLNode*) paramNodes.getFirst(); paramNode != NULL; paramNode = (XMLNode*) paramNodes.getNext()) {
                parameter = new Parameter(paramNode);
                if (parameter->name.length() > 0) {
                        parameters.put(parameter->name, parameter);
                }
                else {
                        delete(parameter);
                }
        }

        return true;
}

JString CatalogSpec::toXML() {
        JString xml;

        if (description.length() > 0)
                xml += JString::format("<description>%s</description>\n", (char*) description.xmlStringEncode());

        Parameter* parameter;
        for (int n=0; n<parameters.getCount(); n++) {
                parameter = (Parameter*) parameters.get(n);
                if (parameter != NULL)
                        xml += JString::format("%s\n", (char*) parameter->toXML());
        }

        JString attributes;
        if (plug.length() > 0)
                attributes = JString::format("name=\"%s\" plug=\"%s\"", (char*) name.xmlStringEncode(), (char*) plug.xmlStringEncode());
        else if (queryhandler.length() > 0)
                attributes = JString::format("name=\"%s\" category=\"%s\"", (char*) name.xmlStringEncode(), (char*) queryhandler.xmlStringEncode());
        else
                attributes = JString::format("name=\"%s\"", (char*) name.xmlStringEncode());

        if (xml.length() > 0) {
                return JString::format("<catalog %s remote=\"%s\">\n%s</catalog>", (char*) attributes, (char*) xml.indentXML(), (char*) remote.xmlStringEncode());
        }

        return JString::format("<catalog %s />", (char*) attributes);
}



JString CatalogSpec::toHTML() {
        JString html;
        return html;
}








//////////////////////////////////////////////////////////////////////
// Executable Spec
//////////////////////////////////////////////////////////////////////

ExecutableSpec::ExecutableSpec() {
        consoleOutput = false;
        autoRestart = false;
}

ExecutableSpec::ExecutableSpec(const JString& xml) {
        consoleOutput = false;
        autoRestart = false;
        fromXML(xml);
}

ExecutableSpec::ExecutableSpec(XMLNode* node) {
        consoleOutput = false;
        autoRestart = false;
        fromXML(node);
}

ExecutableSpec::~ExecutableSpec() {
}

//! Get total size of payload
unsigned long ExecutableSpec::getPayloadSize() const {
        return name.getPayloadSize() + startupDir.getPayloadSize() + sysSpecs.getPayloadSize() +
                commandLines.getPayloadSize();
}

Object* ExecutableSpec::clone() const { 
        ExecutableSpec* spec = new ExecutableSpec();
        spec->consoleOutput = consoleOutput;
        spec->autoRestart = autoRestart;
        spec->name = name;
        spec->startupDir = startupDir;
        spec->sysSpecs.copyAll(sysSpecs);
        spec->commandLines.copyAll(commandLines);
        return spec;
}

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

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

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

bool ExecutableSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("executable")) )
                return false;

        name = node->getAttribute("name");
        if (node->hasAttribute("consoleoutput"))
                consoleOutput = node->getAttribute("consoleoutput").equalsIgnoreCase("yes");
        if (node->hasAttribute("autorestart"))
                autoRestart = node->getAttribute("autorestart").equalsIgnoreCase("yes");
        if (node->hasAttribute("startupdir"))
                startupDir = node->getAttribute("startupdir");

        JString cmdline;
        SysInfo* sysInfo;
        JString id;

        ObjectCollection sysNodes = node->getChildNodes("sys");
        if (sysNodes.getCount() == 0)
                sysNodes = node->getChildNodes("command");
        if (sysNodes.getCount() == 0) {
                if ((cmdline = node->getTextContent()).length() > 0) {
                        sysInfo = new SysInfo();
                        sysInfo->clear();
                        id = createUniqueID();
                        sysSpecs.put(id, sysInfo);
                        commandLines.put(id, cmdline);
                }
        }
        else {
                for (XMLNode* sysNode = (XMLNode*) sysNodes.getFirst(); sysNode != NULL; sysNode = (XMLNode*) sysNodes.getNext()) {
                        sysInfo = new SysInfo();
                        if (sysInfo->fromXML(sysNode)) {
                                if ((cmdline = sysNode->getTextContent()).length() > 0) {
                                        id = createUniqueID();
                                        sysSpecs.put(id, sysInfo);
                                        commandLines.put(id, cmdline);
                                }
                        }
                }
        }

        return true;
}

JString ExecutableSpec::toXML() {
        JString xml;

        JString cmdline;
        SysInfo* sysInfo;
        for (JString key = sysSpecs.getFirstKey(); key.length() > 0; key = sysSpecs.getNextKey()) {
                if (( (sysInfo = (SysInfo*) sysSpecs.get(key)) != NULL) &&
                        ( (cmdline = commandLines.get(key)).length() > 0 ) ) {
                        xml += sysInfo->toXML("command", cmdline);
                }
        }

        return JString::format("<executable name=\"%s\" consoleoutput=\"%s\" autorestart=\"%s\" startupdir=\"%s\">\n%s</executable>",
                (char*) name.xmlStringEncode(), (char*) JString(consoleOutput), (char*) JString(autoRestart), (char*) startupDir, (char*) xml.indentXML());
}


JString ExecutableSpec::getMatchingCommandLine() {
        SysInfo* sysInfo = new SysInfo();
        sysInfo->update();
        JString cmdline = getMatchingCommandLine(sysInfo);
        delete(sysInfo);
        return cmdline;
}

JString ExecutableSpec::getMatchingCommandLine(SysInfo* sysInfo) {

        JString cmdline;
        SysInfo* storedSysInfo;
        for (JString key = sysSpecs.getFirstKey(); key.length() > 0; key = sysSpecs.getNextKey()) {
                if (( (storedSysInfo = (SysInfo*) sysSpecs.get(key)) != NULL) &&
                        ( (storedSysInfo->equals(sysInfo))) &&
                        ( (cmdline = commandLines.get(key)).length() > 0 ) ) {
                        return cmdline;
                }
        }
        return "";
}


JString ExecutableSpec::toHTML() {
        JString html;
        return html;
}








//////////////////////////////////////////////////////////////////////
// Satellite Spec
//////////////////////////////////////////////////////////////////////

SatelliteSpec::SatelliteSpec() {
}

SatelliteSpec::SatelliteSpec(const JString& xml) {
        port = 0;
        fromXML(xml);
}

SatelliteSpec::SatelliteSpec(XMLNode* node) {
        port = 0;
        fromXML(node);
}

SatelliteSpec::~SatelliteSpec() {
}

//! Get total size of payload
unsigned long SatelliteSpec::getPayloadSize() const {
        return name.getPayloadSize() + host.getPayloadSize();
}

Object* SatelliteSpec::clone() const { 
        SatelliteSpec* spec = new SatelliteSpec();
        spec->name = this->name;
        spec->host = this->host;
        spec->port = this->port;
        return spec;
}

TCPLocation SatelliteSpec::getTCPLocation() {
        return TCPLocation(host, port, name);
}


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

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

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

bool SatelliteSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("Satellite")) )
                return false;

        name = node->findAttr("name");
        host = node->findAttr("host");
        if (node->hasAttribute("daemonport"))
                port = node->findAttr("daemonport").toInt();
        else if (node->hasAttribute("demonport"))
                port = node->findAttr("demonport").toInt();
        else if (node->hasAttribute("deamonport"))
                port = node->findAttr("deamonport").toInt();
        else if (node->hasAttribute("port"))
                port = node->findAttr("port").toInt();
        else
                port = 10000;
        return true;

/*      XMLNode* xmlNode = node->getChildNode("executables");
        if (xmlNode == NULL)
                return true;

        ExecutableSpec* exeSpec;
        ObjectCollection children = xmlNode->getChildTags();

        XMLNode* child;
        for (int n=0; n<children.getCount(); n++) {
                child = (XMLNode*) children.get(n);
                if ( (child != NULL) && (child->getTag().equalsIgnoreCase("executable")) ) {
                        exeSpec = new ExecutableSpec(child);
                        executables->put(exeSpec->name, exeSpec);
                }
        }

        return true;*/
}

JString SatelliteSpec::toXML() {

/*      JString xml;
        JString subxml;

        ExecutableSpec* exeSpec;
        for (int n=0; n<executables->getCount(); n++) {
                exeSpec = (ExecutableSpec*) executables->get(n);
                if (exeSpec != NULL) {
                        subxml += exeSpec->toXML() + "\n";
                }
        }

        if (subxml.length() > 0)
                return JString::format("<satellite name=\"%s\" location=\"%s\">\n%s</satellite>", (char*) name, (char*) location, (char*) subxml.indentXML());
        else*/
                return JString::format("<satellite name=\"%s\" host=\"%s\" port=\"%d\" />", (char*) name.xmlStringEncode(), (char*) host.xmlStringEncode(), port);
}



JString SatelliteSpec::toHTML() {
        JString html;
        return html;
}








//////////////////////////////////////////////////////////////////////
// ActionSpec Spec
//////////////////////////////////////////////////////////////////////

ActionSpec::ActionSpec() {
        delay = 0;
        object = NULL;
        answer = NULL;
}

ActionSpec::ActionSpec(JString name, JString act, JString value, JString target, Object* obj, JString content) {
        delay = 0;
        this->name = name;
        this->act = act;
        this->target = target;
        this->content = content;
        this->value = value;
        this->object = obj;
        answer = NULL;
}

ActionSpec::ActionSpec(const JString& xml) {
        delay = 0;
        object = NULL;
        answer = NULL;
        fromXML(xml);
}

ActionSpec::ActionSpec(XMLNode* node) {
        delay = 0;
        object = NULL;
        answer = NULL;
        fromXML(node);
}

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

//! Get total size of payload
unsigned long ActionSpec::getPayloadSize() const {
        unsigned long payloadSize =
                name.getPayloadSize() + state.getPayloadSize() + target.getPayloadSize() +
                act.getPayloadSize() + value.getPayloadSize() + content.getPayloadSize() +
                params.getPayloadSize();

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

        return payloadSize;
}

Object* ActionSpec::clone() const { 
        ActionSpec* spec = new ActionSpec();
        spec->name = this->name;
        spec->delay = this->delay;
        spec->target = this->target;
        spec->act = this->act;
        spec->value = this->value;
        spec->content = this->content;
        spec->state = this->state;
        if (object != NULL)
                spec->object = this->object->clone();
        if (answer != NULL)
                spec->answer = this->answer->clone();
        spec->params.copyAll(this->params);
        return spec;
}

bool ActionSpec::setParameter(JString name, JString value) {
        return params.put(name, value);
}

JString ActionSpec::getParameter(JString name) {
        return params.get(name);
}

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

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

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

bool ActionSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("action")) )
                return false;

        name = node->findAttr("name");
        delay = node->findAttr("delay").toInt();
        target = node->findAttr("target");
        act = node->findAttr("act");
        content = node->findAttr("content");
        value = node->findAttr("value");
        state = node->findAttr("state");

        XMLNode* answerNode;
        ObjectCollection* children = node->getChildTags();
        if (children != NULL) {
                for (XMLNode* xmlNode = (XMLNode*) children->getFirst(); xmlNode != NULL; xmlNode = (XMLNode*) children->getNext()) {
                        if (xmlNode->getTag().equalsIgnoreCase("dictionary")) {
                                params.fromXML(xmlNode);
                        }
                        else if (xmlNode->getTag().equalsIgnoreCase("content"))
                                content = xmlNode->getTextContent(); //.fromHTML();
                        else if (xmlNode->getTag().equalsIgnoreCase("answer")) {
                                if ( (answerNode = (XMLNode*)xmlNode->getFirstChildNode()) != NULL) {
                                        if (answer != NULL)
                                                delete(answer);
                                        answer = createObjectFromXML(answerNode);
                                }
                        }
                        else {
                                if (object != NULL)
                                        delete(object);
                                object = createObjectFromXML(xmlNode);
                        }
                }
        }
        return true;
}

JString ActionSpec::toXML() {

        JString paramsXML;
        if (params.getCount() > 0) {
                paramsXML = params.toXML().indentXML();
        }

        if ( (content.length() == 0) && (object == NULL) && (paramsXML.length() == 0) )
                return JString::format("<action name=\"%s\" delay=\"%d\" state=\"%s\" target=\"%s\" act=\"%s\" value=\"%s\" />",
                        (char*) name.xmlStringEncode(), delay, (char*) state.xmlStringEncode(), (char*) target.xmlStringEncode(), (char*) act.xmlStringEncode(), (char*) value.xmlStringEncode());
        else {
                JString contentXML;
                if (content.length() > 0) {
                        if (content.looksLikeXML())
                                contentXML = JString::format("<content>\n%s</content>", (char*) content.indentXML()).indentXML();
                        else
                                contentXML = JString::format("\t<content>%s</content>", (char*) content.xmlStringEncode());
                }
                JString objectXML;
                if (object != NULL)
                        objectXML = object->toXML().indentXML();
                JString answerXML;
                if (answer != NULL) {
                        answerXML = JString::format("<answer>\n%s</answer>", (char*) answer->toXML().indentXML()).indentXML();
                }

                return JString::format("<action name=\"%s\" delay=\"%d\" state=\"%s\" target=\"%s\" act=\"%s\" value=\"%s\">\n%s%s%s%s</action>",
                        (char*) name.xmlStringEncode(), delay, (char*) state.xmlStringEncode(), (char*) target.xmlStringEncode(), (char*) act.xmlStringEncode(), (char*) value.xmlStringEncode(),
                        (char*) paramsXML, (char*) contentXML, (char*) objectXML, (char*) answerXML);
        }
}

JString ActionSpec::toHTML() {
        JString html;
        return html;
}

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


//! Get the size of any binary data
long ActionSpec::getBinarySize(int chunk) {
        int chunkCountObject = 0, chunkCountAnswer = 0;
        long binarySize = 0;
        if (object != NULL) {
                chunkCountObject = object->getBinaryChunkCount();
                if (chunk <= chunkCountObject)
                        return object->getBinarySize(chunk);
        }
        if (answer != NULL) {
                chunkCountAnswer = answer->getBinaryChunkCount();
                if (chunk > chunkCountObject)
                        return answer->getBinarySize(chunk - chunkCountObject);
        }
        return 0;
}

//! Get the number of data chunks
int ActionSpec::getBinaryChunkCount() {
        int chunkCountObject = 0, chunkCountAnswer = 0;
        if (object != NULL)
                chunkCountObject = object->getBinaryChunkCount();
        if (answer != NULL)
                chunkCountAnswer = answer->getBinaryChunkCount();
        return chunkCountObject + chunkCountAnswer;
}

//! Get a pointer to the binary data at chunk number 'chunk'
long ActionSpec::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        int chunkCountObject = 0, chunkCountAnswer = 0;
        long binarySize = 0;
        if (object != NULL) {
                chunkCountObject = object->getBinaryChunkCount();
                if (chunk <= chunkCountObject)
                        return object->toBinaryBuffer(chunk, buffer, maxlen);
        }
        if (answer != NULL) {
                chunkCountAnswer = answer->getBinaryChunkCount();
                if (chunk > chunkCountObject)
                        return answer->toBinaryBuffer(chunk-chunkCountObject, buffer, maxlen);
        }
        return 0;
}

//! Set the data after separate reception
bool ActionSpec::fromBinaryBuffer(int chunk, char* buffer, long len) {
        int chunkCountObject = 0, chunkCountAnswer = 0;
        long binarySize = 0;
        if (object != NULL) {
                chunkCountObject = object->getBinaryChunkCount();
                if (chunk <= chunkCountObject)
                        return object->fromBinaryBuffer(chunk, buffer, len);
        }
        if (answer != NULL) {
                chunkCountAnswer = answer->getBinaryChunkCount();
                if (chunk > chunkCountObject)
                        return answer->fromBinaryBuffer(chunk-chunkCountObject, buffer, len);
        }
        return 0;
}














//////////////////////////////////////////////////////////////////////
// ClientProfile Spec
//////////////////////////////////////////////////////////////////////

ClientProfile::ClientProfile() {
}

ClientProfile::ClientProfile(const JString& xml) {
        fromXML(xml);
}

ClientProfile::ClientProfile(XMLNode* node) {
        fromXML(node);
}

ClientProfile::~ClientProfile() {
}

//! Get total size of payload
unsigned long ClientProfile::getPayloadSize() const {
        return name.getPayloadSize() + capabilities.getPayloadSize() + connectionProfile.getPayloadSize() +
                thisConvID.getPayloadSize() + lastConvID.getPayloadSize();
}

Object* ClientProfile::clone() const { 
        ClientProfile* spec = new ClientProfile();
        spec->name = this->name;
        spec->lastConvID = this->lastConvID;
        spec->connectionProfile = this->connectionProfile;
        spec->capabilities.copyAll(this->capabilities);
        return spec;
}

bool ClientProfile::equals(const Object* otherProfile) const {
        JString othername = ((ClientProfile*) otherProfile)->name;
        return name.equals(othername);
}

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

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

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

bool ClientProfile::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("clientprofile")) )
                return false;

        name = node->findAttr("name");
        lastConvID = node->findAttr("lastConvID");
        thisConvID = node->findAttr("thisConvID");

        XMLNode* xmlNode = node->getChildNode("objectdictionary");
        if (xmlNode != NULL) {
                capabilities.removeAll();
                capabilities.fromXML(xmlNode);
        }

        xmlNode = node->getChildNode("connectionprofile");
        if (xmlNode != NULL) {
                connectionProfile = ConnectionProfile(xmlNode);
        }

        return true;
}

JString ClientProfile::toXML() {
        return JString::format(
                "<clientprofile name=\"%s\" lastConvID=\"%s\" thisConvID=\"%s\">\n%s%s</clientprofile>",
                (char*) name.xmlStringEncode(), (char*) lastConvID.xmlStringEncode(), (char*) thisConvID.xmlStringEncode(),
                (char*) capabilities.toXML().indentXML(),
                (char*) connectionProfile.toXML().indentXML());
}

JString ClientProfile::toHTML() {
        return JString::format(
                "ClientProfile %s: ConvID=\"%s\"<br>\nCapabilities:<br>%s<br>\n%s<br>\n",
                (char*) name.toHTML(), (char*) thisConvID.toHTML(),
                (char*) capabilities.toHTML(), (char*) connectionProfile.toHTML());
}

JString ClientProfile::print() {
        return JString::format(
                "ClientProfile %s: ConvID=\"%s\"\n%s\n%s\n",
                (char*) name, (char*) thisConvID,
                (char*) capabilities.print(), (char*) connectionProfile.print());
}

JString ClientProfile::getCapability(const JString& category, const JString& capability) {
        Dictionary* dict = (Dictionary*) capabilities.get(category.toLowerCase());
        if (dict != NULL)
                return dict->get(capability.toLowerCase());
        else
                return "";
}

bool ClientProfile::setCapability(const JString& category, const JString& capability, const JString& value) {
        Dictionary* dict = (Dictionary*) capabilities.get(category.toLowerCase());
        if (dict == NULL) {
                dict = new Dictionary();
                capabilities.put(category.toLowerCase(), dict);
        }
        return dict->put(capability.toLowerCase(), value);
}

bool ClientProfile::hasCapability(const JString& category, const JString& capability) {
        Dictionary* dict = (Dictionary*) capabilities.get(category.toLowerCase());
        if (dict != NULL)
                return dict->contains(capability.toLowerCase());
        else
                return false;
}










//////////////////////////////////////////////////////////////////////
// ServiceSpec Spec
//////////////////////////////////////////////////////////////////////

ServiceSpec::ServiceSpec() {
        priority = 0;
        maxConv = 0;
        timeout = 30000;
        moduleSpec = new ModuleSpec();
        moduleSpec->type = "service";
}

ServiceSpec::ServiceSpec(const JString& xml) {
        priority = 0;
        maxConv = 0;
        timeout = 30000;
        moduleSpec = new ModuleSpec();
        fromXML(xml);
        moduleSpec->type = "service";
}

ServiceSpec::ServiceSpec(XMLNode* node) {
        priority = 0;
        maxConv = 0;
        timeout = 30000;
        moduleSpec = new ModuleSpec();
        fromXML(node);
}

ServiceSpec::~ServiceSpec() {
        delete(moduleSpec);
}

//! Get total size of payload
unsigned long ServiceSpec::getPayloadSize() const {
        unsigned long payloadSize = name.getPayloadSize() + service.getPayloadSize() + type.getPayloadSize() +
                remote.getPayloadSize() + provider.getPayloadSize() + location.getPayloadSize();

        if (moduleSpec != NULL) payloadSize += moduleSpec->getPayloadSize();

        return payloadSize;
}

Object* ServiceSpec::clone() const { 
        ServiceSpec* spec = new ServiceSpec();
//      *spec = *this;
        spec->name = this->name;
        spec->service = this->service;
        spec->type = this->type;
        spec->remote = this->remote;
        spec->maxConv = this->maxConv;
        spec->timeout = this->timeout;
        spec->provider = this->provider;
        spec->location = this->location;
        spec->priority = this->priority;
        delete(spec->moduleSpec);
        spec->moduleSpec = (ModuleSpec*) moduleSpec->clone();
        return spec;
}

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

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

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

bool ServiceSpec::fromXML(XMLNode* node) {

        if ( (node == NULL) || (!node->getTag().equalsIgnoreCase("serviceprovider")) )
                return false;

        name = node->findAttr("name");
        service = node->findAttr("service");
        type = node->findAttr("type");
        if (node->hasAttribute("remote"))
                remote = node->findAttr("remote");
        else
                remote = node->findAttr("satellite");
        if (node->hasAttribute("max"))
                maxConv = node->findAttr("max").toInt();
        else
                maxConv = 0;
        if (node->hasAttribute("timeout"))
                timeout = node->findAttr("timeout").toInt();
        else
                timeout = 30000;
        provider = node->findAttr("provider");
//      whiteboard = node->findAttr("whiteboard");

        if (node->hasAttribute("priority"))
                priority = node->findAttr("priority").toDouble();

        XMLNode* xmlNode = node->getChildNode("tcplocation");
        if (xmlNode != NULL)
                location.fromXML(xmlNode);

/*      xmlNode = node->getChildNode("setup");
        if (xmlNode == NULL)
                xmlNode = node->getChildNode("config");
        if (xmlNode != NULL)
                configXML = xmlNode->toXMLChildrenOnly();
        else
                configXML = "";*/

        if (!moduleSpec->fromXML(node)) {
                return false;
        }

        return true;
}

JString ServiceSpec::toXML() {

        JString xml, subxml;

        if (location.isValid()) {
                xml += location.toXML();
        }

        if (moduleSpec->description.length() > 0)
                xml += JString::format("<description>%s</description>\n", (char*) moduleSpec->description.xmlStringEncode());

        if (moduleSpec->allowSelfTriggering)
                xml += JString::format("<allowselftriggering>Yes</allowselftriggering>\n");

        int n = 0;
        Parameter* parameter;
        for (n=0; n<moduleSpec->parameters->getCount(); n++) {
                parameter = (Parameter*) moduleSpec->parameters->get(n);
                if (parameter != NULL)
                        xml += JString::format("%s\n", (char*) parameter->toXML());
                //      subxml += JString::format("%s\n", (char*) parameter->toXML());
        }

//      if (subxml.length() > 0) {
//              xml += JString::format("<parameters>\n%s</parameters>\n", (char*) subxml.indentXML());
//      }

        subxml = "";
        ContextSpec* contextSpec;
        for (n=0; n<moduleSpec->contexts->getCount(); n++) {
                contextSpec = (ContextSpec*) moduleSpec->contexts->get(n);
                if (contextSpec != NULL) {
                        subxml += contextSpec->toXML() + "\n";
                }
        }

        xml += JString::format("<spec>\n%s</spec>\n", (char*) subxml.indentXML());

        if (moduleSpec->configXML.length() > 0) {
                xml += JString::format("\n<config>\n%s</config>", (char*) moduleSpec->configXML.indentXML());
        }

        if (xml.length() > 0) {
                return JString::format(
                        "<serviceprovider name=\"%s\" service=\"%s\" type=\"%s\" max=\"%d\" verbose=\"%d\" provider=\"%s\" timeout=\"%d\" satellite=\"%s\" priority=\"%f\">\n%s</serviceprovider>",
                        (char*) name.xmlStringEncode(), (char*) service.xmlStringEncode(), (char*) type.xmlStringEncode(), maxConv, moduleSpec->verbose, (char*) provider.xmlStringEncode(),
                        timeout, (char*) remote.xmlStringEncode(), priority, (char*) xml.indentXML());
        }
        else {
                return JString::format(
                        "<serviceprovider name=\"%s\" service=\"%s\" type=\"%s\" max=\"%d\" verbose=\"%d\" provider=\"%s\" timeout=\"%d\" satellite=\"%s\" priority=\"%f\" />",
                        (char*) name.xmlStringEncode(), (char*) service.xmlStringEncode(), (char*) type.xmlStringEncode(), maxConv, moduleSpec->verbose, (char*) provider.xmlStringEncode(),
                        timeout, (char*) remote.xmlStringEncode(), priority);
        }
}

JString ServiceSpec::toHTML() {
        JString html;
        return html;
}

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


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

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

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

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
















} // namespace cmlabs

---