Changeset 1581 for trunk/src/objects

Timestamp:

Oct 17, 2009, 9:01:23 PM (15 years ago)

Author:

dkearney

Message:

updates for the rappture objects, object examples, and object apis. small fix for rpunits c interface to check string length. there should probably be more of these checks in the c interface, but units should also be rewritten. added folders to separate out octave2 and octave3 app-fermi examples

Location:

trunk/src/objects

Files:

• Makefile.in (modified) (4 diffs)
• RpLibObj.cc (modified) (11 diffs)
• RpLibObj.h (modified) (2 diffs)
• RpLibStorage.cc (added)
• RpLibStorage.h (added)
• RpNumber.cc (modified) (16 diffs)
• RpNumber.h (modified) (4 diffs)
• RpObject.cc (modified) (5 diffs)
• RpObject.h (modified) (5 diffs)
• RpParserXML.cc (modified) (4 diffs)
• RpParserXML.h (modified) (1 diff)
• RpPath.cc (modified) (10 diffs)
• RpPlot.cc (modified) (2 diffs)
• RpPlot.h (modified) (2 diffs)
• RpTest.cc (added)
• RpTest.h (added)

trunk/src/objects/Makefile.in

@@ -65 +65 @@
                 RpHistogram.h \
                 RpLibObj.h \
+                RpLibStorage.h \
                 RpNumber.h \
                 RpParserXML.h \
@@ -72 +73 @@
                 RpScatter.h \
                 RpString.h \
+                RpTest.h \
                 RpTree.h \
                 RpObjConfig.h \
@@ -95 +97 @@
                 RpHistogram.o \
                 RpLibObj.o \
+                RpLibStorage.o \
                 RpNumber.o \
                 RpParserXML.o \
@@ -102 +105 @@
                 RpScatter.o \
                 RpString.o \
+                RpTest.o \
                 RpTree.o \
                 RpUtils2.o \

trunk/src/objects/RpLibObj.cc

@@ -25 +25 @@
 #include <time.h>
 #include <cctype>
+#include <fstream>
 
 using namespace Rappture;
@@ -41 +42 @@
 Library::__libInit()
 {
-    _objList = Rp_ChainCreate();
+    _status.addContext("Rappture::Library::__libInit");
     return;
 }
@@ -48 +49 @@
 Library::__libFree()
 {
-    if (_objList != NULL) {
-        Rp_ChainLink *l = NULL;
-        Rappture::Object *objVal = NULL;
-        l = Rp_ChainFirstLink(_objList);
-        while(l) {
-            objVal = (Rappture::Object *) Rp_ChainGetValue(l);
-            delete objVal;
-            objVal = NULL;;
-            l = Rp_ChainNextLink(l);
-        }
-        Rp_ChainDestroy(_objList);
-        _objList = NULL;
-    }
     return;
 }
@@ -85 +73 @@
     // FIXME: add error check for Rp_ParserXmlParse
 
-    // convert xml tree into chain of rappture objects
-    Rp_Chain *tmpObjList = Rp_ChainCreate();
-    __parseTree2ObjectList(p,tmpObjList);
+    //_objStorage.backup();
+    _objStorage.clear();
+    __parseTree2ObjectList(p);
+    /*
     if (!_status) {
-        __libFree();
-        _objList = tmpObjList;
-    }
+        _objStorage.save();
+    } else {
+        _objStorage.restore()
+    }
+    */
 
     return _status;
@@ -107 +98 @@
     }
 
+    // null terminate string holding file
+    fileBuf.append("\0",1);
+
     loadXml(fileBuf.bytes());
 
     return _status;
+}
+
+Library &
+Library::value (
+    const char *key,
+    void *storage,
+    size_t numHints,
+    ...)
+{
+    _status.addContext("Rappture::Library::value");
+    Rappture::Object *o = _objStorage.find(key);
+
+    if (o == NULL) {
+        _status.addError("Error while retrieving object "
+            "with key \"%s\": object does not exist", key);
+        return *this;
+    }
+
+    va_list arg;
+
+    va_start(arg,numHints);
+    o->vvalue(storage,numHints,arg);
+    _status = o->outcome();
+    va_end(arg);
+
+    return *this;
 }
 
@@ -115 +135 @@
 Library::xml() const
 {
+    _status.addContext("Rappture::Library::xml");
     Rp_ParserXml *p = Rp_ParserXmlCreate();
     Rp_ChainLink *l = NULL;
 
-    l = Rp_ChainFirstLink(_objList);
+    const Rp_Chain *objList = _objStorage.contains();
+
+    l = Rp_ChainFirstLink(objList);
 
     while (l != NULL) {
         Rappture::Object *o = (Rappture::Object *) Rp_ChainGetValue(l);
-        o->dump(RPCONFIG_TREE,(ClientData)p);
+        if (o != NULL) {
+            // FIXME: we can remove the if statement when
+            // LibraryStorage is fixed to clean up holes
+            // in the object chain.
+            o->dump(RPCONFIG_TREE,(ClientData)p);
+        }
         l = Rp_ChainNextLink(l);
     }
@@ -130 +158 @@
 
 void
-Library::__parseTree2ObjectList(
-    Rp_ParserXml *p,
-    Rp_Chain *retObjList)
+Library::__parseTree2ObjectList(Rp_ParserXml *p)
 {
     _status.addContext("Rappture::Library::__parseTree2ObjectList");
@@ -141 +167 @@
     }
 
-    if (retObjList == NULL) {
-        _status.addError("return object list is NULL");
-        return;
-    }
-
-    // get the children nodes of "tool", "input", and "output"
     Rp_Chain *children = Rp_ChainCreate();
+
+    // parse out the tool information
     // Rp_ParserXmlChildren(p, "tool", NULL, children);
+    // if there is a child called tool, grab its
+    //      title                   char *
+    //      about                   char *
+    //      command                 char *
+    //      limits.cputime          double
+    //      layout                  char *
+    //      control                 char *
+    //      analyzer                char *
+    //      reportJobFailures       int
+
+    // get the children nodes of "input", and "output"
     Rp_ParserXmlChildren(p, "input", NULL, children);
     Rp_ParserXmlChildren(p, "output", NULL, children);
@@ -164 +197 @@
             Rappture::Number *obj = new Rappture::Number();
             obj->configure(RPCONFIG_TREE,(void*)p);
-            Rp_ChainAppend(retObjList,(void*)obj);
+            _objStorage.store(obj->name(),obj);
+            _objStorage.link(obj->name(),obj->path());
+            // Rp_ChainAppend(retObjList,(void*)obj);
+
+        // FIXME: add code to check for strings, choices,
+        //        groups, curves, notes, images, molecules...
+        //        all of the rappture object types
         } else {
             _status.addError("unrecognized object type: %s",label);
@@ -178 +217 @@
 }
 
