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

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

#include "Parameter.h"

namespace cmlabs {

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

Parameter::Parameter(const JString& parametername, const JString& type, const Collection& collValues) {
        name = parametername;
        valueType = type;
        values.removeAll();
        values.copyAll(collValues);
        maxValue = minValue = NOVALUE;
        def = current = 0;
        step = 1;
}

Parameter::Parameter(const JString& parametername, const JString& type, const JString& val, const JString& defaultVal) {
        name = parametername;
        valueType = type;
        value = val;
        if (defaultVal.length() > 0)
                defaultValue = defaultVal;
        else
                defaultValue = val;
        maxValue = minValue = NOVALUE;
        def = current = 0;
        step = 1;
}

/*
Parameter::Parameter(JString parametername, double min, double max, double incr) {
        name = parametername;
        valueType = "Double";
        if (incr != 0) {
                for (double d=min; d<=max; d+=incr)
                        values.add(JString(d));
        }
        else {
                maxValue = max;
                minValue = min;
        }
        value = defaultValue = values.get(0);
        def = current = 0;
}
*/

Parameter::Parameter(const JString& parametername, const JString& type) {
        name = parametername;
        valueType = type;
        maxValue = minValue = NOVALUE;
        step = 1;
}

Parameter::Parameter(const JString& xml) {
        valueType = "String";
        def = current = 0;
        maxValue = minValue = NOVALUE;
        step = 1;
        fromXML(xml);
}

Parameter::Parameter(XMLNode* node) {
        valueType = "String";
        def = current = 0;
        maxValue = minValue = NOVALUE;
        step = 1;
        fromXML(node);
}




Object* Parameter::clone() const {
        Parameter* parameter = new Parameter(name, valueType);
        *parameter = *this;
        parameter->locked = false;
        return (Object*) parameter;
}

Parameter::~Parameter() {
        values.removeAll();
}

//! Get total size of payload
unsigned long Parameter::getPayloadSize() const {
        return name.length() + value.length() + defaultValue.length() + parameterType.length() +
                notify.length() + values.getPayloadSize();
}

JString Parameter::print() {
        JString minmax = "";
        if (minValue != NOVALUE)
                minmax = JString::format(" min=\"%f\"", minValue);
        if (maxValue != NOVALUE)
                minmax += JString::format(" max=\"%f\"", maxValue);
        
        if (values.getCount() > 0) {
                return JString::format("Parameter name=\"%s\" type=\"%s\" value=\"%s\" default=\"%s\" step=\"%f\"%s>\n%s",
                        (char*) getName().xmlStringEncode(), (char*) getType().xmlStringEncode(), (char*) getString().xmlStringEncode(), (char*) defaultValue.xmlStringEncode(),
                        step, (char*) minmax, (char*) values.printListLine("\n", " = ", "'"));
        }
        else {
                return JString::format("Parameter name=\"%s\" type=\"%s\" value=\"%s\" default=\"%s\" step=\"%f\"%s",
                        (char*) getName().xmlStringEncode(), (char*) getType().xmlStringEncode(), (char*) getString().xmlStringEncode(), (char*) defaultValue.xmlStringEncode(),
                        step, (char*) minmax);
        }
}


// ***********************************************************************************
// XML Functions
// ***********************************************************************************

JString Parameter::toXML() {
        // <parameter type="erasedFromMax" value="15" units="integer" />
        JString minmax = "";
        if (minValue != NOVALUE)
                minmax = JString::format(" min=\"%f\"", minValue);
        if (maxValue != NOVALUE)
                minmax += JString::format(" max=\"%f\"", maxValue);
        if (notify.length() > 0)
                minmax += JString::format(" notify=\"%s\"", (char*) notify.xmlStringEncode());
        
        JString xml;
        if (values.getCount() > 0) {
                xml = JString::format("<parameter name=\"%s\" type=\"%s\" value=\"%s\" default=\"%s\" step=\"%f\"%s>\n%s</parameter>",
                        (char*) getName().xmlStringEncode(), (char*) getType().xmlStringEncode(), (char*) getString().xmlStringEncode(), (char*) defaultValue.xmlStringEncode(),
                        step, (char*) minmax, (char*) values.toXML().indentXML());
        }
        else {
                xml = JString::format("<parameter name=\"%s\" type=\"%s\" value=\"%s\" default=\"%s\" step=\"%f\"%s />", (char*) getName().xmlStringEncode(),
                        (char*) getType().xmlStringEncode(), (char*) getString().xmlStringEncode(), (char*) defaultValue.xmlStringEncode(), step, (char*) minmax);
        }
        return xml;
}

bool Parameter::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 Parameter::fromXML(XMLNode* node) {

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

        name = node->getAttribute("name");
        setType(node->findAttr("type"));
        value = node->getAttribute("value");
        notify = node->getAttribute("notify");
        if (node->hasAttribute("default"))
                defaultValue = node->getAttribute("default");
        else
                defaultValue = value;
        if (node->hasAttribute("step"))
                step = node->getAttribute("step").toDouble();
        if (node->hasAttribute("min"))
                minValue = node->getAttribute("min").toDouble();
        if (node->hasAttribute("max"))
                maxValue = node->getAttribute("max").toDouble();

        if (value.length() == 0)
                value = defaultValue;
        else if (defaultValue.length() == 0)
                defaultValue = value;

        XMLNode* subNode = node->getChildNode("collection");
        if (subNode != NULL)
                values.fromXML(subNode);
        else
                values.removeAll();

        return true;
}


// ***********************************************************************************
// Setters
// ***********************************************************************************

bool Parameter::set(const JString& val) {

//      printf("[Parameter] Setting %s param to: %s\n", (char*) valueType, (char*) val);

//      if (valueType.length() == 0)
//              return false;

//      if (!valueType.equalsIgnoreCase("String")) {
//              return setString(val);
//      }
        if (valueType.equalsIgnoreCase("Integer")) {
                return setInteger(val.toInt());
        }
        else if (valueType.equalsIgnoreCase("Double")) {
                return setDouble(val.toDouble());
        }
        else if (valueType.equalsIgnoreCase("Pointer")) {
                return setPointer(val.toPointer());
        }
        else {
                return setString(val);
        }
}

bool Parameter::setType(const JString& type) {
        valueType = type;
        return true;
}

bool Parameter::setMinMax(double min, double max) {

//      if ( (!valueType.equalsIgnoreCase("Double")) &&
//              (!valueType.equalsIgnoreCase("Integer")) )
//              return false;

        minValue = min;
        maxValue = max;

        return true;
}

bool Parameter::setString(const JString& val) {

        if (valueType.length() == 0)
                valueType = "String";

        if (!valueType.equalsIgnoreCase("String")) {
                if (DEBUGLEVEL(STATUS)) {
                        printf("[Parameter] Setting non-string param to string");
                }
                return false;
        }

        // If we have no collection of values
        if (values.getCount() == 0) {
                value = val;
        }
        else {
                if (!values.contains(val))
                        return false;
                current = values.getPos(val);
        }
        return true;
}

bool Parameter::setInteger(int val) {

        if (valueType.length() == 0)
                valueType = "Integer";

        if (!valueType.equalsIgnoreCase("Integer")) {
                if (DEBUGLEVEL(STATUS)) {
                        printf("[Parameter] Setting non-integer param to integer");
                }
                return false;
        }

        // If we have no collection of values
        if (values.getCount() == 0) {
                if ( (minValue != NOVALUE) && (maxValue != NOVALUE) && ( (val < minValue) || (val > maxValue) ) ) {
                        return false;
                }
                value = JString(val);
        }
        else {
                if (!values.contains(JString(val))) {
                        return false;
                }
                current = values.getPos(JString(val));
        }
        return true;
}

bool Parameter::setDouble(double val) {

        if (valueType.length() == 0)
                valueType = "Double";

        if (!valueType.equalsIgnoreCase("Double")) {
                if (DEBUGLEVEL(STATUS)) {
                        printf("[Parameter] Setting non-double param to double");
                }
                return false;
        }

        // If we have no collection of values
        if (values.getCount() == 0) {
                if ( (minValue != NOVALUE) && (maxValue != NOVALUE) && ( (val < minValue) || (val > maxValue) ) )
                        return false;
                value = JString(val);
        }
        else {
                if (!values.contains(JString(val)))
                        return false;
                current = values.getPos(JString(val));
        }
        return true;
}

bool Parameter::setPointer(void* val) {

        if (valueType.length() == 0)
                valueType = "Pointer";

        if (!valueType.equalsIgnoreCase("Pointer")) {
                if (DEBUGLEVEL(STATUS)) {
                        printf("[Parameter] Setting non-pointer param to pointer");
                }
                return false;
        }

        value = JString(val);
        return true;
}



// ***********************************************************************************
// Getters
// ***********************************************************************************

JString Parameter::getType() {
        return valueType;
}

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

int Parameter::getInteger() {

//      if (!valueType.equalsIgnoreCase("Integer"))
//              return 0;

        if (values.getCount() == 0)
                return value.toInt();
        else {
                if (current < 0) return 0;
                if (!valueType.equals("Integer")) return 0;
                return values.get(current).toInt();
        }
}

double Parameter::getDouble() {

//      if (!valueType.equalsIgnoreCase("Double"))
//              return 0;

        if (values.getCount() == 0)
                return value.toDouble();
        else {
                if (current < 0) return 0;
                if (!valueType.equals("Double")) return 0;
                return values.get(current).toDouble();
        }
}

JString Parameter::getString() {

//      if (!valueType.equalsIgnoreCase("String"))
//              return "";

        if (values.getCount() == 0)
                return value;
        else {
                if (current < 0) return "";
                return values.get(current);
        }
}

JString Parameter::getAsString() {

        if (values.getCount() == 0)
                return value;
        else {
                if (current < 0) return "";
                return values.get(current);
        }
}

void* Parameter::getPointer() {

//      if (!valueType.equalsIgnoreCase("Pointer"))
//              return NULL;

        return (void*) value.toPointer();
}


bool Parameter::addItem(const JString& value) {
        if (values.getCount() == 0)
                return false;
        int pos = values.getPos(value);
        if (pos >= 0)
                return true;
        else
                return values.add(value);
}

bool Parameter::removeItem(const JString& value) {
        if (values.getCount() < 2)
                return false;
        int pos = values.getPos(value);
        if (pos < 0)
                return true;
        else {
                if ((current == pos) && (current > 0)) {
                        current--;
                }
                return values.remove(pos);
        }
}



bool Parameter::reset() {
        current = def;
        value = defaultValue;
        return true;
}

bool Parameter::increment(int steps) {

        if (valueType.equalsIgnoreCase("Integer")) {
                return setInteger(value.toInt() + (int)(step*steps));
        }
        if (valueType.equalsIgnoreCase("Double")) {
                return setDouble(value.toDouble() + (step*steps));
        }
        if (values.getCount() == 0)
                return true;

        if (current < 0) return false;

        if ( (current+steps) < (values.length()-1) ) {
                current += steps;
                return true;
        }
        else
                return false;
}

bool Parameter::decrement(int steps) {
        if (valueType.equalsIgnoreCase("Integer")) {
                return setInteger(value.toInt() - (int)(step*steps));
        }
        if (valueType.equalsIgnoreCase("Double")) {
                return setDouble(value.toDouble() - (step*steps));
        }
        if (values.getCount() == 0)
                return true;

        if (current < 0) return false;

        if (current-steps >= 0) {
                current -= steps;
                return true;
        }
        else
                return false;
}


JString Parameter::getParameterValueFromCollection(ObjectDictionary* parameters, const JString& name) {
        if (parameters == NULL)
                return "";
        Parameter* param = (Parameter*) parameters->getIgnoreCase(name);
        if (param == NULL)
                return "";
        return param->value;
}

ObjectDictionary* Parameter::getParameterCollectionFromNode(XMLNode* node) {

        if (node == NULL)
                return NULL;

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

        ObjectDictionary* parameters = new ObjectDictionary();
        XMLNode* xmlNode;

        JString name, source;
        for (int n=0; n<children->getCount(); n++) {
                xmlNode = (XMLNode*) children->get(n);
                if (xmlNode != NULL) {
                //      if (xmlNode->getTag().equalsIgnoreCase("parameter")) {
                                name = xmlNode->getAttribute("name");
                                if (name.length() > 0) {
                                        parameters->put(name, new Parameter(xmlNode));
                                }
                        }
                //}
        }

        if (parameters->getCount() == 0) {
                delete(parameters);
                parameters = NULL;
        }

        return parameters;
}















bool Parameter::unitTest() {

        JString xml = "<parameter name=\"ProgDetCriteria\" type=\"String\" value=\"if obj.x &gt; 1 and obj.x &lt; 3 then status = true else status = false end\"/>";

        Parameter* p = new Parameter(xml);

        JString xml2 = p->toXML().trimCTRL();

        p->fromXML(xml2);

        if (!p->getString().equalsIgnoreCase("if obj.x > 1 and obj.x < 3 then status = true else status = false end")) {
                addUnitTestLog(JString::format("Parameter XML and toXML did not match\n%s\n%s\n", (char*) xml, (char*) xml2));
                return false;
        }
        delete(p);

        Collection oc;

        oc.add("Test0");
        oc.add("Test1");
        oc.add("Test2");
        oc.add("Test3");
        oc.add("Test4");
        oc.add("Test5");
        oc.add("Test6");
        oc.add("Test7");
        oc.add("Test8");
        oc.add("Test9");
        oc.add("Test10");

        Parameter* parameter = new Parameter("MyParam", "String", oc);

        if (parameter->values.getCount() != 11)
                return false;

        if (!parameter->set("Test6"))
                return false;

        if (!parameter->getString().equals("Test6"))
                return false;

        if (parameter->set("TestBla"))
                return false;

        if (!parameter->getString().equals("Test6"))
                return false;

        if (!parameter->reset())
                return false;

        JString s = parameter->getString();
        if (!s.equals("Test0"))
                return false;

        delete(parameter);


        parameter = new Parameter("<parameter name=\"ProgDetCriteria\" type=\"Integer\" value=\"0\" default=\"6\" step=\"2\" min=\"0\" max=\"10\"/>");

        int n;
        if ( (n = parameter->getInteger()) != 0)
                return false;

        if (!parameter->reset())
                return false;
        if ( (n = parameter->getInteger()) != 6)
                return false;

        if (!parameter->increment(2))
                return false;
        if ( (n = parameter->getInteger()) != 10)
                return false;

        if (!parameter->decrement(4))
                return false;
        if ( (n = parameter->getInteger()) != 2)
                return false;

        if (parameter->set(12))
                return false;
        if ( (n = parameter->getInteger()) != 2)
                return false;

        delete(parameter);

        return true;
}


} // namespace cmlabs

---