Changeset 1560 for trunk/src/objects


Ignore:
Timestamp:
Aug 28, 2009 5:54:24 AM (12 years ago)
Author:
dkearney
Message:

updates to the object system, fixed up tree and xml parser objects, added some basic tests for them and adopted number object to accept xml text and configure itself from the parsed xml. added fermi3.cc example program which contains suggested interface from apps meeting.

Location:
trunk/src/objects
Files:
2 added
28 edited

Legend:

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

    r1528 r1560  
    4848LN              = ln -s
    4949
     50#               RpDXReader.h \
     51#               RpDXWriter.h \
     52
    5053HEADERS = \
    5154                RpAccessor.h \
     
    6265                RpHistogram.h \
    6366                RpNumber.h \
     67                RpParserXML.h \
    6468                RpPath.h \
    6569                RpPlot.h \
     
    7276LOCAL_HEADERS = \
    7377                RpHash.h
     78
     79#               RpDXReader.o \
     80#               RpDXWriter.o \
    7481
    7582OBJS = \
     
    8693                RpHistogram.o \
    8794                RpNumber.o \
     95                RpParserXML.o \
    8896                RpPath.o \
    8997                RpPlot.o \
  • trunk/src/objects/RpAccessor.h

    r1528 r1560  
    7171Accessor<const char *>::operator() (const char *val)
    7272{
     73    if (val == NULL) {
     74        return;
     75    }
     76
    7377    size_t len = strlen(val);
    7478    char *tmp = new char[len+1];
  • trunk/src/objects/RpArray1D.cc

    r1528 r1560  
    180180
    181181const char *
    182 Array1D::xml()
     182Array1D::xml(size_t indent, size_t tabstop)
    183183{
    184184    return "";
  • trunk/src/objects/RpArray1D.h

    r1528 r1560  
    4141    static const char type[];
    4242
    43     const char *xml(void);
     43    const char *xml(size_t indent, size_t tabstop);
    4444    const int is(void) const;
    4545
  • trunk/src/objects/RpAxisMarker.cc

    r1528 r1560  
    139139
    140140const char *
    141 AxisMarker::xml()
     141AxisMarker::xml(size_t indent, size_t tabstop)
    142142{
     143    size_t l1width = indent + tabstop;
     144    const char *sp = "";
     145
    143146    _tmpBuf.clear();
    144147
    145148    _tmpBuf.appendf(
    146 "        <marker>\n\
    147             <at>%g</at>\n\
    148             <label>%s</label>\n\
    149             <style>%s</style>\n\
    150         <marker>\n",_at,label(),_style);
     149"%6$*4$s<marker>\n\
     150%6$*5$s<at>%1$g</at>\n\
     151%6$*5$s<label>%2$s</label>\n\
     152%6$*5$s<style>%3$s</style>\n\
     153%6$*4$s<marker>\n",
     154        _at,label(),_style,indent,l1width,sp);
    151155
    152156    _tmpBuf.append("\0",1);
  • trunk/src/objects/RpAxisMarker.h

    r1528 r1560  
    3939        double at (void) const;
    4040
    41         const char *xml();
     41        const char *xml(size_t indent, size_t tabstop);
    4242        const int is(void) const;
    4343
  • trunk/src/objects/RpBoolean.cc

    r1528 r1560  
    6565
    6666const char *
    67 Boolean::xml()
     67Boolean::xml(size_t indent, size_t tabstop)
    6868{
     69    size_t l1width = indent + tabstop;
     70    size_t l2width = indent + (2*tabstop);
     71    const char *sp = "";
     72
    6973    Path p(path());
    7074    _tmpBuf.clear();
     
    7377
    7478    _tmpBuf.appendf(
    75 "<boolean id=\"%s\">\n\
    76     <about>\n\
    77         <label>%s</label>\n\
    78         <description>%s</description>\n\
    79     </about>\n\
    80     <default>%i</default>\n\
    81     <current>%i</current>\n\
    82 </boolean>",
    83        p.id(),label(),desc(),def(),cur());
     79"%9$*6$s<boolean id=\"%1$s\">\n\
     80%9$*7$s<about>\n\
     81%9$*8$s<label>%2$s</label>\n\
     82%9$*8$s<description>%3$s</description>\n\
     83%9$*7$s</about>\n\
     84%9$*7$s<default>%4$i</default>\n\
     85%9$*7$s<current>%5$i</current>\n\
     86%9$*6$s</boolean>",
     87       p.id(),label(),desc(),def(),cur(),indent,l1width,l2width,sp);
    8488
    8589    return _tmpBuf.bytes();
  • trunk/src/objects/RpBoolean.h

    r1528 r1560  
    3434        Accessor<int> cur;
    3535
    36         const char *xml();
     36        const char *xml(size_t indent, size_t tabstop);
    3737        const int is() const;
    3838};
  • trunk/src/objects/RpChoice.cc

    r1528 r1560  
    150150
    151151const char *
    152 Choice::xml()
    153 {
     152Choice::xml(size_t indent, size_t tabstop)
     153{
     154    size_t l1width = indent + tabstop;
     155    size_t l2width = indent + (2*tabstop);
     156    size_t l3width = indent + (3*tabstop);
     157    const char *sp = "";
     158
    154159    Path p(path());
    155160    _tmpBuf.clear();
    156161
    157162    _tmpBuf.appendf(
    158 "<choice id='%s'>\n\
    159     <about>\n\
    160         <label>%s</label>\n\
    161         <description>%s</description>\n\
    162     </about>\n",
    163        p.id(),label(),desc());
     163"%7$*4$s<choice id='%1$s'>\n\
     164%7$*5$s<about>\n\
     165%7$*6$s<label>%2$s</label>\n\
     166%7$*6$s<description>%3$s</description>\n\
     167%7$*5$s</about>\n",
     168       p.id(),label(),desc(),indent,l1width,l2width,sp);
    164169
    165170    Rp_ChainLink *l = NULL;
     
    168173        option *op = (option *)Rp_ChainGetValue(l);
    169174        _tmpBuf.appendf(
    170 "    <option>\n\
    171         <about>\n\
    172             <label>%s</label>\n\
    173             <description>%s</description>\n\
    174         </about>\n\
    175         <value>%s</value>\n\
    176     </option>\n",
    177            op->label(),op->desc(),op->val());
     175"%7$*4$s<option>\n\
     176%7$*5$s<about>\n\
     177%7$*6$s<label>%1$s</label>\n\
     178%7$*6$s<description>%2$s</description>\n\
     179%7$*5$s</about>\n\
     180%7$*5$s<value>%3$s</value>\n\
     181%7$*4$s</option>\n",
     182           op->label(),op->desc(),op->val(),l1width,l2width,l3width,sp);
    178183        l = Rp_ChainNextLink(l);
    179184    }
    180185
    181186    _tmpBuf.appendf(
    182 "    <default>%s</default>\n\
    183     <current>%s</current>\n\
    184 </choice>",
    185        def(),cur());
     187"%5$*4$s<default>%1$s</default>\n\
     188%5$*4$s<current>%2$s</current>\n\
     189%5$*3$s</choice>",
     190       def(),cur(),indent,l1width,sp);
    186191
    187192    return _tmpBuf.bytes();
  • trunk/src/objects/RpChoice.h

    r1528 r1560  
    4141        Choice& delOption ( const char *label);
    4242
    43         const char *xml();
     43        const char *xml(size_t indent, size_t tabstop);
    4444        const int is() const;
    4545
  • trunk/src/objects/RpCurve.cc

    r1528 r1560  
    259259
    260260const char *
    261 Curve::xml()
    262 {
     261Curve::xml(size_t indent, size_t tabstop)
     262{
     263    size_t l1width = indent + tabstop;
     264    size_t l2width = indent + (2*tabstop);
     265    const char *sp = "";
     266
    263267    Path p(path());
    264268
     
    267271
    268272    const double *dataArr[dims()];
     273    const char *type = propstr("type");
    269274
    270275    _tmpBuf.clear();
    271276
    272277    _tmpBuf.appendf(
    273 "<curve id=\"%s\">\n\
    274     <about>\n\
    275         <group>%s</group>\n\
    276         <label>%s</label>\n\
    277         <description>%s</description>\n\
    278     </about>\n", p.id(),group(),label(),desc());
     278"%9$*6$s<curve id=\"%1$s\">\n\
     279%9$*7$s<about>\n\
     280%9$*8$s<group>%2$s</group>\n\
     281%9$*8$s<label>%3$s</label>\n\
     282%9$*8$s<description>%4$s</description>\n\
     283%9$*8$s<type>%5$s</type>\n\
     284%9$*7$s</about>\n",
     285        p.id(),group(),label(),desc(),type,indent,l1width,l2width,sp);
    279286
    280287    for (size_t dim=0; dim < dims(); dim++) {
     
    283290        dataArr[dim] = tmpAxis->data();
    284291        _tmpBuf.appendf(
    285 "    <%s>\n\
    286         <label>%s</label>\n\
    287         <description>%s</description>\n\
    288         <units>%s</units>\n\
    289         <scale>%s</scale>\n\
    290     </%s>\n",
     292"%8$*6$s<%1$s>\n\
     293%8$*7$s<label>%2$s</label>\n\
     294%8$*7$s<description>%3$s</description>\n\
     295%8$*7$s<units>%4$s</units>\n\
     296%8$*7$s<scale>%5$s</scale>\n\
     297%8$*6$s</%1$s>\n",
    291298        tmpAxis->name(), tmpAxis->label(), tmpAxis->desc(),
    292         tmpAxis->units(), tmpAxis->scale(), tmpAxis->name());
    293     }
    294 
    295     _tmpBuf.append("    <component>\n        <xy>\n");
     299        tmpAxis->units(), tmpAxis->scale(),l1width,l2width,sp);
     300    }
     301
     302    _tmpBuf.appendf("%3$*1$s<component>\n%3$*2$s<xy>\n",l1width,l2width,sp);
    296303    for (size_t idx=0; idx < nmemb; idx++) {
    297304        for(size_t dim=0; dim < dims(); dim++) {
     
    300307        _tmpBuf.append("\n",1);
    301308    }
    302     _tmpBuf.append("        </xy>\n    </component>\n</curve>");
    303     _tmpBuf.append("\0",1);
     309    _tmpBuf.appendf("%4$*3$s</xy>\n%4$*2$s</component>\n%4$*1$s</curve>",
     310        indent, l1width, l2width, sp);
    304311
    305312    return _tmpBuf.bytes();
  • trunk/src/objects/RpCurve.h

    r1528 r1560  
    4848        size_t dims() const;
    4949
    50         const char *xml();
     50        const char *xml(size_t indent, size_t tabstop);
    5151        const int is() const;
    5252
  • trunk/src/objects/RpHistogram.cc

    r1528 r1560  
    315315
    316316const char *
    317 Histogram::xml()
    318 {
     317Histogram::xml(size_t indent, size_t tabstop)
     318{
     319    size_t l1width = indent + tabstop;
     320    size_t l2width = indent + (2*tabstop);
     321    const char *sp = "";
     322
    319323    Path p(path());
    320324
     
    327331
    328332    _tmpBuf.appendf(
    329 "<histogram id=\"%s\">\n\
    330     <about>\n\
    331         <group>%s</group>\n\
    332         <label>%s</label>\n\
    333         <description>%s</description>\n\
    334     </about>\n", p.id(),group(),label(),desc());
     333"%8$*5$s<histogram id=\"%1$s\">\n\
     334%8$*6$s<about>\n\
     335%8$*7$s<group>%2$s</group>\n\
     336%8$*7$s<label>%3$s</label>\n\
     337%8$*7$s<description>%4$s</description>\n\
     338%8$*6$s</about>\n",
     339        p.id(),group(),label(),desc(),indent,l1width,l2width,sp);
    335340
    336341    for (size_t dim=0; dim < dims(); dim++) {
     
    342347        }
    343348        _tmpBuf.appendf(
    344 "    <%s>\n\
    345         <label>%s</label>\n\
    346         <description>%s</description>\n\
    347         <units>%s</units>\n\
    348         <scale>%s</scale>\n",
     349"%8$*6$s<%1$s>\n\
     350%8$*7$s<label>%2$s</label>\n\
     351%8$*7$s<description>%3$s</description>\n\
     352%8$*7$s<units>%4$s</units>\n\
     353%8$*7$s<scale>%5$s</scale>\n",
    349354        tmpAxis->name(), tmpAxis->label(), tmpAxis->desc(),
    350         tmpAxis->units(), tmpAxis->scale());
     355        tmpAxis->units(), tmpAxis->scale(),l1width,l2width,sp);
    351356
    352357        if (_markerList != NULL) {
     
    355360                AxisMarker *m = (AxisMarker *) Rp_ChainGetValue(l);
    356361                if (strcmp(tmpAxis->name(),m->axisName()) == 0) {
    357                     _tmpBuf.append(m->xml());
     362                    _tmpBuf.append(m->xml(indent+tabstop,tabstop));
    358363                }
    359364                l = Rp_ChainNextLink(l);
    360365            }
    361366        }
    362         _tmpBuf.appendf("    </%s>\n",tmpAxis->name());
    363     }
    364 
    365     _tmpBuf.append("    <component>\n        <xhw>\n");
     367        _tmpBuf.appendf("%3$*2$s</%1$s>\n",tmpAxis->name(),l1width,sp);
     368    }
     369
     370    _tmpBuf.appendf("%3$*1$s<component>\n%3$*2$s<xhw>\n",l1width,l2width,sp);
    366371    for (size_t idx=0; idx < nmemb; idx++) {
    367372        for (size_t dim=0; dim < dims(); dim++) {
     
    370375        _tmpBuf.append("\n",1);
    371376    }
    372     _tmpBuf.append("        </xhw>\n    </component>\n</curve>");
    373     _tmpBuf.append("\0",1);
     377    _tmpBuf.appendf("%4$*3$s</xhw>\n%4$*2$s</component>\n%4$*1$s</curve>",
     378        indent,l1width,l2width,sp);
    374379
    375380    return _tmpBuf.bytes();
  • trunk/src/objects/RpHistogram.h

    r1528 r1560  
    7373        size_t nbins(void) const;
    7474
    75         const char *xml();
     75        const char *xml(size_t indent, size_t tabstop);
    7676        const int is(void) const;
    7777
  • trunk/src/objects/RpNumber.cc

    r1528 r1560  
    1515#include "RpUnits.h"
    1616#include "RpSimpleBuffer.h"
     17#include "RpUnitsCInterface.h"
     18#include "RpParserXML.h"
     19#include "RpPath.h"
    1720
    1821using namespace Rappture;
     
    2427     _presets (NULL)
    2528{
     29    // FIXME: empty names should be autoname'd
     30    this->name("");
    2631    this->path("");
    2732    this->label("");
     
    3136    this->min(0.0);
    3237    this->max(0.0);
    33     // need to set this to the None unit
     38    // FIXME: empty units should be set to the None unit
    3439    // this->units(units);
    3540}
    3641
    37 Number::Number(const char *path, const char *units, double val)
     42Number::Number(const char *name, const char *units, double val)
    3843   : Object (),
    3944     _minSet (0),
     
    4348    const RpUnits *u = NULL;
    4449
    45     this->path(path);
     50    this->name(name);
     51    this->path("");
    4652    this->label("");
    4753    this->desc("");
     
    5864}
    5965
    60 Number::Number(const char *path, const char *units, double val,
     66Number::Number(const char *name, const char *units, double val,
    6167               double min, double max, const char *label,
    6268               const char *desc)
     
    6874    const RpUnits *u = NULL;
    6975
    70     this->path(path);
     76    this->name(name);
     77    this->path("");
    7178    this->label(label);
    7279    this->desc(desc);
     
    112119    this->units(o.units());
    113120
    114     // need to copy _presets
     121    // FIXME: need to copy _presets
    115122}
    116123
     
    225232
    226233    return *this;
     234}
     235
     236Number&
     237Number::addPreset(const char *label, const char *desc, const char *val)
     238{
     239    double valval = 0.0;
     240    const char *valunits = "";
     241    char *endptr = NULL;
     242    int result = 0;
     243
     244    std::string vstr = RpUnits::convert(val,"",RPUNITS_UNITS_OFF,&result);
     245    if (result) {
     246        // probably shouldnt trust this result
     247        fprintf(stderr,"error in RpUnits::convert in addPreset\n");
     248    }
     249    size_t len = vstr.length();
     250    valunits = val+len;
     251
     252    valval = strtod(val,&endptr);
     253    if ( (endptr == val) || (endptr != valunits) ) {
     254        // error? strtod was not able to find the same
     255        // units location as RpUnits::convert
     256        fprintf(stderr,"error while parsing units in addPreset\n");
     257    }
     258
     259    return addPreset(label,desc,valval,valunits);
    227260}
    228261
     
    276309
    277310const char *
    278 Number::xml()
    279 {
     311Number::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
    280317    Path p(path());
    281318    _tmpBuf.clear();
    282319
    283320    _tmpBuf.appendf(
    284 "<number id='%s'>\n\
    285     <about>\n\
    286         <label>%s</label>\n\
    287         <description>%s</description>\n\
    288     </about>\n\
    289     <units>%s</units>\n",
    290        p.id(),label(),desc(),units());
     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);
    291328
    292329    if (_minSet) {
    293         _tmpBuf.appendf("    <min>%g%s</min>\n", min(),units());
     330        _tmpBuf.appendf("%4$*3$s<min>%1$g%2$s</min>\n", min(),units(),l1width,sp);
    294331    }
    295332    if (_maxSet) {
    296         _tmpBuf.appendf("    <max>%g%s</max>\n", max(),units());
     333        _tmpBuf.appendf("%4$*3$s<max>%1$g%2$s</max>\n", max(),units(),l1width,sp);
    297334    }
    298335
    299336    _tmpBuf.appendf(
    300 "    <default>%g%s</default>\n\
    301     <current>%g%s</current>\n\
    302 </number>",
    303        def(),units(),cur(),units());
     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);
    304341
    305342    return _tmpBuf.bytes();
    306343}
     344
     345/**********************************************************************/
     346// METHOD: xml(const char *xmltext)
     347/// configure the object based on Rappture1.1 xmltext
     348/**
     349 * Configure the object based on the provided xml
     350 */
     351
     352void
     353Number::xml(const char *xmltext)
     354{
     355    Rp_ParserXml *p = NULL;
     356
     357    p = Rp_ParserXmlCreate();
     358
     359    Rp_ParserXmlParse(p, xmltext);
     360
     361    Rp_TreeNode node = Rp_ParserXmlElement(p,NULL);
     362    name(Rp_ParserXmlNodeId(p,node));
     363    label(Rp_ParserXmlGet(p,"about.label"));
     364    desc(Rp_ParserXmlGet(p,"about.description"));
     365    units(Rp_ParserXmlGet(p,"units"));
     366    minFromStr(Rp_ParserXmlGet(p,"min"));
     367    maxFromStr(Rp_ParserXmlGet(p,"max"));
     368    defFromStr(Rp_ParserXmlGet(p,"default"));
     369    curFromStr(Rp_ParserXmlGet(p,"current"));
     370
     371    // collect info about the preset values
     372    Rp_Chain *childChain = Rp_ChainCreate();
     373    Rp_ParserXmlChildren(p,NULL,"preset",childChain);
     374    Rp_ChainLink *l = Rp_ChainFirstLink(childChain);
     375    while (l != NULL) {
     376        Rp_TreeNode presetNode = (Rp_TreeNode) Rp_ChainGetValue(l);
     377        Rp_ParserXmlBaseNode(p,presetNode);
     378
     379        const char *presetlabel = Rp_ParserXmlGet(p,"label");
     380        const char *presetdesc = Rp_ParserXmlGet(p,"description");
     381        const char *presetvalue = Rp_ParserXmlGet(p,"value");
     382        addPreset(presetlabel,presetdesc,presetvalue);
     383
     384
     385        l = Rp_ChainNextLink(l);
     386    }
     387
     388    Rp_ChainDestroy(childChain);
     389
     390    // return the base node to the tree root
     391    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/*
     403Rp_TreeNode
     404tree()
     405{
     406    return NULL;
     407}
     408*/
     409
     410/**********************************************************************/
     411// METHOD: tree(Rp_TreeNode root)
     412/// construct a number object from the provided tree
     413/**
     414 * construct a number object from the provided tree
     415 */
     416
     417/*
     418void
     419tree(
     420    Rp_TreeNode root)
     421{
     422    if (root == NULL) {
     423        // FIXME: setup error
     424    }
     425}
     426*/
    307427
    308428/**********************************************************************/
     
    321441
    322442
     443/**********************************************************************/
     444// METHOD: minFromStr()
     445/// xml helper function to receive min value as a string
     446/**
     447 * convert string to value and units and store as min
     448 */
     449
     450void
     451Number::minFromStr(
     452    const char *val)
     453{
     454    double numericVal = 0;
     455    int err = 0;
     456
     457    numericVal = rpConvertDbl(val,units(),&err);
     458
     459    if (!err) {
     460        min(numericVal);
     461    } else {
     462        // FIXME: add error code
     463    }
     464}
     465
     466/**********************************************************************/
     467// METHOD: maxFromStr()
     468/// xml helper function to receive max value as a string
     469/**
     470 * convert string to value and units and store as max
     471 */
     472
     473void
     474Number::maxFromStr(
     475    const char *val)
     476{
     477    double numericVal = 0;
     478    int err = 0;
     479
     480    numericVal = rpConvertDbl(val,units(),&err);
     481
     482    if (!err) {
     483        max(numericVal);
     484    } else {
     485        // FIXME: add error code
     486    }
     487}
     488
     489/**********************************************************************/
     490// METHOD: defFromStr()
     491/// xml helper function to receive default value as a string
     492/**
     493 * convert string to value and units and store as default
     494 */
     495
     496void
     497Number::defFromStr(
     498    const char *val)
     499{
     500    double numericVal = 0;
     501    int err = 0;
     502
     503    numericVal = rpConvertDbl(val,units(),&err);
     504
     505    if (!err) {
     506        def(numericVal);
     507    } else {
     508        // FIXME: add error code
     509    }
     510}
     511
     512/**********************************************************************/
     513// METHOD: currFromStr()
     514/// xml helper function to receive current value as a string
     515/**
     516 * convert string to value and units and store as current
     517 */
     518
     519void
     520Number::curFromStr(
     521    const char *val)
     522{
     523    double numericVal = 0;
     524    int err = 0;
     525
     526    numericVal = rpConvertDbl(val,units(),&err);
     527
     528    if (!err) {
     529        cur(numericVal);
     530    } else {
     531        // FIXME: add error code
     532    }
     533}
     534
     535
     536
    323537// -------------------------------------------------------------------- //
    324538
  • trunk/src/objects/RpNumber.h

    r1528 r1560  
    2222
    2323        Number();
    24         Number(const char *path, const char *units, double val);
     24        Number(const char *name, const char *units, double val);
    2525
    26         Number(const char *path, const char *units, double val,
     26        Number(const char *name, const char *units, double val,
    2727               double min, double max, const char *label,
    2828               const char *desc);
     
    5252                          double val, const char *units);
    5353
     54        Number& addPreset(const char *label, const char *desc,
     55                          const char *val);
     56
    5457        Number& delPreset(const char *label);
    5558
    56         const char* xml();
     59        const char* xml(size_t indent, size_t tabstop);
     60        void xml(const char *xmltext);
     61
     62        /*
     63        Rp_TreeNode tree();
     64        void tree(Rp_TreeNode root);
     65        */
     66
    5767        const int is() const;
     68
     69        void minFromStr(const char *val);
     70        void maxFromStr(const char *val);
     71        void defFromStr(const char *val);
     72        void curFromStr(const char *val);
    5873
    5974    private:
  • trunk/src/objects/RpObject.cc

    r1528 r1560  
    2525
    2626Object::Object (
     27    const char *name,
    2728    const char *path,
    2829    const char *label,
     
    3132    const char *color   )
    3233{
     34    this->name(name);
    3335    this->path(path);
    3436    this->label(label);
     
    4042Object::Object(const Object& o)
    4143{
     44    name(o.name());
    4245    path(o.path());
    4346    label(o.label());
     
    5861
    5962const char*
     63Object::name() const
     64{
     65    return propstr("name");
     66}
     67
     68void
     69Object::name(const char *p)
     70{
     71    propstr("name",p);
     72}
     73
     74const char*
    6075Object::path() const
    6176{
     
    201216    }
    202217
     218    if (val == NULL) {
     219        // no value provided, no value stored.
     220        // FIXME: raise error.
     221        return;
     222    }
     223
    203224    // set the value
    204225    // FIXME: this is suspect,
    205226    // want to use void's and void*'s but c++ wont let me
    206227    // g++ says there is no delete[] for void*
     228    // FIXME: can probably just get the length and use property() fxn
    207229    size_t l = strlen(val);
    208230    str = new char[l+1];
     
    276298
    277299const char *
    278 Object::xml() const
     300Object::xml(size_t indent, size_t tabstop) const
    279301{
    280302    return NULL;
  • trunk/src/objects/RpObject.h

    r1528 r1560  
    2424    public:
    2525        Object ();
    26         Object (const char *path,
     26        Object (const char *name,
     27                const char *path,
    2728                const char *label,
    2829                const char *desc,
     
    3132        Object (const Object& o);
    3233        virtual ~Object();
     34
     35        const char *name(void) const;
     36        void name(const char *p);
    3337
    3438        const char *path(void) const;
     
    4549
    4650        const char *color(void) const;
    47         void color(const char *);
     51        void color(const char *p);
    4852
    4953        // void *icon(void) const;
     
    6670
    6771        // get the Rappture1.1 xml text for this object
    68         virtual const char *xml() const;
     72        virtual const char *xml(size_t indent, size_t tabstop) const;
    6973
    7074        // set the object properties based on Rappture1.1 xml text
  • trunk/src/objects/RpPath.cc

    r1528 r1560  
    2323#include "RpChainHelper.h"
    2424#include <cstring>
     25#include <cstdlib>
    2526
    2627using namespace Rappture;
     
    6061    _ifs = b._ifs;
    6162
     63    //FIXME: i think this is broken
    6264    Rp_ChainCopy (_pathList, b._pathList, Rp_ChainCharCpyFxn);
    6365}
     
    105107    _ifs = '.';
    106108    _pathList = Rp_ChainCreate();
     109    _currLink = Rp_ChainFirstLink(_pathList);
    107110    return;
    108111}
     
    134137    int end,
    135138    int idOpenParen,
    136     int idCloseParen)
     139    int idCloseParen,
     140    size_t degree)
    137141{
    138142    componentStruct *c = new componentStruct();
     
    143147    c->type = NULL;
    144148    c->id = NULL;
     149    c->degree = degree;
    145150
    146151    if (idOpenParen < idCloseParen) {
     
    171176        the type and id of the third component are both blank.
    172177        for the above example paths, the id field of the first
    173         components, the index component, is NULL.
     178        components, the input component, is NULL.
    174179        i don't think there is a way to get a NULL type right now.
    175180    */
     
    215220    int idCloseParen = -1;
    216221    componentStruct *c = NULL;
     222    size_t degree = 1;
     223    char *newEnd = NULL;
    217224
    218225    Rp_Chain *compList = Rp_ChainCreate();
     
    227234        } else if (p[end] == ')') {
    228235            idCloseParen = end;
     236        } else if ( (idOpenParen <= idCloseParen) &&
     237                    (end != 0) &&
     238                    (p[end] >= '0') &&
     239                    (p[end] <= '9') ) {
     240            degree = (size_t) strtod(p+end, &newEnd);
     241            if (degree == 0) {
     242                // interpret degree of 0 same as degree of 1
     243                degree = 1;
     244            }
     245            // check if we consumed the _ifs
     246            if (*(newEnd-1) == _ifs) {
     247                newEnd -= 2;
     248            }
     249            end += newEnd - (p + end);
    229250        } else if (p[end] == _ifs) {
    230             c = __createComponent(p,start,end,idOpenParen,idCloseParen);
     251            c = __createComponent(p,start,end,idOpenParen,idCloseParen,degree);
    231252            if (c != NULL) {
    232253                Rp_ChainAppend(compList,c);
     
    240261    }
    241262
    242     c = __createComponent(p,start,end,idOpenParen,idCloseParen);
     263    c = __createComponent(p,start,end,idOpenParen,idCloseParen,degree);
    243264    if (c != NULL) {
    244265        Rp_ChainAppend(compList,c);
     
    335356}
    336357
     358bool
     359Path::eof ()
     360{
     361    return (_currLink == NULL);
     362}
     363
     364Path&
     365Path::first ()
     366{
     367    _currLink = Rp_ChainFirstLink(_pathList);
     368    return *this;
     369}
     370
     371Path&
     372Path::prev ()
     373{
     374    if (_currLink) {
     375        _currLink = Rp_ChainPrevLink(_currLink);
     376    }
     377    return *this;
     378}
     379
     380Path&
     381Path::next ()
     382{
     383    if (_currLink) {
     384        _currLink = Rp_ChainNextLink(_currLink);
     385    }
     386    return *this;
     387}
     388
     389Path&
     390Path::last ()
     391{
     392    _currLink = Rp_ChainLastLink(_pathList);
     393    return *this;
     394}
     395
     396size_t
     397Path::count ()
     398{
     399    return Rp_ChainGetLength(_pathList);
     400}
     401
    337402const char *
    338403Path::component(void)
    339404{
    340405    Rp_ChainLink *l = NULL;
    341     size_t len = 0;
    342 
     406
     407    /*
    343408    tmpBuf.clear();
    344409
     
    348413    }
    349414
    350     l = Rp_ChainLastLink(_pathList);
     415    l = _currLink;
    351416
    352417    if (l == NULL) {
     
    363428
    364429    if (c->type != NULL) {
    365         len = strlen(c->type);
    366         if (len > 0) {
    367             tmpBuf.append(c->type,len);
    368         }
     430        tmpBuf.appendf("%s",c->type);
     431    }
     432
     433    if (c->degree != 1) {
     434        tmpBuf.appendf("%zu",c->degree);
    369435    }
    370436
    371437    if (c->id != NULL) {
    372         tmpBuf.append("(",1);
    373         len = strlen(c->id);
    374         if (len > 0) {
    375             tmpBuf.append(c->id,len);
    376         }
    377         tmpBuf.append(")",1);
    378     }
    379 
     438        tmpBuf.appendf("(%s)",c->id);
     439    }
     440
     441    // incase none of the above if statements are hit.
     442    tmpBuf.append("\0",1);
     443
     444    return tmpBuf.bytes();
     445    */
     446
     447
     448    if (_pathList == NULL) {
     449        return NULL;
     450    }
     451
     452    l = _currLink;
     453
     454    if (l == NULL) {
     455        return NULL;
     456    }
     457
     458    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
     459
     460    if (c == NULL) {
     461        return NULL;
     462    }
     463
     464    tmpBuf.clear();
     465
     466    if (c->type != NULL) {
     467        tmpBuf.appendf("%s",c->type);
     468    }
     469
     470    if (c->degree != 1) {
     471        tmpBuf.appendf("%zu",c->degree);
     472    }
     473
     474    if (c->id != NULL) {
     475        tmpBuf.appendf("(%s)",c->id);
     476    }
     477
     478    // incase none of the above if statements are hit.
    380479    tmpBuf.append("\0",1);
    381480
     
    426525    Rp_ChainDestroy(addList);
    427526
    428     // remove the last component from the current path
    429     l = Rp_ChainLastLink(_pathList);
     527    // swap the current component from the current path
     528    // with the component from the provided path.
     529    l = _currLink;
    430530
    431531    if (l != NULL) {
    432532        componentStruct *last = (componentStruct *) Rp_ChainGetValue(l);
    433533        delete last;
    434         Rp_ChainDeleteLink(_pathList,l);
    435     }
    436 
    437     // append the new component onto the current path
    438     Rp_ChainAppend(_pathList,aLcomp);
     534        Rp_ChainSetValue(l,aLcomp);
     535    } else {
     536        // add a new component as a link
     537        // point _currLink to the new component
     538        _currLink = Rp_ChainAppend(_pathList,aLcomp);
     539    }
    439540
    440541    __updateBuffer();
     
    448549    Rp_ChainLink *l = NULL;
    449550
     551    /*
    450552    tmpBuf.clear();
    451553
     
    455557    }
    456558
    457     l = Rp_ChainLastLink(_pathList);
     559    l = _currLink;
    458560
    459561    if (l == NULL) {
     
    476578
    477579    return tmpBuf.bytes();
     580    */
     581
     582    if (_pathList == NULL) {
     583        return NULL;
     584    }
     585
     586    l = _currLink;
     587
     588    if (l == NULL) {
     589        return NULL;
     590    }
     591
     592    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
     593
     594    if (c == NULL) {
     595        return NULL;
     596    }
     597
     598    return c->id;
    478599}
    479600
     
    490611    componentStruct *last = NULL;
    491612
    492     // update the last component from the current path
    493     l = Rp_ChainLastLink(_pathList);
     613    // update the current component from the current path
     614    l = _currLink;
    494615
    495616    if (l != NULL) {
     
    499620        // append the new component onto the current path
    500621        last = new componentStruct;
    501         Rp_ChainAppend(_pathList,last);
     622        _currLink = Rp_ChainAppend(_pathList,last);
    502623        tmp = new char[1];
    503624        *tmp = '\0';
     
    520641    Rp_ChainLink *l = NULL;
    521642
     643    /*
    522644    tmpBuf.clear();
    523645
     
    527649    }
    528650
    529     l = Rp_ChainLastLink(_pathList);
     651    l = _currLink;
    530652
    531653    if (l == NULL) {
     
    548670
    549671    return tmpBuf.bytes();
     672    */
     673
     674    if (_pathList == NULL) {
     675        return NULL;
     676    }
     677
     678    l = _currLink;
     679
     680    if (l == NULL) {
     681        return NULL;
     682    }
     683
     684    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
     685
     686    if (c == NULL) {
     687        return NULL;
     688    }
     689
     690    return c->type;
    550691}
    551692
     
    563704
    564705    // update the last component from the current path
    565     l = Rp_ChainLastLink(_pathList);
     706    l = _currLink;
    566707
    567708    if (l != NULL) {
     
    571712        // append the new component onto the current path
    572713        last = new componentStruct;
    573         Rp_ChainAppend(_pathList,last);
     714        _currLink = Rp_ChainAppend(_pathList,last);
    574715        last->id = NULL;
    575716    }
     
    593734    tmpBuf.clear();
    594735
    595     last = Rp_ChainLastLink(_pathList);
     736    last = _currLink;
    596737    l = Rp_ChainFirstLink(_pathList);
    597738    while (l != last) {
     
    685826}
    686827
     828size_t
     829Path::degree()
     830{
     831    Rp_ChainLink *l = NULL;
     832
     833    l = _currLink;
     834
     835    if (l == NULL) {
     836        return 0;
     837    }
     838
     839    componentStruct *c = (componentStruct *) Rp_ChainGetValue(l);
     840
     841    if (c == NULL) {
     842        return 0;
     843    }
     844
     845    return c->degree;
     846}
     847
     848void
     849Path::degree(size_t d)
     850{
     851    if (d == 0) {
     852        d = 1;
     853    }
     854
     855    Rp_ChainLink *l = NULL;
     856    componentStruct *last = NULL;
     857
     858    // update the current component from the current path
     859    l = _currLink;
     860
     861    if (l != NULL) {
     862        last = (componentStruct *) Rp_ChainGetValue(l);
     863    } else {
     864        // append the new component onto the current path
     865        last = new componentStruct;
     866        _currLink = Rp_ChainAppend(_pathList,last);
     867    }
     868
     869    // adjust the degree field
     870    last->degree = d;
     871
     872    __updateBuffer();
     873
     874    return;
     875}
     876
    687877const char *
    688878Path::path(void)
     
    696886    if (p != NULL) {
    697887        _pathList = __parse(p);
     888        _currLink = Rp_ChainLastLink(_pathList);
    698889        __updateBuffer();
    699890    }
  • trunk/src/objects/RpPath.h

    r1528 r1560  
    4848    Path& add(const char *el);  // turns input into input.number(blah)
    4949    Path& del();                // turns input.number(blah) into input
     50    bool eof();
     51
     52    Path& first();
     53    Path& prev();
     54    Path& next();
     55    Path& last();
     56    size_t count();
    5057
    5158    // turns input.number(blah) into number(blah)
    52     const char *component(void);    // get component of the path
    53     void component(const char *p);  // set component of the path
     59    const char *component(void);    // get component of the current component
     60    void component(const char *p);  // set component of the current component
    5461
    5562    // turns input.number(blah) into blah
    56     const char *id(void);       // get the id of the path
    57     void id(const char *p);     // set the id of the path
     63    const char *id(void);       // get the id of the current component
     64    void id(const char *p);     // set the id of the current component
    5865
    5966    // turns input.number(blah) into number
    60     const char *type(void);     // get the type of the path
    61     void type(const char *p);   // set the type of the path
     67    const char *type(void);     // get the type of the current component
     68    void type(const char *p);   // set the type of the current component
    6269
    6370    // turns input.number(blah) into input
    64     const char *parent(void);   // get the parent of the path
    65     void parent(const char *p); // set the parent of the path
     71    const char *parent(void);   // get the parent of the current component
     72    void parent(const char *p); // set the parent of the current component
     73
     74    // turns input.number2(blah) into 2
     75    size_t degree(void);        // get the degree of the current component
     76    void degree(size_t degree); // set the degree of the current component
    6677
    6778    const char *path(void);     // get the path
     
    7384        const char *type;
    7485        const char *id;
     86        size_t degree;
    7587    } componentStruct;
    7688
     
    8092    Rp_Chain *__parse(const char *p);
    8193    componentStruct *__createComponent(const char *p, int start,
    82                         int end, int idOpenParen, int idCloseParen);
     94                        int end, int idOpenParen, int idCloseParen,
     95                        size_t degree);
    8396    void __deleteComponent(componentStruct *c);
    8497
    8598    char _ifs;
    8699    Rp_Chain *_pathList;
     100    Rp_ChainLink *_currLink;
    87101    SimpleCharBuffer b;
    88102    SimpleCharBuffer tmpBuf;
  • trunk/src/objects/RpPlot.cc

    r1528 r1560  
    258258
    259259const char *
    260 Plot::xml()
     260Plot::xml(size_t indent, size_t tabstop)
    261261{
    262262
     
    302302        }
    303303
    304         _tmpBuf.append(c->xml());
     304        _tmpBuf.append(c->xml(indent,tabstop));
    305305        _tmpBuf.append("\n",1);
    306306        l = Rp_ChainNextLink(l);
  • trunk/src/objects/RpPlot.h

    r1528 r1560  
    4242        Curve *getNthCurve(size_t n) const;
    4343
    44         const char *xml();
     44        const char *xml(size_t indent, size_t tabstop);
    4545        const int is() const;
    4646
  • trunk/src/objects/RpScatter.cc

    r1528 r1560  
    2323    this->desc("");
    2424    this->group("");
     25    propstr("type","scatter");
    2526}
    2627
     
    3233    this->desc("");
    3334    this->group("");
     35    propstr("type","scatter");
    3436}
    3537
     
    4244    this->desc(desc);
    4345    this->group(group);
     46    propstr("type","scatter");
    4447}
    4548
     
    7174 */
    7275
     76/*
    7377const char *
    74 Scatter::xml()
     78Scatter::xml(size_t indent, size_t tabstop)
    7579{
    7680// FIXME: the xml function should just read an array
     
    122126    return _tmpBuf.bytes();
    123127}
     128*/
    124129
    125130/**********************************************************************/
  • trunk/src/objects/RpScatter.h

    r1528 r1560  
    3333        virtual ~Scatter();
    3434
    35         const char *xml();
     35        // const char *xml();
    3636        const int is() const;
    3737
  • trunk/src/objects/RpString.cc

    r1528 r1560  
    7878
    7979const char *
    80 String::xml()
     80String::xml(size_t indent, size_t tabstop)
    8181{
     82    size_t l1width = indent + tabstop;
     83    size_t l2width = indent + (2*tabstop);
     84    const char *sp = "";
     85
    8286    Path p(path());
    8387    _tmpBuf.clear();
    8488
    8589    _tmpBuf.appendf(
    86 "<string id='%s'>\n\
    87     <about>\n\
    88         <label>%s</label>\n\
    89         <description>%s</description>\n\
    90         <hints>%s</hints>\n\
    91     </about>\n\
    92     <size>%ix%i</size>\n\
    93     <default>%s</default>\n\
    94     <current>%s</current>\n\
    95 </string>\n",
    96        p.id(),label(),desc(),hints(),width(),height(),def(),cur());
     90"%12$*9$s<string id='%1$s'>\n\
     91%12$*10$s<about>\n\
     92%12$*11$s<label>%2$s</label>\n\
     93%12$*11$s<description>%3$s</description>\n\
     94%12$*11$s<hints>%4$s</hints>\n\
     95%12$*10$s</about>\n\
     96%12$*10$s<size>%5$ix%6$i</size>\n\
     97%12$*10$s<default>%7$s</default>\n\
     98%12$*10$s<current>%8$s</current>\n\
     99%12$*9$s</string>\n",
     100       p.id(),label(),desc(),hints(),width(),height(),def(),cur(),
     101       indent, l1width, l2width, sp);
    97102
    98103    return _tmpBuf.bytes();
  • trunk/src/objects/RpString.h

    r1528 r1560  
    3939    Accessor<size_t> height;
    4040
    41     const char *xml();
     41    const char *xml(size_t indent, size_t tabstop);
    4242    const int is() const;
    4343
  • trunk/src/objects/RpTree.c

    r1528 r1560  
    220220 */
    221221static Node *
    222 NewNode(TreeObject *treeObjPtr, CONST char *name, int inode)
     222NewNode(TreeObject *treeObjPtr, CONST char *name, size_t inode)
    223223{
    224224    Node *nodePtr;
     
    840840    Node *nodePtr;  /* Node to be inserted. */
    841841    TreeObject *treeObjPtr;
    842     int inode;
     842    size_t inode;
    843843    int isNew;
    844844
     
    890890                             * be inserted. */
    891891    CONST char *name,       /* Name of node. */
    892     int inode,              /* Requested id of the new node. If a
     892    size_t inode,           /* Requested id of the new node. If a
    893893                             * node by this id already exists in the
    894894                             * tree, no node is created. */
     
    10041004
    10051005Rp_TreeNode
    1006 Rp_TreeGetNode(TreeClient *clientPtr, unsigned int inode)
     1006Rp_TreeGetNode(TreeClient *clientPtr, size_t inode)
    10071007{
    10081008    TreeObject *treeObjPtr = clientPtr->treeObject;
     
    10991099    label = Rp_TreeGetKey(string);
    11001100    for (nodePtr = parentPtr->first; nodePtr != NULL; nodePtr = nodePtr->next) {
     1101        if (label == nodePtr->label) {
     1102            return nodePtr;
     1103        }
     1104    }
     1105    return NULL;
     1106}
     1107
     1108/*
     1109 *----------------------------------------------------------------------
     1110 *
     1111 * Rp_TreeFindChildNext --
     1112 *
     1113 *  Searches for the next named node in a parent's chain of siblings.
     1114 *
     1115 *
     1116 * Results:
     1117 *  If found, the child node is returned, otherwise NULL.
     1118 *
     1119 *----------------------------------------------------------------------
     1120 */
     1121Rp_TreeNode
     1122Rp_TreeFindChildNext(Node *childPtr, CONST char *string)
     1123{
     1124    Rp_TreeKey label;
     1125    register Node *nodePtr;
     1126
     1127    label = Rp_TreeGetKey(string);
     1128    for (nodePtr = childPtr->next; nodePtr != NULL; nodePtr = nodePtr->next) {
    11011129        if (label == nodePtr->label) {
    11021130            return nodePtr;
     
    14811509}
    14821510
     1511/*
     1512 * commented out to avoid compiler warnings about function not being used
     1513 */
     1514/*
    14831515static int
    14841516ParseParentheses(
     
    14871519    char **rightPtr)
    14881520{
    1489     register char *p;
    1490     char *left, *right;
     1521    register char *p = NULL;
     1522    char *left = NULL;
     1523    char *right = NULL;
    14911524
    14921525    left = right = NULL;
     
    15101543    return RP_OK;
    15111544}
     1545*/
    15121546
    15131547//FIXME: commented out because it calls Rp_TreeGetArrayValue
    1514 //int
    1515 //Rp_TreeGetValue(
    1516 //    TreeClient *clientPtr,
    1517 //    Node *nodePtr,
    1518 //    CONST char *string,     /* String identifying the field in node. */
    1519 //    void **objPtrPtr)
    1520 //{
    1521 //    char *left, *right;
    1522 //    int result;
    1523 //
     1548int
     1549Rp_TreeGetValue(
     1550    TreeClient *clientPtr,
     1551    Node *nodePtr,
     1552    CONST char *string,     /* String identifying the field in node. */
     1553    void **objPtrPtr)
     1554{
     1555    char *left = NULL;
     1556    char *right = NULL;
     1557    int result;
     1558
     1559// uncomment after Rp_TreeGetArrayValue is fixed
    15241560//    if (ParseParentheses(string, &left, &right) != TCL_OK) {
    15251561//        return TCL_ERROR;
    15261562//    }
    1527 //    if (left != NULL) {
    1528 //        *left = *right = '\0';
    1529 //        result = Rp_TreeGetArrayValue(clientPtr, nodePtr, string, left + 1, objPtrPtr);
    1530 //        *left = '(', *right = ')';
    1531 //    } else {
    1532 //        result = Rp_TreeGetValueByKey(clientPtr, nodePtr,
    1533 //                    Rp_TreeGetKey(string), objPtrPtr);
    1534 //    }
    1535 //    return result;
    1536 //}
     1563    if (left != NULL) {
     1564        *left = *right = '\0';
     1565        // result = Rp_TreeGetArrayValue(clientPtr, nodePtr, string, left + 1, objPtrPtr);
     1566        *left = '(', *right = ')';
     1567    } else {
     1568        result = Rp_TreeGetValueByKey(clientPtr, nodePtr,
     1569                    Rp_TreeGetKey(string), objPtrPtr);
     1570    }
     1571    return result;
     1572}
    15371573
    15381574//FIXME: commented out because it calls Rp_TreeSetArrayValue
    1539 //int
    1540 //Rp_TreeSetValue(
    1541 //    TreeClient *clientPtr,
    1542 //    Node *nodePtr,          /* Node to be updated. */
    1543 //    CONST char *string,     /* String identifying the field in node. */
    1544 //    void *valueObjPtr)      /* New value of field. If NULL, field
    1545 //                             * is deleted. */
    1546 //{
    1547 //    char *left, *right;
    1548 //    int result;
    1549 //
     1575int
     1576Rp_TreeSetValue(
     1577    TreeClient *clientPtr,
     1578    Node *nodePtr,          /* Node to be updated. */
     1579    CONST char *string,     /* String identifying the field in node. */
     1580    void *valueObjPtr)      /* New value of field. If NULL, field
     1581                             * is deleted. */
     1582{
     1583    char *left = NULL;
     1584    char *right = NULL;
     1585    int result;
     1586
     1587// uncomment after Rp_TreeSetArrayValue is fixed
    15501588//    if (ParseParentheses(string, &left, &right) != RP_OK) {
    15511589//        return RP_ERROR;
    15521590//    }
    1553 //    if (left != NULL) {
    1554 //        *left = *right = '\0';
    1555 //        result = Rp_TreeSetArrayValue(clientPtr, nodePtr, string, left + 1, valueObjPtr);
    1556 //        fprintf(stderr, "Rp_TreeSetArrayValue not supported\n", name);
    1557 //
    1558 //        *left = '(', *right = ')';
    1559 //    } else {
    1560 //        result = Rp_TreeSetValueByKey(clientPtr, nodePtr,
    1561 //                    Rp_TreeGetKey(string), valueObjPtr);
    1562 //    }
    1563 //    return result;
    1564 //}
     1591    if (left != NULL) {
     1592        *left = *right = '\0';
     1593        //result = Rp_TreeSetArrayValue(clientPtr, nodePtr, string, left + 1, valueObjPtr);
     1594        *left = '(', *right = ')';
     1595    } else {
     1596        result = Rp_TreeSetValueByKey(clientPtr, nodePtr,
     1597                    Rp_TreeGetKey(string), valueObjPtr);
     1598    }
     1599    return result;
     1600}
    15651601
    15661602//FIXME: commented out because it calls Rp_TreeUnsetArrayValue
    1567 //int
    1568 //Rp_TreeUnsetValue(
    1569 //    TreeClient *clientPtr,
    1570 //    Node *nodePtr,          /* Node to be updated. */
    1571 //    CONST char *string)     /* String identifying the field in node. */
    1572 //{
    1573 //    char *left, *right;
    1574 //    int result;
    1575 //
     1603int
     1604Rp_TreeUnsetValue(
     1605    TreeClient *clientPtr,
     1606    Node *nodePtr,          /* Node to be updated. */
     1607    CONST char *string)     /* String identifying the field in node. */
     1608{
     1609    char *left = NULL;
     1610    char *right = NULL;
     1611    int result;
     1612
     1613// uncomment after Rp_TreeUnsetArrayValue is fixed
    15761614//    if (ParseParentheses(string, &left, &right) != RP_OK) {
    15771615//        return RP_ERROR;
    15781616//    }
    1579 //    if (left != NULL) {
    1580 //        *left = *right = '\0';
    1581 //        result = Rp_TreeUnsetArrayValue(clientPtr, nodePtr, string, left + 1);
    1582 //        *left = '(', *right = ')';
    1583 //    } else {
    1584 //        result = Rp_TreeUnsetValueByKey(clientPtr, nodePtr, Rp_TreeGetKey(string));
    1585 //    }
    1586 //    return result;
    1587 //}
     1617    if (left != NULL) {
     1618        *left = *right = '\0';
     1619        // result = Rp_TreeUnsetArrayValue(clientPtr, nodePtr, string, left + 1);
     1620        *left = '(', *right = ')';
     1621    } else {
     1622        result = Rp_TreeUnsetValueByKey(clientPtr, nodePtr, Rp_TreeGetKey(string));
     1623    }
     1624    return result;
     1625}
    15881626
    15891627//FIXME: commented out because it calls Rp_TreeArrayValueExists
    1590 //int
    1591 //Rp_TreeValueExists(TreeClient *clientPtr, Node *nodePtr, CONST char *string)
    1592 //{
    1593 //    char *left, *right;
    1594 //    int result;
    1595 //
     1628int
     1629Rp_TreeValueExists(TreeClient *clientPtr, Node *nodePtr, CONST char *string)
     1630{
     1631    char *left = NULL;
     1632    char *right = NULL;
     1633    int result;
     1634
     1635// uncomment after Rp_TreeArrayValueExists is fixed
    15961636//    if (ParseParentheses(string, &left, &right) != RP_OK) {
    15971637//        return FALSE;
    15981638//    }
    1599 //    if (left != NULL) {
    1600 //        *left = *right = '\0';
    1601 //        result = Rp_TreeArrayValueExists(clientPtr, nodePtr, string, left + 1);
    1602 //        *left = '(', *right = ')';
    1603 //    } else {
    1604 //        result = Rp_TreeValueExistsByKey(clientPtr, nodePtr,
    1605 //                Rp_TreeGetKey(string));
    1606 //    }
    1607 //    return result;
    1608 //}
     1639    if (left != NULL) {
     1640        *left = *right = '\0';
     1641        // result = Rp_TreeArrayValueExists(clientPtr, nodePtr, string, left + 1);
     1642        *left = '(', *right = ')';
     1643    } else {
     1644        result = Rp_TreeValueExistsByKey(clientPtr, nodePtr,
     1645                Rp_TreeGetKey(string));
     1646    }
     1647    return result;
     1648}
    16091649
    16101650Rp_TreeKey
     
    19551995//    return RP_OK;
    19561996//}
     1997
     1998int
     1999Rp_TreeGetTokenFromToken(
     2000    TreeClient *fromClientPtr, // old client from which to base the new client
     2001    TreeClient **clientPtrPtr) // new client
     2002{
     2003    TreeClient *clientPtr;
     2004    TreeObject *treeObjPtr;
     2005
     2006    if (fromClientPtr == NULL) {
     2007        fprintf(stderr, "can't create new token from null token\n");
     2008        return RP_ERROR;
     2009    }
     2010
     2011    treeObjPtr = fromClientPtr->treeObject;
     2012    if (treeObjPtr == NULL) {
     2013        fprintf(stderr, "can't find a tree object based on provided client\n");
     2014        return RP_ERROR;
     2015    }
     2016    clientPtr = NewTreeClient(treeObjPtr);
     2017    if (clientPtr == NULL) {
     2018        fprintf(stderr, "can't allocate token for tree \"%s\"",
     2019            treeObjPtr->name);
     2020        return RP_ERROR;
     2021    }
     2022    *clientPtrPtr = clientPtr;
     2023    return RP_OK;
     2024}
    19572025
    19582026void
     
    30313099            RebuildTable(nodePtr);
    30323100        }
    3033         } else {
     3101    } else {
    30343102        Value *prevPtr;
    30353103
  • trunk/src/objects/RpTree.h

    r1528 r1560  
    192192
    193193    unsigned int nChildren; /* # of children for this node. */
    194     unsigned int inode;     /* Serial number of the node. */
     194    // unsigned int inode;     /* Serial number of the node. */
     195    size_t inode;           /* Serial number of the node. */
    195196
    196197    unsigned short depth;   /* The depth of this node in the tree. */
     
    281282        Rp_TreeNode parent, CONST char *name, int position));
    282283EXTERN Rp_TreeNode Rp_TreeCreateNodeWithId _ANSI_ARGS_((Rp_Tree tree,
    283         Rp_TreeNode parent, CONST char *name, int position, int inode));
     284        Rp_TreeNode parent, CONST char *name, size_t inode, int position));
    284285
    285286EXTERN int Rp_TreeDeleteNode _ANSI_ARGS_((Rp_Tree tree, Rp_TreeNode node));
     
    288289        Rp_TreeNode parent, Rp_TreeNode before));
    289290
    290 EXTERN Rp_TreeNode Rp_TreeGetNode _ANSI_ARGS_((Rp_Tree tree,
    291         unsigned int inode));
     291EXTERN Rp_TreeNode Rp_TreeGetNode _ANSI_ARGS_((Rp_Tree tree, size_t inode));
    292292
    293293EXTERN Rp_TreeNode Rp_TreeFindChild _ANSI_ARGS_((Rp_TreeNode parent,
     294        CONST char *name));
     295
     296EXTERN Rp_TreeNode Rp_TreeFindChildNext _ANSI_ARGS_((Rp_TreeNode child,
    294297        CONST char *name));
    295298
     
    391394        Rp_TreeApplyProc *proc, ClientData clientData));
    392395
     396EXTERN int Rp_TreeApplyXML _ANSI_ARGS_((Rp_TreeNode root,
     397        Rp_TreeApplyProc *proc, ClientData clientData));
     398
    393399EXTERN int Rp_TreeSortNode _ANSI_ARGS_((Rp_Tree tree, Rp_TreeNode node,
    394400        Rp_TreeCompareNodesProc *proc));
     
    399405// EXTERN int Rp_TreeExists _ANSI_ARGS_((CONST char *name));
    400406
    401 EXTERN int Rp_TreeGetToken _ANSI_ARGS_((CONST char *name,
    402         Rp_Tree *treePtr));
     407// EXTERN int Rp_TreeGetToken _ANSI_ARGS_((CONST char *name,
     408//         Rp_Tree *treePtr));
     409
     410EXTERN int Rp_TreeGetTokenFromToken _ANSI_ARGS_((
     411        CONST Rp_Tree tree, Rp_Tree *newToken));
    403412
    404413EXTERN void Rp_TreeReleaseToken _ANSI_ARGS_((Rp_Tree tree));
Note: See TracChangeset for help on using the changeset viewer.