+
+
 Outcome &
 Library::outcome() const
@@ -184 +225 @@
 }
 
+int
+Library::error() const
+{
+    return (int) _status;
+}
+
+/*
+Outcome &
+Library::result(int status)
+{
+    Rappture::SimpleCharBuffer tmpBuf;
+    std::fstream file;
+    const char *xmlText = NULL;
+    time_t t = 0;
+    struct tm* timeinfo = NULL;
+    timestamp = "";
+    std::string username = "";
+    std::string hostname = "";
+    char *user = NULL;
+
+    tmpBuf.appendf("run%i.xml",(int)time(&t));
+    file.open(tmpBuf.bytes(),std::ios::out);
+
+//    put("tool.version.rappture.revision",
+//        "$LastChangedRevision: 1527 $");
+//    put("tool.version.rappture.modified",
+//        "$LastChangedDate: 2009-06-22 15:38:49 -0400"
+//        " (Mon, 22 Jun 2009) $");
+//    if ( "" == get("tool.version.rappture.language") ) {
+//        put("tool.version.rappture.language","c++");
+//    }
+
+    // generate a timestamp for the run file
+    timeinfo = localtime(&t);
+    timestamp = std::string(ctime(&t));
+    // erase the 24th character because it is a newline
+    timestamp.erase(24);
+    // concatinate the timezone
+    timestamp.append(" ");
+#ifdef _WIN32
+    timestamp.append(_tzname[_daylight]);
+    // username is left blank for windows because i dont know
+    // how to retrieve username on win32 environment.
+    username = "";
+    hostname = "";
+#else
+    timestamp.append(timeinfo->tm_zone);
+    user = getenv("USER");
+    if (user != NULL) {
+        username = std::string(user);
+    } else {
+        user = getenv("LOGNAME");
+        if (user != NULL) {
+            username = std::string(user);
+        }
+    }
+#endif
+
+    // add the timestamp to the run file
+//    put("output.time", timestamp);
+//    put("output.status",exitStatus);
+//    put("output.user",username);
+//    put("output.host",hostname);
+
+    if ( file.is_open() ) {
+        xmlText = xml();
+        if (xmlText == NULL) {
+        }
+        file << xmlText;
+        // check to make sure there were no
+        // errors while writing the run.xml file.
+        if (   (!file.good())
+            || (strlen(xmlText) != ((long)file.tellp()-(long)1))
+           ) {
+             status.error("Error while writing run file");
+             status.addContext("RpLibrary::result()");
+        }
+        file.close();
+    }
+    else {
+        status.error("Error while opening run file");
+        status.addContext("RpLibrary::result()");
+    }
+    std::printf("=RAPPTURE-RUN=>%s\n",outputFile.bytes());
+}
+*/
+
 const Rp_Chain *
 Library::contains() const
 {
-    return _objList;
-}
+    return _objStorage.contains();
+}
+

trunk/src/objects/RpLibObj.h

@@ -32 +32 @@
 #include "RpChain.h"
 #include "RpParserXML.h"
+#include "RpLibStorage.h"
+#include <cstdarg>
 
 namespace Rappture {
@@ -46 +48 @@
 
 
-        // Library *value(const char *key, void *storage);
+        Library &value(const char *key, void *storage,
+            size_t numHints, ...);
 
         // Rp_Chain *diff(Library *lib);
 
-        // Library *remove (const char *key);
+        // Library &remove (const char *key);
 
         const char *xml() const;
 
         Outcome &outcome() const;
+        int error() const;
 
-        // Library *result(int status);
+        // Outcome &result(int status);
 
         const Rp_Chain *contains() const;
     private:
-        Rp_Chain *_objList;
-        // Rp_HashTable _objHash;
-        mutable Rappture::Outcome _status;
+        LibraryStorage _objStorage;
+        mutable Outcome _status;
 
         void __libInit();
         void __libFree();
-        void __parseTree2ObjectList(Rp_ParserXml *p, Rp_Chain *retObjList);
+        void __parseTree2ObjectList(Rp_ParserXml *p);
 
 }; // end class Library

trunk/src/objects/RpNumber.cc

@@ -24 +24 @@
      _minSet (0),
      _maxSet (0),
