Changeset 1566 for trunk/src/objects


Ignore:
Timestamp:
Sep 14, 2009 3:18:36 PM (12 years ago)
Author:
dkearney
Message:

updates to Rappture::Library and Rappture::Number objects to demo how the library should store objects and generate the xml for those objects upon request. opting for configure() and dump() functions for objects. the object should know how to configure it self from a string of xml, tree object or (in the future) blob of hdf5. added some rudimentary examples of using the library object.

Location:
trunk/src/objects
Files:
3 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/objects/Makefile.in

    r1560 r1566  
    6464                RpHashHelper.h \
    6565                RpHistogram.h \
     66                RpLibObj.h \
    6667                RpNumber.h \
    6768                RpParserXML.h \
     
    7273                RpString.h \
    7374                RpTree.h \
     75                RpObjConfig.h \
    7476                RpObject.h
    7577
     
    9294                RpHashHelper.o \
    9395                RpHistogram.o \
     96                RpLibObj.o \
    9497                RpNumber.o \
    9598                RpParserXML.o \
     
    115118        $(RM) $@
    116119        $(SHLIB_LD) $(SHLIB_LDFLAGS) -o $@ $(OBJS) \
    117                 $(LIB_SEARCH_DIRS) $(LIBS)  -lstdc++
     120                $(LIB_SEARCH_DIRS) $(LIBS)  -lstdc++ -lexpat
    118121
    119122$(lib): $(OBJS)
  • trunk/src/objects/RpChainHelper.c

    r1528 r1566  
    5656        Rp_ChainUnlinkLink(c2,l);
    5757        Rp_ChainAppendLink(c1,l);
     58        l = Rp_ChainFirstLink(c2);
     59    }
     60
     61    return c1;
     62}
     63
     64Rp_Chain *
     65Rp_ChainInsertChainAfter (
     66    Rp_Chain *c1,
     67    Rp_Chain *c2,
     68    Rp_ChainLink *at)
     69{
     70    Rp_ChainLink *l = NULL;
     71
     72    if (c1 == NULL) {
     73        return c2;
     74    }
     75
     76    if (c2 == NULL) {
     77        return c1;
     78    }
     79
     80    l = Rp_ChainLastLink(c2);
     81    while (l != NULL) {
     82        Rp_ChainUnlinkLink(c2,l);
     83        Rp_ChainLinkAfter(c1,l,at);
     84        l = Rp_ChainLastLink(c2);
     85    }
     86
     87    return c1;
     88}
     89
     90Rp_Chain *
     91Rp_ChainInsertChainBefore (
     92    Rp_Chain *c1,
     93    Rp_Chain *c2,
     94    Rp_ChainLink *at)
     95{
     96    Rp_ChainLink *l = NULL;
     97
     98    if (c1 == NULL) {
     99        return c2;
     100    }
     101
     102    if (c2 == NULL) {
     103        return c1;
     104    }
     105
     106    l = Rp_ChainFirstLink(c2);
     107    while (l != NULL) {
     108        Rp_ChainUnlinkLink(c2,l);
     109        Rp_ChainLinkBefore(c1,l,at);
    58110        l = Rp_ChainFirstLink(c2);
    59111    }
  • trunk/src/objects/RpChainHelper.h

    r1528 r1566  
    1212// int chain2hash(Rp_Chain *c, Rp_HashTable *h);
    1313
    14 Rp_Chain * Rp_ChainJoin     ( Rp_Chain *c1,
    15                               Rp_Chain *c2);
     14Rp_Chain *Rp_ChainJoin (Rp_Chain *c1, Rp_Chain *c2);
    1615
    17 Rp_Chain * Rp_ChainConcat   ( Rp_Chain *c1,
    18                               Rp_Chain *c2);
     16Rp_Chain *Rp_ChainConcat (Rp_Chain *c1, Rp_Chain *c2);
     17Rp_Chain *Rp_ChainInsertChainAfter (Rp_Chain *c1, Rp_Chain *c2, Rp_ChainLink *at);
     18Rp_Chain *Rp_ChainInsertChainBefore (Rp_Chain *c1, Rp_Chain *c2, Rp_ChainLink *at);
    1919
    20 int Rp_ChainCopy            ( Rp_Chain *c1,
    21                               Rp_Chain *c2,
    22                               int (*cpyFxn)(void **to,void *from));
     20int Rp_ChainCopy (Rp_Chain *c1, Rp_Chain *c2,
     21                  int (*cpyFxn)(void **to,void *from));
    2322
    2423int Rp_ChainCharCpyFxn (void **to, void *from);
  • trunk/src/objects/RpNumber.cc

    r1560 r1566  
    1616#include "RpSimpleBuffer.h"
    1717#include "RpUnitsCInterface.h"
    18 #include "RpParserXML.h"
    1918#include "RpPath.h"
    2019
     
    302301
    303302/**********************************************************************/
    304 // METHOD: xml()
    305 /// view this object's xml
    306 /**
    307  * View this object as an xml element returned as text.
    308  */
    309 
    310 const char *
    311 Number::xml(size_t indent, size_t tabstop)
    312 {
    313     size_t l1width = indent + (1*tabstop);
    314     size_t l2width = indent + (2*tabstop);
    315     const char *sp = "";
    316 
    317     Path p(path());
    318     _tmpBuf.clear();
    319 
    320     _tmpBuf.appendf(
    321 "%8$*5$s<number id='%1$s'>\n\
    322 %8$*6$s<about>\n\
    323 %8$*7$s<label>%2$s</label>\n\
    324 %8$*7$s<description>%3$s</description>\n\
    325 %8$*6$s</about>\n\
    326 %8$*6$s<units>%4$s</units>\n",
    327        p.id(),label(),desc(),units(),indent,l1width,l2width,sp);
    328 
    329     if (_minSet) {
    330         _tmpBuf.appendf("%4$*3$s<min>%1$g%2$s</min>\n", min(),units(),l1width,sp);
    331     }
    332     if (_maxSet) {
    333         _tmpBuf.appendf("%4$*3$s<max>%1$g%2$s</max>\n", max(),units(),l1width,sp);
    334     }
    335 
    336     _tmpBuf.appendf(
    337 "%6$*5$s<default>%1$g%3$s</default>\n\
    338 %6$*5$s<current>%2$g%3$s</current>\n\
    339 %6$*4$s</number>",
    340        def(),cur(),units(),indent,l1width,sp);
    341 
    342     return _tmpBuf.bytes();
    343 }
    344 
    345 /**********************************************************************/
    346 // METHOD: xml(const char *xmltext)
     303// METHOD: configure(Rp_ParserXml *p)
     304/// construct a number object from the provided tree
     305/**
     306 * construct a number object from the provided tree
     307 */
     308
     309void
     310Number::configure(size_t as, void *p)
     311{
     312    if (as == RPCONFIG_XML) {
     313        __configureFromXml((const char *)p);
     314    } else if (as == RPCONFIG_TREE) {
     315        __configureFromTree((Rp_ParserXml *)p);
     316    }
     317}
     318
     319/**********************************************************************/
     320// METHOD: configureFromXml(const char *xmltext)
    347321/// configure the object based on Rappture1.1 xmltext
    348322/**
     
    351325
    352326void
    353 Number::xml(const char *xmltext)
    354 {
    355     Rp_ParserXml *p = NULL;
    356 
    357     p = Rp_ParserXmlCreate();
    358 
     327Number::__configureFromXml(const char *xmltext)
     328{
     329    if (xmltext == NULL) {
     330        // FIXME: setup error
     331        return;
     332    }
     333
     334    Rp_ParserXml *p = Rp_ParserXmlCreate();
    359335    Rp_ParserXmlParse(p, xmltext);
     336    configure(RPCONFIG_TREE, p);
     337
     338    return;
     339}
     340
     341void
     342Number::__configureFromTree(Rp_ParserXml *p)
     343{
     344    if (p == NULL) {
     345        // FIXME: setup error
     346        return;
     347    }
    360348
    361349    Rp_TreeNode node = Rp_ParserXmlElement(p,NULL);
     350
     351    Rappture::Path pathObj(Rp_ParserXmlNodePath(p,node));
     352
     353    path(pathObj.parent());
    362354    name(Rp_ParserXmlNodeId(p,node));
    363355    label(Rp_ParserXmlGet(p,"about.label"));
     
    390382    // return the base node to the tree root
    391383    Rp_ParserXmlBaseNode(p,NULL);
    392 }
    393 
    394 /**********************************************************************/
    395 // METHOD: tree()
    396 /// return the object as a tree
    397 /**
    398  * Represent the object as a tree.
    399  * An Rp_TreeNode is returned.
    400  */
    401 
    402 /*
    403 Rp_TreeNode
    404 tree()
    405 {
    406     return NULL;
    407 }
    408 */
    409 
    410 /**********************************************************************/
    411 // METHOD: tree(Rp_TreeNode root)
     384
     385    return;
     386}
     387
     388/**********************************************************************/
     389// METHOD: dump(size_t as, void *p)
    412390/// construct a number object from the provided tree
    413391/**
     
    415393 */
    416394
    417 /*
    418 void
    419 tree(
    420     Rp_TreeNode root)
    421 {
    422     if (root == NULL) {
     395void
     396Number::dump(size_t as, ClientData p)
     397{
     398    if (as == RPCONFIG_XML) {
     399        __dumpToXml((clientdata_xml *)p);
     400    } else if (as == RPCONFIG_TREE) {
     401        __dumpToTree((clientdata_tree *)p);
     402    }
     403}
     404
     405/**********************************************************************/
     406// METHOD: dumpToXml(ClientData p)
     407/// configure the object based on Rappture1.1 xmltext
     408/**
     409 * Configure the object based on the provided xml
     410 */
     411
     412void
     413Number::__dumpToXml(ClientData c)
     414{
     415    if (c == NULL) {
    423416        // FIXME: setup error
    424     }
    425 }
    426 */
     417        return;
     418    }
     419
     420    clientdata_xml *d = (clientdata_xml *)c;
     421
     422    size_t l1width = d->indent + (1*d->tabstop);
     423    size_t l2width = d->indent + (2*d->tabstop);
     424    const char *sp = "";
     425
     426    Path p(path());
     427    _tmpBuf.clear();
     428
     429    _tmpBuf.appendf(
     430"%8$*5$s<number id='%1$s'>\n\
     431%8$*6$s<about>\n\
     432%8$*7$s<label>%2$s</label>\n\
     433%8$*7$s<description>%3$s</description>\n\
     434%8$*6$s</about>\n\
     435%8$*6$s<units>%4$s</units>\n",
     436       p.id(),label(),desc(),units(),d->indent,l1width,l2width,sp);
     437
     438    if (_minSet) {
     439        _tmpBuf.appendf("%4$*3$s<min>%1$g%2$s</min>\n", min(),units(),l1width,sp);
     440    }
     441    if (_maxSet) {
     442        _tmpBuf.appendf("%4$*3$s<max>%1$g%2$s</max>\n", max(),units(),l1width,sp);
     443    }
     444
     445    _tmpBuf.appendf(
     446"%6$*5$s<default>%1$g%3$s</default>\n\
     447%6$*5$s<current>%2$g%3$s</current>\n\
     448%6$*4$s</number>",
     449       def(),cur(),units(),d->indent,l1width,sp);
     450
     451    d->retStr =  _tmpBuf.bytes();
     452}
     453
     454/**********************************************************************/
     455// METHOD: dumpToTree(ClientData p)
     456/// dump the object to a Rappture1.1 based tree
     457/**
     458 * Dump the object to a Rappture1.1 based tree
     459 */
     460
     461void
     462Number::__dumpToTree(ClientData c)
     463{
     464    if (c == NULL) {
     465        // FIXME: setup error
     466        return;
     467    }
     468
     469    Rp_ParserXml *parser = (Rp_ParserXml *)c;
     470
     471    Path p;
     472
     473    p.parent(path());
     474    p.last();
     475
     476    p.add("number");
     477    p.id(name());
     478
     479    p.add("about");
     480
     481    p.add("label");
     482    Rp_ParserXmlPutF(parser,p.path(),"%s",label());
     483
     484    p.del();
     485    p.add("description");
     486    Rp_ParserXmlPutF(parser,p.path(),"%s",desc());
     487
     488    p.del();
     489    p.del();
     490    p.add("units");
     491    Rp_ParserXmlPutF(parser,p.path(),"%s",units());
     492
     493
     494    if (_minSet) {
     495        p.del();
     496        p.add("min");
     497        Rp_ParserXmlPutF(parser,p.path(),"%g",min());
     498    }
     499
     500    if (_maxSet) {
     501        p.del();
     502        p.add("max");
     503        Rp_ParserXmlPutF(parser,p.path(),"%g",max());
     504    }
     505
     506    p.del();
     507    p.add("default");
     508    Rp_ParserXmlPutF(parser,p.path(),"%g",def());
     509
     510    p.del();
     511    p.add("current");
     512    Rp_ParserXmlPutF(parser,p.path(),"%g",cur());
     513
     514    // still need to add presets
     515    return;
     516}
    427517
    428518/**********************************************************************/
  • trunk/src/objects/RpNumber.h

    r1560 r1566  
    5757        Number& delPreset(const char *label);
    5858
    59         const char* xml(size_t indent, size_t tabstop);
    60         void xml(const char *xmltext);
    6159
    62         /*
    63         Rp_TreeNode tree();
    64         void tree(Rp_TreeNode root);
    65         */
     60        void configure(size_t as, ClientData p);
     61        void dump(size_t as, ClientData p);
     62        // const char* xml(size_t indent, size_t tabstop);
    6663
    6764        const int is() const;
     
    8885        };
    8986
     87        void __configureFromXml(const char *p);
     88        void __configureFromTree(Rp_ParserXml *p);
     89        void __dumpToXml(ClientData c);
     90        void __dumpToTree(ClientData c);
    9091};
    9192
  • trunk/src/objects/RpObject.cc

    r1560 r1566  
    303303}
    304304
     305/*
    305306void
    306307Object::xml(const char *xmltext)
     308{
     309    return;
     310}
     311*/
     312
     313void
     314Object::configure(size_t as, void *p)
     315{
     316    return;
     317}
     318
     319void
     320Object::dump(size_t as, void *p)
    307321{
    308322    return;
  • trunk/src/objects/RpObject.h

    r1560 r1566  
    1717#include "RpBuffer.h"
    1818#include "RpPath.h"
     19#include "RpParserXML.h"
     20#include "RpObjConfig.h"
    1921
    2022namespace Rappture {
     
    7375
    7476        // set the object properties based on Rappture1.1 xml text
    75         virtual void xml(const char *xmltext);
     77        // virtual void xml(const char *xmltext);
     78
     79        // configure the object properties based on Rappture1.1 xml text
     80        virtual void configure(size_t as, void *p);
     81        virtual void dump(size_t as, void *p);
    7682
    7783        virtual const int is() const;
  • trunk/src/objects/RpParserXML.cc

    r1560 r1566  
    1212 */
    1313
     14#include <errno.h>
     15#include <expat.h>
     16#include <string.h>
     17#include <stdarg.h>
    1418#include "RpParserXML.h"
    1519#include "RpSimpleBuffer.h"
    1620#include "RpPath.h"
    17 
    18 static const char *Rp_ParserXml_Field_ID = "id";
    19 static const char *Rp_ParserXml_Field_VALUE = "value";
    20 static const char *Rp_ParserXml_Field_VISITED = "visited";
    2121
    2222struct Rp_ParserXmlStruct {
     
    2727};
    2828
     29const char *Rp_ParserXml_Field_ID = "id";
     30const char *Rp_ParserXml_Field_VALUE = "value";
     31const char *Rp_ParserXml_Field_VISITED = "visited";
     32const char *Rp_ParserXml_TreeRootName = "rapptureTree";
    2933
    3034static void XMLCALL
     
    127131    Rp_ParserXml *p = new Rp_ParserXml();
    128132
    129     Rp_TreeCreate("rapptureTree",&(p->tree));
     133    Rp_TreeCreate(Rp_ParserXml_TreeRootName,&(p->tree));
    130134    p->curr = Rp_TreeRootNode(p->tree);
    131135    p->path = new Rappture::Path();
     
    340344    Rp_TreeNode child = Rp_ParserXmlSearch(p, path, 1);
    341345
    342     if (child != NULL) {
    343         // check to see if there is already a value
    344         if (RP_OK == Rp_TreeGetValue(p->tree,child,
     346    if (child == NULL) {
     347        // error while searching for node?
     348        return;
     349    }
     350
     351    // check to see if there is already a value
     352    if (RP_OK == Rp_TreeGetValue(p->tree,child,
     353                    Rp_ParserXml_Field_VALUE,
     354                    (void **)&oldval)) {
     355        if (oldval != NULL) {
     356            // FIXME: use the RPXML_APPEND flag
     357            if (append) {
     358                oldval_len = strlen(oldval);
     359                val_len = strlen(val);
     360                newval = new char[oldval_len + val_len + 1];
     361                strncpy(newval,oldval,oldval_len);
     362            }
     363            // free the old data
     364            delete(oldval);
     365            oldval = NULL;
     366        }
     367    }
     368
     369    // allocate space for our new value if needed
     370    if (newval == NULL) {
     371        // set the new value for the node
     372        val_len = strlen(val);
     373        newval = new char[val_len + 1];
     374    }
     375
     376    strcpy(newval+oldval_len,val);
     377
     378    // set the value of the child node
     379    if (RP_ERROR == Rp_TreeSetValue(p->tree,child,
    345380                        Rp_ParserXml_Field_VALUE,
    346                         (void **)&oldval)) {
    347             if (oldval != NULL) {
    348                 // FIXME: use the RPXML_APPEND flag
    349                 if (append) {
    350                     oldval_len = strlen(oldval);
    351                     val_len = strlen(val);
    352                     newval = new char[oldval_len + val_len + 1];
    353                     strncpy(newval,oldval,oldval_len);
    354                 }
    355                 // free the old data
    356                 delete(oldval);
    357                 oldval = NULL;
    358             }
    359         }
    360 
    361         // allocate space for our new value if needed
    362         if (newval == NULL) {
    363             // set the new value for the node
    364             val_len = strlen(val);
    365             newval = new char[val_len + 1];
    366         }
    367 
    368         strcpy(newval+oldval_len,val);
    369 
    370         // set the value of the child node
    371         if (RP_ERROR == Rp_TreeSetValue(p->tree,child,
    372                             Rp_ParserXml_Field_VALUE,
    373                             (void *)newval)) {
    374             fprintf(stderr,"error while setting value of %s\n",path);
    375         }
    376     }
     381                        (void *)newval)) {
     382        fprintf(stderr,"error while setting value of %s\n",path);
     383    }
     384
     385    /*
     386    if (p->curr == p->root) {
     387        // reset the root node
     388        p->curr = Rp_TreeFirstChild(p->root);
     389    }
     390    */
     391
    377392    return;
    378393}
     394
     395void
     396Rp_ParserXmlPutF(
     397    Rp_ParserXml *p,
     398    const char *path,
     399    const char *format,
     400    ...)
     401{
     402    if (format == NULL) {
     403        // no value, do nothing
     404        return;
     405    }
     406
     407    Rp_TreeNode child = Rp_ParserXmlSearch(p, path, 1);
     408
     409    if (child == NULL) {
     410        fprintf(stderr, "child node %s does not exist", path);
     411        return;
     412    }
     413
     414    // check to see if there is already a value
     415    const char *oldval = NULL;
     416    if (RP_OK == Rp_TreeGetValue(p->tree,child,
     417                    Rp_ParserXml_Field_VALUE,
     418                    (void **)&oldval)) {
     419        if (oldval != NULL) {
     420            // free the old data
     421            delete(oldval);
     422            oldval = NULL;
     423        }
     424    }
     425
     426    // store the formatted string in the tree node
     427    size_t stackSize = 1024;
     428    char *stackSpace = new char[stackSize];
     429    va_list lst;
     430    size_t n;
     431
     432    va_start(lst, format);
     433    n = vsnprintf(stackSpace, stackSize, format, lst);
     434    if (n >= stackSize) {
     435        delete stackSpace;
     436        stackSpace = new char[n];
     437        vsnprintf(stackSpace, n, format, lst);
     438    }
     439
     440    // set the value of the child node
     441    if (RP_ERROR == Rp_TreeSetValue(p->tree,child,
     442                        Rp_ParserXml_Field_VALUE,
     443                        (void *)stackSpace)) {
     444        fprintf(stderr,"error while setting value of %s\n",path);
     445    }
     446
     447    /*
     448    if (p->curr == p->root) {
     449        // reset the root node
     450        p->curr = Rp_TreeFirstChild(p->root);
     451    }
     452    */
     453
     454    return;
     455}
     456
     457void
     458Rp_ParserXmlAppendF(
     459    Rp_ParserXml *p,
     460    const char *path,
     461    const char *format,
     462    ...)
     463{
     464    if (format == NULL) {
     465        // no value, do nothing
     466        return;
     467    }
     468
     469    Rp_TreeNode child = Rp_ParserXmlSearch(p, path, 1);
     470
     471    if (child == NULL) {
     472        fprintf(stderr, "child node %s does not exist", path);
     473        return;
     474    }
     475
     476    // check to see if there is already a value
     477    const char *oldval = NULL;
     478    Rp_TreeGetValue(p->tree,child, Rp_ParserXml_Field_VALUE, (void **)&oldval);
     479
     480    // get the formatted string
     481    size_t stackSize = 1024;
     482    char *stackSpace = new char[stackSize];
     483    va_list lst;
     484    size_t n;
     485
     486    va_start(lst, format);
     487    n = vsnprintf(stackSpace, stackSize, format, lst);
     488    if (n >= stackSize) {
     489        delete stackSpace;
     490        stackSpace = new char[n];
     491        vsnprintf(stackSpace, n, format, lst);
     492    }
     493
     494    // concatenate the formatted string and the old value
     495    char *newval = stackSpace;
     496    if (oldval != NULL) {
     497        size_t oldval_len = strlen(oldval);
     498        newval = new char[n+oldval_len+1];
     499        strcpy(newval, oldval);
     500        strcat(newval,stackSpace);
     501        // free the old data
     502        delete(oldval);
     503        oldval = NULL;
     504        delete(stackSpace);
     505        stackSpace = NULL;
     506    }
     507
     508    // set the value of the child node
     509    if (RP_ERROR == Rp_TreeSetValue(p->tree,child,
     510                        Rp_ParserXml_Field_VALUE,
     511                        (void *)newval)) {
     512        fprintf(stderr,"error while setting value of %s\n",path);
     513    }
     514
     515    /*
     516    if (p->curr == p->root) {
     517        // reset the root node
     518        p->curr = Rp_TreeFirstChild(p->root);
     519    }
     520    */
     521
     522    return;
     523}
     524
    379525
    380526Rp_Tree
     
    408554
    409555    Rp_TreeGetValue(p->tree,node,Rp_ParserXml_Field_VALUE,(void **)&value);
    410     size_t valLen = strlen(value);
     556    size_t valLen = 0;
     557    if (value != NULL) {
     558        valLen = strlen(value);
     559    }
    411560
    412561    if (!Rp_TreeValueExists(p->tree,node,Rp_ParserXml_Field_VISITED)) {
     
    468617    p->buf->appendf("<?xml version=\"1.0\"?>\n");
    469618
    470     Rp_TreeNode root = p->curr;
     619    Rp_TreeNode root = Rp_TreeRootNode(p->tree);
     620    if (p->curr == root) {
     621        // reset the root node
     622        root = Rp_TreeFirstChild(root);
     623    } else {
     624        root = p->curr;
     625    }
    471626
    472627    Rp_TreeApplyDFS(root, printXmlData, (ClientData)p, TREE_PREORDER|TREE_POSTORDER);
     
    540695    p->path = new Rappture::Path();
    541696
    542     Rp_TreeNode root = p->curr;
     697    // Rp_TreeNode root = p->curr;
     698    Rp_TreeNode root = Rp_TreeRootNode(p->tree);
     699    if (p->curr == root) {
     700        // reset the root node
     701        root = Rp_TreeFirstChild(root);
     702    } else {
     703        root = p->curr;
     704    }
    543705
    544706    Rp_TreeApplyDFS(root, printPathVal, (ClientData)p, TREE_PREORDER|TREE_POSTORDER);
     
    599761    Rp_TreeNode node = Rp_ParserXmlSearch(p,path,!RPXML_CREATE);
    600762
    601     if (node != NULL) {
     763    if (node == NULL) {
     764        return count;
     765    }
     766
     767    if (type == NULL) {
     768        node = Rp_TreeFirstChild(node);
     769        while (node != NULL) {
     770            count++;
     771            Rp_ChainAppend(children,(void*)node);
     772            node = Rp_TreeNextSibling(node);
     773        }
     774    } else {
    602775        node = Rp_TreeFindChild(node,type);
    603776        while (node != NULL) {
     
    607780        }
    608781    }
     782
    609783    return count;
    610784}
     
    648822}
    649823
    650 /*
    651824const char *
    652825Rp_ParserXmlNodePath(
     
    654827    Rp_TreeNode node)
    655828{
    656     Path pathObj("junk");
     829    Rappture::Path pathObj;
    657830
    658831    const char *type = NULL;
    659832    const char *id = NULL;
    660833
    661     // FIXME: path's add and del don't work on the current node
    662834    if (p != NULL) {
    663         while (node != p->curr) {
    664             type = Rp_TreeNodeLabel(node)
    665             Rp_TreeGetValue(p->tree,child, Rp_ParserXml_Field_ID,(void **)&id);
    666             pathObj.first();
    667             pathObj.add(type);
    668             pathObj.id(id);
     835        while (node != NULL) {
     836            type = Rp_TreeNodeLabel(node);
     837            pathObj.parent(type);
     838            if (RP_OK == Rp_TreeGetValue(p->tree,node,
     839                            Rp_ParserXml_Field_ID,(void **)&id)) {
     840                pathObj.id(id);
     841            }
    669842            node = Rp_TreeNodeParent(node);
    670843        }
    671844    }
    672845
     846    // remove the tree name from the path
    673847    pathObj.first();
    674848    pathObj.del();
    675     return path
    676 }
    677 */
     849    // remove the <run> tag from the path
     850    // pathObj.del();
     851
     852    p->path->path(pathObj.path());
     853    return p->path->path();
     854}
    678855
    679856const char *
  • trunk/src/objects/RpParserXML.h

    r1560 r1566  
    88 * ======================================================================
    99 */
    10 #include <errno.h>
    11 #include <expat.h>
    12 #include <string.h>
    1310#include "RpTree.h"
    1411#include "RpChain.h"
     
    2421};
    2522
     23extern const char *Rp_ParserXml_Field_ID;
    2624
    2725typedef struct Rp_ParserXmlStruct Rp_ParserXml;
     
    3331Rp_TreeNode Rp_ParserXmlSearch( Rp_ParserXml *p, const char *path, int create);
    3432const char *Rp_ParserXmlGet(Rp_ParserXml *p, const char *path);
    35 void Rp_ParserXmlPut(Rp_ParserXml *p, const char *path, const char *val,
    36     int append);
     33void Rp_ParserXmlPut(Rp_ParserXml *p, const char *path, const char *val, int append);
     34void Rp_ParserXmlPutF(Rp_ParserXml *p, const char *path, const char *val, ...);
     35void Rp_ParserXmlAppendF(Rp_ParserXml *p, const char *path, const char *val, ...);
    3736
    3837Rp_Tree Rp_ParserXmlTreeClient(Rp_ParserXml *p);
     
    4645void Rp_ParserXmlBaseNode(Rp_ParserXml *p, Rp_TreeNode node);
    4746
    48 // const char *Rp_ParserXmlNodePath(Rp_ParserXml *p, Rp_TreeNode node);
     47const char *Rp_ParserXmlNodePath(Rp_ParserXml *p, Rp_TreeNode node);
    4948const char *Rp_ParserXmlNodeId(Rp_ParserXml *p, Rp_TreeNode node);
    5049
  • trunk/src/objects/RpPath.cc

    r1560 r1566  
    55 *  AUTHOR:  Derrick Kearney, Purdue University
    66 *
    7  *  Copyright (c) 2004-2008  Purdue Research Foundation
     7 *  Copyright (c) 2005-2009  Purdue Research Foundation
    88 * ----------------------------------------------------------------------
    99 *  See the file "license.terms" for information on usage and
     
    328328{
    329329    Rp_Chain *addList = NULL;
     330    Rp_ChainLink *tmpLink = NULL;
    330331
    331332    addList = __parse(el);
    332     Rp_ChainConcat(_pathList,addList);
     333    tmpLink = Rp_ChainLastLink(addList);
     334    Rp_ChainInsertChainAfter(_pathList,addList,_currLink);
     335    _currLink = tmpLink;
    333336
    334337    __updateBuffer();
     
    342345    Rp_ChainLink *l = NULL;
    343346
    344     l = Rp_ChainLastLink(_pathList);
     347    // l = Rp_ChainLastLink(_pathList);
     348
     349    if (_currLink != NULL) {
     350        l = _currLink;
     351    } else {
     352        l = Rp_ChainLastLink(_pathList);
     353    }
    345354
    346355    if (l != NULL) {
     
    348357        __deleteComponent(c);
    349358        c = NULL;
     359        _currLink = Rp_ChainPrevLink(l);
     360        if (_currLink == NULL) {
     361            // don't go off the beginning of the list
     362            _currLink = Rp_ChainNextLink(l);
     363            // if _currLink is still NULL, it means the list is blank
     364        }
    350365        Rp_ChainDeleteLink(_pathList,l);
    351366    }
     
    767782Path::parent(const char *p)
    768783{
    769 // FIXME:
    770 /*
    771     if (p == NULL) {
    772         return;
    773     }
    774 
    775784    Rp_Chain *addList = NULL;
    776     Rp_ChainLink *l = NULL;
     785    Rp_ChainLink *tmpLink = NULL;
    777786
    778787    addList = __parse(p);
    779 
    780     if (addList == NULL) {
    781         // no parent path?
    782         return;
    783     }
    784 
    785     // get the last component of pathList
    786     l = Rp_ChainLastLink(_pathList);
    787 
    788     if (l == NULL) {
    789         // nothing to add
    790         Rp_ChainDestroy(addList);
    791         return;
    792     }
    793 
    794     componentStruct *aLcomp = (componentStruct *) Rp_ChainGetValue(l);
    795     Rp_ChainDeleteLink(_pathList,l);
    796 
    797     // delete addList
    798     l = Rp_ChainFirstLink(addList);
    799     while (l != NULL) {
    800         componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
    801         delete c;
    802         l = Rp_ChainNextLink(l);
    803     }
    804     Rp_ChainDestroy(addList);
    805 
    806     // update the last component from the current path
    807     l = Rp_ChainLastLink(_pathList);
    808 
    809     if (l != NULL) {
    810         componentStruct *last = (componentStruct *) Rp_ChainGetValue(l);
    811         Rp_ChainDeleteLink(_pathList,l);
    812         delete last->type;
    813         last->type = aLcomp->type;
    814         delete aLcomp->type;
    815         delete aLcomp;
    816     } else {
    817         // append the new component onto the current path
    818         delete aLcomp->id;
    819         Rp_ChainAppend(_pathList,aLcomp);
    820     }
     788    // maybe make this an input flag, FirstLink (default) or LastLink
     789    tmpLink = Rp_ChainFirstLink(addList);
     790    Rp_ChainInsertChainBefore(_pathList,addList,_currLink);
     791    _currLink = tmpLink;
    821792
    822793    __updateBuffer();
    823794
    824 */
    825795    return;
    826796}
Note: See TracChangeset for help on using the changeset viewer.