+     _defSet (0),
+     _curSet (0),
      _presets (NULL)
 {
@@ -43 +45 @@
      _minSet (0),
      _maxSet (0),
+     _defSet (0),
+     _curSet (0),
      _presets (NULL)
 {
@@ -69 +73 @@
       _minSet (0),
       _maxSet (0),
+      _defSet (0),
+      _curSet (0),
       _presets (NULL)
 {
@@ -110 +116 @@
     : Object (o),
       _minSet (o._minSet),
-      _maxSet (o._maxSet)
+      _maxSet (o._maxSet),
+      _defSet (o._defSet),
+      _curSet (o._curSet)
 {
     this->def(o.def());
@@ -139 +147 @@
 }
 
+int
+Number::minset() const
+{
+    return _minSet;
+}
+
+int
+Number::maxset() const
+{
+    return _maxSet;
+}
+
+int
+Number::defset() const
+{
+    return _defSet;
+}
+
+int
+Number::curset() const
+{
+    return _curSet;
+}
+
 /**********************************************************************/
 // METHOD: convert()
@@ -146 +178 @@
  */
 
-int
+Outcome&
 Number::convert(const char *to)
 {
     const RpUnits* toUnit = NULL;
     const RpUnits* fromUnit = NULL;
-    double convertedVal = cur();
-    int err = 0;
+
+    _status.addContext("Rappture::Number::convert");
+
+    if (to == NULL) {
+        return _status;
+    }
+
+    if (strcmp(units(),to) == 0) {
+        return _status;
+    }
 
     // make sure all units functions accept char*'s
     toUnit = RpUnits::find(std::string(to));
     if (!toUnit) {
-        // should raise error!
-        // conversion not defined because unit does not exist
-        return convertedVal;
+        _status.addError("conversion not defined, unit \"%s\" does not exist",to);
+        return _status;
     }
 
     fromUnit = RpUnits::find(std::string(units()));
     if (!fromUnit) {
-        // should raise error!
-        // conversion not defined because unit does not exist
-        return convertedVal;
+        _status.addError("conversion not defined, unit \"%s\" does not exist",to);
+        return _status;
     }
 
     // perform the conversion
+    int err = 0;
+    double convertedVal;
+
     convertedVal = fromUnit->convert(toUnit,def(), &err);
-    if (!err) {
+    if (err) {
+        _status.addError("undefined error while converting %s to %s",
+            (fromUnit->getUnitsName()).c_str(),
+            (toUnit->getUnitsName()).c_str());
+    } else {
         def(convertedVal);
     }
 
     convertedVal = fromUnit->convert(toUnit,cur(), &err);
-    if (!err) {
+    if (err) {
+        _status.addError("undefined error while converting %s to %s",
+            (fromUnit->getUnitsName()).c_str(),
+            (toUnit->getUnitsName()).c_str());
+    } else {
         cur(convertedVal);
     }
 
-    return err;
+    return _status;
 }
 
@@ -188 +237 @@
 /**
  * does not change the value of the object
- * error code is returned
- */
-
-int
-Number::value(const char *to, double *value) const
-{
-    return 1;
+ * error code is set on trouble
+ */
+
+double
+Number::value(const char *to) const
+{
+    const RpUnits* toUnit = NULL;
+    const RpUnits* fromUnit = NULL;
+
+    _status.addContext("Rappture::Number::value");
+
+    double val = 0.0;
+
+    if (_defSet) {
+        val = def();
+    }
+
+    if (_curSet) {
+        val = cur();
+    }
+
+    if (to == NULL) {
+        return val;
+    }
+
+    if (strcmp(units(),to) == 0) {
+        return val;
+    }
+
+    // make sure all units functions accept char*'s
+    toUnit = RpUnits::find(std::string(to));
+    if (!toUnit) {
+        _status.addError("conversion not defined, unit \"%s\" does not exist",to);
+        return val;
+    }
+
+    fromUnit = RpUnits::find(std::string(units()));
+    if (!fromUnit) {
+        _status.addError("conversion not defined, unit \"%s\" does not exist",to);
+        return val;
+    }
+
+    // perform the conversion
+    int err = 0;
+    double convertedVal = fromUnit->convert(toUnit,val, &err);
+    if (err) {
+        _status.addError("undefined error while converting %s to %s",
+            (fromUnit->getUnitsName()).c_str(),
+            (toUnit->getUnitsName()).c_str());
+        return cur();
+    }
+
+    return convertedVal;
+}
+
+/**********************************************************************/
+// METHOD: vvalue()
+/// Get the value of this object based on provided hints
+/**
+ * does not change the value of the object
+ * currently recognized hints:
+ *  units
+ * error code is set on trouble
+ */
+
+void
+Number::vvalue(void *storage, size_t numHints, va_list arg) const
+{
+    char buf[1024];
+    char *hintCopy = NULL;
+    size_t hintLen = 0;
+
+    char *hint = NULL;
+    const char *hintKey = NULL;
+    const char *hintVal = NULL;
+
+    double *ret = (double *) storage;
+
+    *ret = 0.0;
+
+    if (_defSet) {
+        *ret = def();
+    }
+
+    if (_curSet) {
+        *ret = cur();
+    }
+
+    while (numHints > 0) {
+        numHints--;
+        hint = va_arg(arg, char *);
+        hintLen = strlen(hint);
+        if (hintLen < 1024) {
+            hintCopy = buf;
+        } else {
+            // buf too small, allocate some space
+            hintCopy = new char[hintLen];
+        }
+        strcpy(hintCopy,hint);
+
+        // parse the hint into a key and value
+        __hintParser(hintCopy,&hintKey,&hintVal);
+
+        // evaluate the hint key
+        if (('u' == *hintKey) &&
+            (strcmp("units",hintKey) == 0)) {
+            *ret = value(hintVal);
+
+        }
+
+        if (hintCopy != buf) {
+            // clean up memory
+            delete hintCopy;
+        }
+    }
+    return;
 }
 
@@ -300 +458 @@
 }
 
-/**********************************************************************/
-// METHOD: configure(ClientData c)
-/// construct a number object from the provided tree
-/**
- * construct a number object from the provided tree
- */
-
-void
-Number::configure(size_t as, ClientData c)
-{
-    if (as == RPCONFIG_XML) {
-        __configureFromXml(c);
-    } else if (as == RPCONFIG_TREE) {
-        __configureFromTree(c);
-    }
-}
-
-/**********************************************************************/
-// METHOD: configureFromXml(const char *xmltext)
-/// configure the object based on Rappture1.1 xmltext
-/**
- * Configure the object based on the provided xml
- */
-
-void
-Number::__configureFromXml(ClientData c)
-{
-    const char *xmltext = (const char *)c;
-    if (xmltext == NULL) {
-        // FIXME: setup error
-        return;
-    }
-
-    Rp_ParserXml *p = Rp_ParserXmlCreate();
-    Rp_ParserXmlParse(p, xmltext);
-    configure(RPCONFIG_TREE, p);
-
-    return;
-}
-
 void
 Number::__configureFromTree(ClientData c)
@@ -394 +512 @@
 
 /**********************************************************************/
-// METHOD: dump(size_t as, void *p)
-/// construct a number object from the provided tree
-/**
- * construct a number object from the provided tree
- */
-
-void
-Number::dump(size_t as, ClientData p)
-{
-    if (as == RPCONFIG_XML) {
-        __dumpToXml(p);
-    } else if (as == RPCONFIG_TREE) {
-        __dumpToTree(p);
-    }
-}
-
-/**********************************************************************/
-// METHOD: dumpToXml(ClientData p)
-/// configure the object based on Rappture1.1 xmltext
-/**
- * Configure the object based on the provided xml
- */
-
-void
-Number::__dumpToXml(ClientData c)
+// METHOD: dumpToTree(ClientData p)
+/// dump the object to a Rappture1.1 based tree
+/**
+ * Dump the object to a Rappture1.1 based tree
+ */
+
+void
+Number::__dumpToTree(ClientData c)
 {
     if (c == NULL) {
@@ -425 +526 @@
     }
 
-    ClientDataXml *d = (ClientDataXml *)c;
-    Rp_ParserXml *parser = Rp_ParserXmlCreate();
-    __dumpToTree(parser);
-    _tmpBuf.appendf("%s",Rp_ParserXmlXml(parser));
-    d->retStr = _tmpBuf.bytes();
-    Rp_ParserXmlDestroy(&parser);
-}
-
-/**********************************************************************/
-// METHOD: dumpToTree(ClientData p)
-/// dump the object to a Rappture1.1 based tree
-/**
- * Dump the object to a Rappture1.1 based tree
- */
-
-void
-Number::__dumpToTree(ClientData c)
-{
-    if (c == NULL) {
-        // FIXME: setup error
-        return;
-    }
-
     Rp_ParserXml *parser = (Rp_ParserXml *)c;
 
@@ -463 +541 @@
     Rp_ParserXmlPutF(parser,p.path(),"%s",label());
 
+    p.type("description");
+    Rp_ParserXmlPutF(parser,p.path(),"%s",desc());
+
     p.del();
-    p.add("description");
-    Rp_ParserXmlPutF(parser,p.path(),"%s",desc());
-
-    p.del();
-    p.del();
-    p.add("units");
+    p.type("units");
     Rp_ParserXmlPutF(parser,p.path(),"%s",units());
 
 
     if (_minSet) {
-        p.del();
-        p.add("min");
-        Rp_ParserXmlPutF(parser,p.path(),"%g",min());
+        p.type("min");
+        Rp_ParserXmlPutF(parser,p.path(),"%g%s",min(),units());
     }
 
     if (_maxSet) {
-        p.del();
-        p.add("max");
-        Rp_ParserXmlPutF(parser,p.path(),"%g",max());
-    }
-
-    p.del();
-    p.add("default");
-    Rp_ParserXmlPutF(parser,p.path(),"%g",def());
-
-    p.del();
-    p.add("current");
-    Rp_ParserXmlPutF(parser,p.path(),"%g",cur());
-
-    // still need to add presets
+        p.type("max");
+        Rp_ParserXmlPutF(parser,p.path(),"%g%s",max(),units());
+    }
+
+    p.type("default");
+    Rp_ParserXmlPutF(parser,p.path(),"%g%s",def(),units());
+
+    p.type("current");
+    Rp_ParserXmlPutF(parser,p.path(),"%g%s",cur(),units());
+
+    // process presets
+    p.type("preset");
+    p.add("label");
+    Rp_ChainLink *l = Rp_ChainFirstLink(_presets);
+    while (l != NULL) {
+        struct preset *presetObj = (struct preset *) Rp_ChainGetValue(l);
+
+        p.type("label");
+        Rp_ParserXmlPutF(parser,p.path(),"%s",presetObj->label());
+        //p.type("description");
+        //Rp_ParserXmlPutF(parser,p.path(),"%s",presetObj->desc());
+        // p.type("units");
+        // Rp_ParserXmlPutF(parser,p.path(),"%s",presetObj->units());
+        p.type("value");
+        Rp_ParserXmlPutF(parser,p.path(),"%g%s",presetObj->val(),presetObj->units());
+
+        p.prev();
+        p.degree(p.degree()+1);
+        p.next();
+
+        l = Rp_ChainNextLink(l);
+    }
+
     return;
 }
@@ -512 +606 @@
 
 
+void
+Number::__convertFromString(
+    const char *val,
+    double *ret)
+{
+    if (val == NULL) {
+        return;
+    }
+
+    if (ret == NULL) {
+        return;
+    }
+
+    double numericVal = 0.0;
+    if (units()) {
+        // convert the provided string into
+        // the objects default units
+        int err = 0;
+        std::string strVal;
+        strVal = RpUnits::convert(val,units(),RPUNITS_UNITS_OFF,&err);
+        if (err) {
+            _status.addError("Unknown error while converting units");
+        }
+
+        char *endPtr = NULL;
+        numericVal = strtod(strVal.c_str(),&endPtr);
+        if (endPtr == strVal.c_str()) {
+            // no conversion was performed
+            _status.addError("Could not convert \"%s\" into a number",
+                strVal.c_str());
+        } else if (endPtr == (strVal.c_str()+strVal.length())) {
+            *ret = numericVal;
+        } else {
+            // the whole string could not be converted to a number
+            // signal error?
+            _status.addError("Could not convert \"%s\" of \"%s\"into a number",
+                endPtr, strVal.c_str());
+        }
+    } else {
+        // try to figure out the units
+        // store units and return the numeric value to the user
+        const char *foundUnits = NULL;
+        __valUnitsSplit(val,&numericVal,&foundUnits);
+        units(foundUnits);
+        *ret = numericVal;
+    }
+
+}
+
+void
+Number::__valUnitsSplit(
+    const char *inStr,
+    double *val,
+    const char **units)
+{
+    if (inStr == NULL) {
+        return;
+    }
+
+    if (val == NULL) {
+        return;
+    }
+
+    if (units == NULL) {
+        return;
+    }
+
+    char *endPtr = NULL;
+    *val = strtod(inStr,&endPtr);
+    if (endPtr == inStr) {
+        // no conversion was performed
+        _status.addError("Could not convert \"%s\" into a number", inStr);
+    } else if (endPtr == (inStr+strlen(inStr))) {
+        // the whole string was used in the numeric conversion
+        // set units to NULL
+        *units = NULL;
+    } else {
+        // the whole string could not be converted to a number
+        // we assume the rest of the string are the units
+        *units = endPtr;
+    }
+}
+
 /**********************************************************************/
 // METHOD: minFromStr()
@@ -524 +701 @@
 {
     double numericVal = 0;
-    int err = 0;
-
-    numericVal = rpConvertDbl(val,units(),&err);
-
-    if (!err) {
+
+    if (val == NULL) {
+        return;
+    }
+
+    __convertFromString(val,&numericVal);
+
+    if (!_status) {
         min(numericVal);
-    } else {
-        // FIXME: add error code
-    }
+        _minSet = 1;
+    }
+
 }
 
@@ -547 +727 @@
 {
     double numericVal = 0;
-    int err = 0;
-
-    numericVal = rpConvertDbl(val,units(),&err);
-
-    if (!err) {
+
+    if (val == NULL) {
+        return;
+    }
+
+    __convertFromString(val,&numericVal);
+
+    if (!_status) {
         max(numericVal);
-    } else {
-        // FIXME: add error code
-    }
+        _maxSet = 1;
+    }
+
 }
 
@@ -570 +753 @@
 {
     double numericVal = 0;
-    int err = 0;
-
-    numericVal = rpConvertDbl(val,units(),&err);
-
-    if (!err) {
+
+    if (val == NULL) {
+        return;
+    }
+
+    __convertFromString(val,&numericVal);
+
+    if (!_status) {
         def(numericVal);
-    } else {
-        // FIXME: add error code
-    }
+        _defSet = 1;
+    }
+
 }
 
@@ -593 +779 @@
 {
     double numericVal = 0;
-    int err = 0;
-
-    numericVal = rpConvertDbl(val,units(),&err);
-
-    if (!err) {
+
+    if (val == NULL) {
+        return;
+    }
+
+    __convertFromString(val,&numericVal);
+
+    if (!_status) {
         cur(numericVal);
-    } else {
-        // FIXME: add error code
-    }
+        _curSet = 1;
+    }
+
 }
 

trunk/src/objects/RpNumber.h

@@ -39 +39 @@
         void units(const char *p);
 
+        int minset() const;
+        int maxset() const;
+        int defset() const;
+        int curset() const;
+
         // convert the value stored in this object to specified units
         // does not return the converted value
         // error code is returned
-        int convert(const char *to);
+        Outcome& convert(const char *to);
 
         // get the value of this object converted to specified units
         // does not change the value of the object
         // error code is returned
-        int value(const char *units, double *value) const;
+        double value(const char *units) const;
+        void vvalue(void *storage, size_t numHints, va_list arg) const;
 
         Number& addPreset(const char *label, const char *desc,
@@ -57 +63 @@
         Number& delPreset(const char *label);
 
-
-        void configure(size_t as, ClientData c);
-        void dump(size_t as, ClientData c);
 
         const int is() const;
@@ -73 +76 @@
         int _minSet;
         int _maxSet;
+        int _defSet;
+        int _curSet;
 
         // hash or linked list of preset values
@@ -84 +89 @@
         };
 
-        void __configureFromXml(ClientData c);
         void __configureFromTree(ClientData c);
-        void __dumpToXml(ClientData c);
         void __dumpToTree(ClientData c);
+
+        void __convertFromString(const char *val, double *ret);
+        void __valUnitsSplit( const char *inStr, double *val,
+                const char **units);
 };
 

trunk/src/objects/RpObject.cc

@@ -16 +16 @@
 #include "RpObject.h"
 #include "RpHashHelper.h"
+#include <cstring>
 
 using namespace Rappture;
@@ -251 +252 @@
     delete[] tmp;
     tmp = NULL;
+    return;
+}
+
+void
+Object::__hintParser(
+    char *hint,
+    const char **hintKey,
+    const char **hintVal) const
+{
+
+    // hints are null terminated strings with a hint key
+    // and hint value separated by an equal sign.
+    // they take the following form:
+    // hintKey=hintVal
+    // this function does change the original hint string.
+
+    char *v = NULL;
+
+    if (hint == NULL) {
+        return;
+    }
+
+    v = strchrnul(hint,'=');
+    *hintKey = hint;
+    if ((*v == '\0') || (*(v+1) == '\0')) {
+        // incomplete hint string
+        *hintVal = NULL;
+    } else {
+        *v = '\0';
+        *hintVal = v+1;
+    }
+
+    return;
+}
+
+void
+Object::vvalue(void *storage, size_t numHints, va_list arg) const
+{
+    // bland objects take no hints
+    char buf[1024];
+    char *hintCopy = NULL;
+    size_t hintLen = 0;
+
+    char *hint = NULL;
+    const char *hintKey = NULL;
+    const char *hintVal = NULL;
+
+    while (numHints > 0) {
+        numHints--;
+        hint = va_arg(arg, char *);
+        hintLen = strlen(hint);
+        if (hintLen < 1024) {
+            hintCopy = buf;
+        } else {
+            hintCopy = new char[hintLen+1];
+        }
+        strcpy(hintCopy,hint);
+        __hintParser(hintCopy,&hintKey,&hintVal);
+        if (hintCopy != buf) {
+            delete hintCopy;
+        }
+    }
     return;
 }
@@ -297 +360 @@
 }
 
+/*
 const char *
 Object::xml(size_t indent, size_t tabstop) const
@@ -302 +366 @@
     return NULL;
 }
+*/
 
 /*
@@ -311 +376 @@
 */
 
+/**********************************************************************/
+// METHOD: configure(ClientData c)
+/// construct an object from the provided tree
+/**
+ * construct an object from the provided tree
+ */
+
 void
 Object::configure(size_t as, ClientData c)
 {
-    return;
-}
-
-void
-Object::dump(size_t as, ClientData c)
-{
-    return;
+    if (as == RPCONFIG_XML) {
+        __configureFromXml(c);
+    } else if (as == RPCONFIG_TREE) {
+        __configureFromTree(c);
+    }
+}
+
+/**********************************************************************/
+// METHOD: configureFromXml(const char *xmltext)
+/// configure the object based on Rappture1.1 xmltext
+/**
+ * Configure the object based on the provided xml
+ */
+
+void
+Object::__configureFromXml(ClientData c)
+{
+    const char *xmltext = (const char *)c;
+    if (xmltext == NULL) {
+        // FIXME: setup error
+        return;
+    }
+
+    Rp_ParserXml *p = Rp_ParserXmlCreate();
+    Rp_ParserXmlParse(p, xmltext);
+    __configureFromTree(p);
+
+    return;
+}
+
+void
+Object::__configureFromTree(ClientData c)
+{
+    Rp_ParserXml *p = (Rp_ParserXml *)c;
+    if (p == NULL) {
+        // FIXME: setup error
+        return;
+    }
+
+    Rp_TreeNode node = Rp_ParserXmlElement(p,NULL);
+
+    Rappture::Path pathObj(Rp_ParserXmlNodePath(p,node));
+
+    path(pathObj.parent());
+    name(Rp_ParserXmlNodeId(p,node));
+
+    pathObj.clear();
+    pathObj.add("about");
+    pathObj.add("label");
+    label(Rp_ParserXmlGet(p,pathObj.path()));
+    pathObj.type("description");
+    desc(Rp_ParserXmlGet(p,pathObj.path()));
+    pathObj.type("hints");
+    hints(Rp_ParserXmlGet(p,pathObj.path()));
+    pathObj.type("color");
+    color(Rp_ParserXmlGet(p,pathObj.path()));
+
+    return;
+}
+
+/**********************************************************************/
+// METHOD: dump(size_t as, void *p)
+/// construct a number object from the provided tree
+/**
+ * construct a number object from the provided tree
+ */
+
+void
+Object::dump(size_t as, ClientData p)
+{
+    if (as == RPCONFIG_XML) {
+        __dumpToXml(p);
+    } else if (as == RPCONFIG_TREE) {
+        __dumpToTree(p);
+    }
+}
+
+/**********************************************************************/
+// METHOD: dumpToXml(ClientData p)
+/// configure the object based on Rappture1.1 xmltext
+/**
+ * Configure the object based on the provided xml
+ */
+
+void
+Object::__dumpToXml(ClientData c)
+{
+    if (c == NULL) {
+        // FIXME: setup error
+        return;
+    }
+
+    ClientDataXml *d = (ClientDataXml *)c;
+    Rp_ParserXml *parser = Rp_ParserXmlCreate();
+    __dumpToTree(parser);
+    _tmpBuf.appendf("%s",Rp_ParserXmlXml(parser));
+    d->retStr = _tmpBuf.bytes();
+    Rp_ParserXmlDestroy(&parser);
+}
+
+/**********************************************************************/
+// METHOD: dumpToTree(ClientData p)
+/// dump the object to a Rappture1.1 based tree
+/**
+ * Dump the object to a Rappture1.1 based tree
+ */
+
+void
+Object::__dumpToTree(ClientData c)
+{
+    if (c == NULL) {
+        // FIXME: setup error
+        return;
+    }
+
+    Rp_ParserXml *parser = (Rp_ParserXml *)c;
+
+    Path p;
+
+    p.parent(path());
+    p.last();
+
+    p.add("object");
+    p.id(name());
+
+    p.add("about");
+
+    p.add("label");
+    Rp_ParserXmlPutF(parser,p.path(),"%s",label());
+
+    p.type("description");
+    Rp_ParserXmlPutF(parser,p.path(),"%s",desc());
+
+    p.type("hints");
+    Rp_ParserXmlPutF(parser,p.path(),"%s", hints());
+
+    p.type("color");
+    Rp_ParserXmlPutF(parser,p.path(),"%s", color());
+
+    return;
+}
+
+Outcome &
+Object::outcome() const
+{
+    return _status;
 }
 

trunk/src/objects/RpObject.h

@@ -14 +14 @@
 #include "RpInt.h"
 #include "RpHash.h"
+#include "RpOutcome.h"
 #include "RpAccessor.h"
 #include "RpBuffer.h"
@@ -19 +20 @@
 #include "RpParserXML.h"
 #include "RpObjConfig.h"
+#include <cstdarg>
 
 namespace Rappture {
@@ -71 +73 @@
         void propremove (const char *key);
 
+        // return the value of object based on provided hints
+        virtual void vvalue (void *storage, size_t numHints, va_list arg) const;
+
         // get the Rappture1.1 xml text for this object
-        virtual const char *xml(size_t indent, size_t tabstop) const;
-
-        // set the object properties based on Rappture1.1 xml text
-        // virtual void xml(const char *xmltext);
+        // virtual const char *xml(size_t indent, size_t tabstop) const;
 
         // configure the object properties based on Rappture1.1 xml text
@@ -81 +83 @@
         virtual void dump(size_t as, ClientData c);
 
+        virtual Outcome &outcome() const;
         virtual const int is() const;
 
@@ -88 +91 @@
         SimpleCharBuffer _tmpBuf;
 
+        /// status of the object
+        mutable Rappture::Outcome _status;
+
+        virtual void __hintParser(char *hint,
+            const char **hintKey, const char **hintVal) const;
+
+        virtual void __configureFromXml(ClientData c);
+        virtual void __configureFromTree(ClientData c);
+        virtual void __dumpToXml(ClientData c);
+        virtual void __dumpToTree(ClientData c);
     private:
 

trunk/src/objects/RpParserXML.cc

@@ -70 +70 @@
     Rp_TreeGetValue(inf->tree,inf->curr,Rp_ParserXml_Field_VALUE,(void **)&value);
 
-    // strip trailing spaces
-    int i = 0;
-    for (i = strlen(value)-1; i >= 0; i--) {
-        if (isspace(value[i])) {
-            value[i] = '\0';
-        } else {
-            break;
-        }
-    }
-
-    // strip leading spaces
-    int j = 0;
-    for (j = 0; j < i; j++) {
-        if (isspace(value[j])) {
-            value[j] = '\0';
-        } else {
-            break;
-        }
-    }
-
-    if (j > 0) {
-        // reallocate the trimmed string
-        char *newValue = new char[i-j+1+1];
-        strcpy(newValue,value+j);
-        Rp_TreeSetValue(inf->tree,inf->curr,Rp_ParserXml_Field_VALUE,(void *)newValue);
-        delete value;
-        value = NULL;
+    if (value != NULL) {
+        // strip trailing spaces
+        int i = 0;
+        for (i = strlen(value)-1; i >= 0; i--) {
+            if (isspace(value[i])) {
+                value[i] = '\0';
+            } else {
+                break;
+            }
+        }
+
+        // strip leading spaces
+        int j = 0;
+        for (j = 0; j < i; j++) {
+            if (isspace(value[j])) {
+                value[j] = '\0';
+            } else {
+                break;
+            }
+        }
+
+        if (j > 0) {
+            // reallocate the trimmed string
+            char *newValue = new char[i-j+1+1];
+            strcpy(newValue,value+j);
+            Rp_TreeSetValue(inf->tree,inf->curr,Rp_ParserXml_Field_VALUE,
+                (void *)newValue);
+            delete value;
+            value = NULL;
+        }
     }
 
@@ -218 +221 @@
 }
 
+int
+Rp_ParserXmlNodeIdentify(
+    Rp_ParserXml *p,
+    Rp_TreeNode n,
+    const char *name,
+    const char *id)
+{
+    int criteriaMet = 0;
+    int criteriaTotal = 0;
+
+    if (n) {
+        if (name) {
+            criteriaTotal++;
+            if (strcmp(name,Rp_TreeNodeLabel(n)) == 0) {
+                criteriaMet++;
+            }
+        }
+        if (id) {
+            criteriaTotal++;
+            const char *nodeId = NULL;
+            Rp_TreeGetValue(p->tree,n,Rp_ParserXml_Field_ID,
+                (void **)&nodeId);
+            if (strcmp(id,nodeId) == 0) {
+                criteriaMet++;
+            }
+        }
+    }
+
+    // check if all of the eligable criteria have been met
+    int retVal = 0;
+    if (criteriaMet == criteriaTotal) {
+        retVal = 0;
+    } else {
+        retVal = 1;
+    }
+
+    return retVal;
+
+}
+
+void
+Rp_ParserXmlFindChild(
+    Rp_ParserXml *p,
+    Rp_TreeNode parent,
+    const char *childName,
+    const char *childId,
+    size_t degree,
+    Rp_TreeNode *child,
+    size_t *numFound)
+{
+    // this function is only concerned with the question:
+    // is a node with a matching name, id, and degree a
+    // child of the provided parent node?
+    // if so return it.
+    // this function does not create new nodes.
+
+    if (child == NULL) {
+        return;
+    }
+
+    if (numFound == NULL) {
+        return;
+    }
+
+    *numFound = 0;
+    *child = Rp_TreeFindChild(parent,childName);
+    if (*child == NULL) {
+        // no nodes with the name childName exist
+        return;
+    }
+
+    while (*child != NULL) {
+        if (Rp_ParserXmlNodeIdentify(p,*child,childName,childId) == 0) {
+            // found a child with the correct name and id
+            (*numFound)++;
+            if (degree == *numFound) {
+                // found a node with the correct degree
+                break;
+            }
+        }
+
+        // check the next child for the correct name and id
+        *child = Rp_TreeNextSibling(*child);
+    }
+
+    return;
+}
+
 Rp_TreeNode
 Rp_ParserXmlSearch(
@@ -227 +318 @@
     Rp_TreeNode parent = NULL;
     Rp_TreeNode child = NULL;
-    size_t degree = 0;
 
     if (p == NULL) {
@@ -244 +334 @@
 
         const char *childName = pathObj.type();
-        const char *searchChildId = pathObj.id();
-
-        child = Rp_TreeFindChild(parent,childName);
+        const char *childId = pathObj.id();
+        size_t childDegree = pathObj.degree();
+
+        size_t foundCnt = 0;
+        Rp_ParserXmlFindChild(p, parent, childName, childId,
+            childDegree, &child, &foundCnt);
+
         if (child == NULL) {
             // no nodes with the name childName exist
             // FIXME: use the RPXML_CREATE flag
             if (create) {
-                for (size_t i = 1; i <= pathObj.degree(); i++) {
+                for (size_t i = foundCnt; i < pathObj.degree(); i++) {
                     child = Rp_ParserXmlCreateNode(p, parent,
-                                childName, searchChildId);
+                                childName, childId);
                     if (child == NULL) {
+                        // error while creating the child node
+                        // signal error
                         break;
                     }
                 }
             } else {
-                fprintf(stderr,"invalid path %s at %s\n",path,childName);
+                // fprintf(stderr,"invalid path %s at %s\n",path,childName);
                 break;
             }
-        }
-
-        //FIXME: rewrite the child id search logic
-        const char *id = NULL;
-        Rp_TreeGetValue(p->tree,child, Rp_ParserXml_Field_ID,(void **)&id);
-        while (searchChildId && id) {
-
-            // check for matching child id and degree
-            if ((*searchChildId == *id) &&
-                (strcmp(searchChildId,id) == 0)) {
-                // found child with matching id
-                // check degree
-                degree++;
-                if (degree == pathObj.degree()) {
-                    // degrees match, return result
-                    break;
-                }
-            }
-
-            // check the next child to see if it has the correct id
-            child = Rp_TreeNextSibling(child);
-            if (child == NULL) {
-                // end of the sibling list
-                // create new node? or return NULL pointer
-                // FIXME: use the RPXML_CREATE flag
-                if (create) {
-                    child = Rp_ParserXmlCreateNode(p, parent,
-                                childName, searchChildId);
-                    if (child == NULL) {
-                        break;
-                    }
-                } else {
-                    // exit, child not found
-                    break;
-                }
-            }
-            id = NULL;
-            Rp_TreeGetValue(p->tree,child,Rp_ParserXml_Field_ID,(void **)&id);
         }
 

trunk/src/objects/RpParserXML.h

@@ -29 +29 @@
 
 void Rp_ParserXmlParse(Rp_ParserXml *p, const char *xml);
+int Rp_ParserXmlNodeIdentify(Rp_ParserXml *p, Rp_TreeNode n,
+    const char *name, const char *id);
+void Rp_ParserXmlFindChild( Rp_ParserXml *p, Rp_TreeNode parent,
+    const char *childName, const char *childId, size_t degree,
+    Rp_TreeNode *child, size_t *numFound);
 Rp_TreeNode Rp_ParserXmlSearch( Rp_ParserXml *p, const char *path, int create);
 const char *Rp_ParserXmlGet(Rp_ParserXml *p, const char *path);

trunk/src/objects/RpPath.cc

@@ -134 +134 @@
 Path::__createComponent(
     const char *p,
-    int start,
-    int end,
+    int typeStart,
+    int typeEnd,
     int idOpenParen,
     int idCloseParen,
@@ -149 +149 @@
     c->degree = degree;
 
+    typeLen = typeEnd - typeStart;
     if (idOpenParen < idCloseParen) {
         // user specified an id
-        typeLen = idOpenParen - start;
         idLen = idCloseParen - idOpenParen - 1;
-    } else {
-        // no id found
-        typeLen = end - start;
     }
 
@@ -183 +180 @@
     if (typeLen >= 0) {
         tmp = new char[typeLen+1];
-        strncpy(tmp,(p+start),typeLen);
+        strncpy(tmp,(p+typeStart),typeLen);
         tmp[typeLen] = '\0';
         c->type = tmp;
@@ -215 +212 @@
 Path::__parse(const char *p)
 {
-    int start = 0;
-    int end = 0;
+    int typeStart = 0;
+    int typeEnd = -1;       // typeEnd must be less than typeStart
+                            // so we can check if there was a type
+    int curr = 0;
     int idOpenParen = -1;
     int idCloseParen = -1;
@@ -229 +228 @@
     }
 
-    while (p[end] != '\0') {
-        if (p[end] == '(') {
-            idOpenParen = end;
-        } else if (p[end] == ')') {
-            idCloseParen = end;
+    while (p[curr] != '\0') {
+        if (p[curr] == '(') {
+            idOpenParen = curr;
+            typeEnd = curr;
+        } else if (p[curr] == ')') {
+            idCloseParen = curr;
         } else if ( (idOpenParen <= idCloseParen) &&
-                    (end != 0) &&
-                    (p[end] >= '0') &&
-                    (p[end] <= '9') ) {
-            degree = (size_t) strtod(p+end, &newEnd);
+                    (curr != 0) &&
+                    (p[curr] >= '0') &&
+                    (p[curr] <= '9') ) {
+            // we are not inside the parens
+            // we are not at the start of the string
+            // the value is a digit
+            if (idOpenParen == idCloseParen) {
+                // we are before any possible parens
+                // and after the type
+                typeEnd = curr;
+            }
+            degree = (size_t) strtod(p+curr, &newEnd);
             if (degree == 0) {
                 // interpret degree of 0 same as degree of 1
@@ -247 +255 @@
                 newEnd -= 2;
             }
-            end += newEnd - (p + end);
-        } else if (p[end] == _ifs) {
-            c = __createComponent(p,start,end,idOpenParen,idCloseParen,degree);
+            curr += newEnd - (p + curr);
+        } else if ( (p[curr] == _ifs) &&
+                    ((idOpenParen == idCloseParen) ||
+                     (idOpenParen < idCloseParen)) ) {
+            // we see the _ifs
+            // we are not inside of the parens for the id tag
+            if (typeEnd < typeStart) {
+                // we didn't come across the end
+                // of the type string, so set it here.
+                typeEnd = curr;
+            }
+            c = __createComponent(p,typeStart,typeEnd,idOpenParen,idCloseParen,degree);
             if (c != NULL) {
                 Rp_ChainAppend(compList,c);
             }
 
-            start = end+1;
+            typeStart = curr+1;
             idOpenParen = -1;
             idCloseParen = -1;
-        }
-        end++;
-    }
-
-    c = __createComponent(p,start,end,idOpenParen,idCloseParen,degree);
+            degree = 1;
+        }
+        curr++;
+    }
+
+    if (typeEnd < typeStart) {
+        // < takes care of cases where there is no
+        // id and no degree, but there is still a type
+        typeEnd = curr;
+    }
+    c = __createComponent(p,typeStart,typeEnd,idOpenParen,idCloseParen,degree);
     if (c != NULL) {
         Rp_ChainAppend(compList,c);
@@ -291 +314 @@
                 b.append(c->type,len);
             }
+        }
+
+        if (c->degree > 1) {
+            b.appendf("%i",c->degree);
         }
 
@@ -428 +455 @@
     Rp_ChainLink *l = NULL;
 
-    /*
-    tmpBuf.clear();
-
-    if (_pathList == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    l = _currLink;
-
-    if (l == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
-
-    if (c == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    if (c->type != NULL) {
-        tmpBuf.appendf("%s",c->type);
-    }
-
-    if (c->degree != 1) {
-        tmpBuf.appendf("%zu",c->degree);
-    }
-
-    if (c->id != NULL) {
-        tmpBuf.appendf("(%s)",c->id);
-    }
-
-    // incase none of the above if statements are hit.
-    tmpBuf.append("\0",1);
-
-    return tmpBuf.bytes();
-    */
-
-
     if (_pathList == NULL) {
         return NULL;
@@ -571 +557 @@
 {
     Rp_ChainLink *l = NULL;
-
-    /*
-    tmpBuf.clear();
-
-    if (_pathList == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    l = _currLink;
-
-    if (l == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
-
-    if (c == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    if (c->id) {
-        tmpBuf.append(c->id);
-    }
-
-    tmpBuf.append("\0",1);
-
-    return tmpBuf.bytes();
-    */
 
     if (_pathList == NULL) {
@@ -664 +619 @@
     Rp_ChainLink *l = NULL;
 
-    /*
-    tmpBuf.clear();
-
-    if (_pathList == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    l = _currLink;
-
-    if (l == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
-
-    if (c == NULL) {
-        tmpBuf.append("\0",1);
-        return tmpBuf.bytes();
-    }
-
-    if (c->type) {
-        tmpBuf.append(c->type);
-    }
-
-    tmpBuf.append("\0",1);
-
-    return tmpBuf.bytes();
-    */
-
     if (_pathList == NULL) {
         return NULL;

trunk/src/objects/RpPlot.cc

@@ -249 +249 @@
 }
 
-/**********************************************************************/
-// METHOD: configure(Rp_ParserXml *c)
-/// construct a number object from the provided tree
-/**
- * construct a number object from the provided tree
- */
-
-void
-Plot::configure(size_t as, ClientData c)
-{
-    if (as == RPCONFIG_XML) {
-        __configureFromXml(c);
-    } else if (as == RPCONFIG_TREE) {
-        __configureFromTree(c);
-    }
-}
-
-/**********************************************************************/
-// METHOD: configureFromXml(const char *xmltext)
-/// configure the object based on Rappture1.1 xmltext
-/**
- * Configure the object based on the provided xml
- */
-
-void
-Plot::__configureFromXml(ClientData c)
-{
-    const char *xmltext = (const char *) c;
-    if (xmltext == NULL) {
-        // FIXME: setup error
-        return;
-    }
-
-    Rp_ParserXml *p = Rp_ParserXmlCreate();
-    Rp_ParserXmlParse(p, xmltext);
-    configure(RPCONFIG_TREE, p);
-
-    return;
-}
+
+/**********************************************************************/
+// METHOD: configureFromTree(ClientData p)
+/// configure the object from a Rappture1.1 based tree
+/**
+ * Configure the object from a Rappture1.1 based tree
+ */
 
 // FIXME: this is an incomplete definition of how to
@@ -309 +277 @@
 
     return;
-}
-
-/**********************************************************************/
-// METHOD: dump(size_t as, void *p)
-/// construct a number object from the provided tree
-/**
- * construct a number object from the provided tree
- */
-
-void
-Plot::dump(size_t as, ClientData c)
-{
-    if (as == RPCONFIG_XML) {
-        __dumpToXml(c);
-    } else if (as == RPCONFIG_TREE) {
-        __dumpToTree(c);
-    }
-}
-
-/**********************************************************************/
-// METHOD: dumpToXml(ClientData c)
-/// configure the object based on Rappture1.1 xmltext
-/**
- * Configure the object based on the provided xml
- */
-
-void
-Plot::__dumpToXml(ClientData c)
-{
-    if (c == NULL) {
-        // FIXME: setup error
-        return;
-    }
-
-    ClientDataXml *d = (ClientDataXml *) c;
-    Rp_ParserXml *parser = Rp_ParserXmlCreate();
-    __dumpToTree(parser);
-    _tmpBuf.appendf("%s",Rp_ParserXmlXml(parser));
-    d->retStr = _tmpBuf.bytes();
-    Rp_ParserXmlDestroy(&parser);
 }
 

trunk/src/objects/RpPlot.h

@@ -42 +42 @@
         Curve *getNthCurve(size_t n) const;
 
-        void configure(size_t as, ClientData p);
-        void dump(size_t as, ClientData p);
-
         const int is() const;
 
@@ -63 +60 @@
         static int __curveCopyFxn(void **to, void *from);
 
-        void __configureFromXml(ClientData c);
         void __configureFromTree(ClientData c);
-        void __dumpToXml(ClientData c);
         void __dumpToTree(ClientData c);
 };