Changeset 1528 for trunk/src/objects


Ignore:
Timestamp:
Jun 22, 2009, 3:16:39 PM (15 years ago)
Author:
dkearney
Message:

updating the objects code and adding some more examples describing how i want developers to use the objects. some of the objects don't work yet, like the tree, anything with an example should work

Location:
trunk/src/objects
Files:
12 added
18 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/src/objects/Makefile.in

    r1389 r1528  
    5151                RpAccessor.h \
    5252                RpArray1D.h \
     53                RpArray1DUniform.h \
     54                RpAxisMarker.h \
    5355                RpBoolean.h \
    5456                RpChain.h \
    … …  
    5860                RpInt.h \
    5961                RpHashHelper.h \
     62                RpHistogram.h \
    6063                RpNumber.h \
     64                RpPath.h \
    6165                RpPlot.h \
    6266                RpPool.h \
     67                RpScatter.h \
    6368                RpString.h \
    64                 RpVariable.h
     69                RpTree.h \
     70                RpObject.h
    6571
    6672LOCAL_HEADERS = \
    … …  
    6975OBJS = \
    7076                RpArray1D.o \
     77                RpArray1DUniform.o \
     78                RpAxisMarker.o \
    7179                RpBoolean.o \
    7280                RpChain.o \
    … …  
    7684                RpHash.o \
    7785                RpHashHelper.o \
     86                RpHistogram.o \
    7887                RpNumber.o \
     88                RpPath.o \
    7989                RpPlot.o \
    8090                RpPool.o \
     91                RpScatter.o \
    8192                RpString.o \
     93                RpTree.o \
    8294                RpUtils2.o \
    83                 RpVariable.o
     95                RpObject.o
    8496
    8597

  • trunk/src/objects/RpAccessor.h

    r1386 r1528  
    7676        // raise error and exit
    7777    }
    78     strncpy(tmp,val,len);
    79     tmp[len] = '\0';
     78    strncpy(tmp,val,len+1);
    8079
    8180    if (_val) {

  • trunk/src/objects/RpArray1D.cc

    r1386 r1528  
    1717using namespace Rappture;
    1818
    19 const char Array1D::type[]        = "RAPPTURE_AXIS_TYPE_IRREGULAR";
    20 const char Array1DUniform::type[] = "RAPPTURE_AXIS_TYPE_UNIFORM";
    21 
    22 Array1D::Array1D (const char *path)
    23     : _val(SimpleDoubleBuffer()),
     19const char Array1D::type[] = "RAPPTURE_AXIS_TYPE_IRREGULAR";
     20
     21Array1D::Array1D()
     22    : Object(),
    2423      _min(std::numeric_limits<double>::max()),
    2524      _max(std::numeric_limits<double>::min())
    2625{
    27     this->path(path);
    28     this->label("");
    29     this->desc("");
    30     this->units("");
    31     this->scale("linear");
    32 }
    33 
    34 Array1D::Array1D (
    35             const char *path,
    36             double *val,
    37             size_t size
    38         )
    39     : _val(SimpleDoubleBuffer()),
     26    name("");
     27    label("");
     28    desc("");
     29    units("");
     30    scale("linear");
     31}
     32
     33Array1D::Array1D(const double *val, size_t size)
     34    : Object(),
    4035      _min(std::numeric_limits<double>::max()),
    4136      _max(std::numeric_limits<double>::min())
    4237{
    43     this->path(path);
    44     this->label("");
    45     this->desc("");
    46     this->units("");
    47     this->scale("linear");
     38    name("");
     39    label("");
     40    desc("");
     41    units("");
     42    scale("linear");
    4843    append(val,size);
    4944}
    5045
    51 Array1D::Array1D (
    52             const char *path,
    53             double *val,
    54             size_t size,
    55             const char *label,
    56             const char *desc,
    57             const char *units,
    58             const char *scale
    59         )
    60     : _val(SimpleDoubleBuffer()),
    61       _min(std::numeric_limits<double>::max()),
    62       _max(std::numeric_limits<double>::min())
    63 {
    64     this->path(path);
    65     this->label(label);
    66     this->desc(desc);
    67     this->units(units);
    68     this->scale(scale);
    69     append(val,size);
    70 }
    71 
    7246// copy constructor
    73 Array1D::Array1D ( const Array1D& o )
     47Array1D::Array1D(const Array1D& o)
    7448    : _val(o._val),
    7549      _min(o._min),
    7650      _max(o._max)
    7751{
    78     this->path(o.path());
    79     this->label(o.label());
    80     this->desc(o.desc());
    81     this->units(o.units());
    82     this->scale(o.scale());
     52    name(o.name());
     53    label(o.label());
     54    desc(o.desc());
     55    units(o.units());
     56    scale(o.scale());
    8357}
    8458
    … …  
    9771
    9872Array1D&
    99 Array1D::append(
    100     double *val,
    101     size_t nmemb)
     73Array1D::append(const double *val, size_t nmemb)
    10274{
    10375    double nmin = _min;
    … …  
    12294
    12395/**********************************************************************/
     96// METHOD: clear()
     97/// clear data values from the object
     98/**
     99 * Clear data values from the object
     100 */
     101
     102Array1D&
     103Array1D::clear()
     104{
     105    _val.clear();
     106    return *this;
     107}
     108
     109/**********************************************************************/
    124110// METHOD: read()
    125111/// Read values from the axis object into a memory location
    … …  
    129115
    130116size_t
    131 Array1D::read(
    132     double *val,
    133     size_t nmemb)
     117Array1D::read(double *val, size_t nmemb)
    134118{
    135119    return _val.read(val,nmemb);
    … …  
    188172}
    189173
     174/**********************************************************************/
     175// METHOD: xml()
     176/// Return the xml text representation of this object
     177/**
     178 * Return the xml text representation of this object
     179 */
     180
     181const char *
     182Array1D::xml()
     183{
     184    return "";
     185}
     186
     187/**********************************************************************/
     188// METHOD: xml()
     189/// Return the xml text representation of this object
     190/**
     191 * Return the xml text representation of this object
     192 */
     193
     194const int
     195Array1D::is() const
     196{
     197    // return "ar1d" in hex
     198    return 0x61723164;
     199}
     200
    190201// -------------------------------------------------------------------- //
    191202

  • trunk/src/objects/RpArray1D.h

    r1397 r1528  
    1414#include "RpAccessor.h"
    1515#include "RpSimpleBuffer.h"
     16#include "RpObject.h"
    1617
    1718namespace Rappture {
    1819
    19 class Array1D
     20class Array1D : public Object
    2021{
    2122public:
    22     Array1D (const char *path);
    23     Array1D (const char *path, double *val, size_t size);
    24     Array1D (const char *path,
    25              double *val,
    26              size_t size,
    27              const char *label,
    28              const char *desc,
    29              const char *units,
    30              const char *scale);
     23
     24    Array1D();
     25    Array1D (const double *val, size_t size);
    3126    Array1D (const Array1D &o);
    3227    virtual ~Array1D();
    3328
    34     Accessor<const char *> path;
    35     Accessor<const char *> label;
    36     Accessor<const char *> desc;
     29    Accessor<const char *> name;
    3730    Accessor<const char *> units;
    3831    Accessor<const char *> scale;
    3932
    40     virtual Array1D& append(double *val, size_t nmemb);
     33    virtual Array1D& append(const double *val, size_t nmemb);
     34    virtual Array1D& clear();
    4135    virtual size_t read(double *val, size_t nmemb);
    4236    virtual size_t nmemb() const;
    … …  
    4741    static const char type[];
    4842
    49 private:
     43    const char *xml(void);
     44    const int is(void) const;
     45
     46protected:
    5047
    5148    SimpleDoubleBuffer _val;
    … …  
    5451};
    5552
    56 class Array1DUniform
    57 {
    58 public:
    59     Array1DUniform  (const char *path);
    60     Array1DUniform  (const char *path, double begin, double end, size_t step);
    61     Array1DUniform  (const char *path,
    62                      double begin,
    63                      double end,
    64                      size_t step,
    65                      const char *label,
    66                      const char *desc,
    67                      const char *units,
    68                      const char *scale);
    69     Array1DUniform  (const Array1DUniform &o);
    70     virtual ~Array1DUniform ();
    71 
    72     Accessor<const char *> path;
    73     Accessor<const char *> label;
    74     Accessor<const char *> desc;
    75     Accessor<const char *> units;
    76     Accessor<const char *> scale;
    77     Accessor<double> begin;
    78     Accessor<double> end;
    79     Accessor<size_t> step;
    80 
    81     size_t read(double *val, size_t nmemb);
    82     const double *data() const;
    83     virtual size_t nmemb() const;
    84     static const char type[];
    85 
    86 private:
    87     SimpleDoubleBuffer _val;
    88 
    89 };
    9053} // namespace Rappture
    9154

  • trunk/src/objects/RpBoolean.cc

    r1386 r1528  
    2121            int val
    2222        )
    23     :   Variable    ()
     23    :   Object    ()
    2424{
    2525    this->path(path);
    … …  
    3434            const char *desc
    3535        )
    36     :   Variable    ()
     36    :   Object    ()
    3737{
    3838    this->path(path);
    … …  
    4545// copy constructor
    4646Boolean::Boolean ( const Boolean& o )
    47     :   Variable(o)
     47    :   Object(o)
    4848{
    4949    this->def(o.def());
    … …  
    5757}
    5858
     59/**********************************************************************/
     60// METHOD: xml()
     61/// view this object's xml
     62/**
     63 * View this object as an xml element returned as text.
     64 */
     65
     66const char *
     67Boolean::xml()
     68{
     69    Path p(path());
     70    _tmpBuf.clear();
     71
     72    // FIXME: boolean should print yes/no
     73
     74    _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());
     84
     85    return _tmpBuf.bytes();
     86}
     87
     88/**********************************************************************/
     89// METHOD: is()
     90/// what kind of object is this
     91/**
     92 * return hex value telling what kind of object this is.
     93 */
     94
     95const int
     96Boolean::is() const
     97{
     98    // return "bool" in hex
     99    return 0x626F6F6C;
     100}
     101
    59102// -------------------------------------------------------------------- //

  • trunk/src/objects/RpBoolean.h

    r1386 r1528  
    99 */
    1010
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212
    1313#ifndef RAPPTURE_BOOLEAN_H
    … …  
    1616namespace Rappture {
    1717
    18 class Boolean : public Variable
     18class Boolean : public Object
    1919{
    2020    public:
    … …  
    3434        Accessor<int> cur;
    3535
     36        const char *xml();
     37        const int is() const;
    3638};
    3739
    … …  
    3941
    4042/*--------------------------------------------------------------------------*/
    41 /*--------------------------------------------------------------------------*/
    4243
    4344#endif

  • trunk/src/objects/RpChainHelper.c

    r1386 r1528  
    110110
    111111    len = strlen((char*)from);
    112     *to = (void*) malloc(len*sizeof(char));
    113     strcpy((char*)(*to),(char*)from);
     112    *to = (void*) malloc(len*sizeof(char)+1);
     113    strncpy((char*)(*to),(char*)from,len+1);
    114114    return 0;
    115115}

  • trunk/src/objects/RpChainHelper.h

    r1386 r1528  
    2222                              int (*cpyFxn)(void **to,void *from));
    2323
     24int Rp_ChainCharCpyFxn (void **to, void *from);
     25int Rp_ChainCharCmpFxn (void *to, void *from);
     26
     27
    2428#ifdef __cplusplus
    2529}

  • trunk/src/objects/RpChoice.cc

    r1386 r1528  
    2020            const char *val
    2121        )
    22     :   Variable    (),
     22    :   Object    (),
    2323        _options    (NULL)
    2424{
    … …  
    3636            const char *desc
    3737        )
    38     :   Variable    (),
     38    :   Object    (),
    3939        _options    (NULL)
    4040{
    … …  
    4848// copy constructor
    4949Choice::Choice ( const Choice& o )
    50     :   Variable(o)
     50    :   Object(o)
    5151{
    5252    this->def(o.def());
    … …  
    142142}
    143143
     144/**********************************************************************/
     145// METHOD: xml()
     146/// view this object's xml
     147/**
     148 * View this object as an xml element returned as text.
     149 */
     150
     151const char *
     152Choice::xml()
     153{
     154    Path p(path());
     155    _tmpBuf.clear();
     156
     157    _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());
     164
     165    Rp_ChainLink *l = NULL;
     166    l = Rp_ChainFirstLink(_options);
     167    while (l != NULL) {
     168        option *op = (option *)Rp_ChainGetValue(l);
     169        _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());
     178        l = Rp_ChainNextLink(l);
     179    }
     180
     181    _tmpBuf.appendf(
     182"    <default>%s</default>\n\
     183    <current>%s</current>\n\
     184</choice>",
     185       def(),cur());
     186
     187    return _tmpBuf.bytes();
     188}
     189
     190/**********************************************************************/
     191// METHOD: is()
     192/// what kind of object is this
     193/**
     194 * return hex value telling what kind of object this is.
     195 */
     196
     197const int
     198Choice::is() const
     199{
     200    // return "choi" in hex
     201    return 0x63686F69;
     202}
     203
    144204// -------------------------------------------------------------------- //
    145205

  • trunk/src/objects/RpChoice.h

    r1386 r1528  
    99 */
    1010#include <errno.h>
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212#include "RpChain.h"
    1313
    … …  
    1717namespace Rappture {
    1818
    19 class Choice : public Variable
     19class Choice : public Object
    2020{
    2121    public:
    … …  
    4141        Choice& delOption ( const char *label);
    4242
     43        const char *xml();
     44        const int is() const;
     45
    4346    private:
    4447
    … …  
    4649        Rp_Chain *_options;
    4750
    48         struct option{
     51        typedef struct {
    4952            Accessor<const char *> label;
    5053            Accessor<const char *> desc;
    5154            Accessor<const char *> val;
    52         };
     55        } option;
    5356};
    5457

  • trunk/src/objects/RpCurve.cc

    r1386 r1528  
    1616using namespace Rappture;
    1717
     18/*
     19const char Curve::format[]  = "RAPPTURE::CURVE::FORMAT";
     20const char Curve::id[]      = "RAPPTURE::CURVE::ID";
     21const char Curve::creator[] = "RAPPTURE::CURVE::CREATOR";
     22*/
     23const char Curve::x[]   = "xaxis";
     24const char Curve::y[]   = "yaxis";
     25
     26Curve::Curve ()
     27    : Object (),
     28      _axisList (NULL)
     29{
     30    this->path("");
     31    this->label("");
     32    this->desc("");
     33    this->group("");
     34}
     35
    1836Curve::Curve (const char *path)
    19     :   Variable    (),
    20         _axisList    (NULL)
     37    : Object (),
     38      _axisList (NULL)
    2139{
    2240    this->path(path);
    … …  
    2644}
    2745
    28 Curve::Curve (
    29             const char *path,
    30             const char *label,
    31             const char *desc,
    32             const char *group
    33         )
    34     :   Variable    (),
    35         _axisList    (NULL)
     46Curve::Curve (const char *path, const char *label, const char *desc,
     47              const char *group)
     48    : Object (),
     49      _axisList (NULL)
    3650{
    3751    this->path(path);
    … …  
    4357// copy constructor
    4458Curve::Curve ( const Curve& o )
    45     :   Variable(o)
     59    :   Object(o)
    4660{
    4761    this->path(o.path());
    … …  
    6983 */
    7084
    71 Curve&
     85Array1D *
    7286Curve::axis(
     87    const char *name,
    7388    const char *label,
    7489    const char *desc,
    7590    const char *units,
    7691    const char *scale,
    77     double *val,
     92    const double *val,
    7893    size_t size)
    7994{
    8095    Array1D *a = NULL;
    81     SimpleCharBuffer apath(path());
    82 
    83     apath.append(".");
    84     apath.append(label);
    85 
    86     a = new Array1D(apath.bytes(),val,size,label,desc,units,scale);
    87     if (!a) {
     96
     97    a = new Array1D(val,size);
     98    if (a == NULL) {
    8899        // raise error and exit
    89     }
     100        return NULL;
     101    }
     102    a->name(name);
     103    a->label(label);
     104    a->desc(desc);
     105    a->units(units);
     106    a->scale(scale);
    90107
    91108    if (_axisList == NULL) {
    … …  
    93110        if (_axisList == NULL) {
    94111            // raise error and exit
     112            delete a;
     113            return NULL;
    95114        }
    96115    }
    … …  
    98117    Rp_ChainAppend(_axisList,a);
    99118
    100     return *this;
    101 }
    102 
    103 /*
    104 Curve&
    105 Curve::addAxis(
    106     const char *path)
    107 {
    108     return *this;
    109 }
    110 */
     119    return a;
     120}
    111121
    112122/**********************************************************************/
    … …  
    118128
    119129Curve&
    120 Curve::delAxis(const char *label)
     130Curve::delAxis(const char *name)
    121131{
    122132    Array1D *a = NULL;
    123133    Rp_ChainLink *l = NULL;
    124     l = __searchAxisList(label);
    125 
    126     if (l == NULL) {
    127         return *this;
    128     }
    129 
    130     a = (Array1D *) Rp_ChainGetValue(l);
    131     delete a;
    132     Rp_ChainDeleteLink(_axisList,l);
     134    l = __searchAxisList(name);
     135
     136    if (l != NULL) {
     137        a = (Array1D *) Rp_ChainGetValue(l);
     138        delete a;
     139        Rp_ChainDeleteLink(_axisList,l);
     140    }
    133141
    134142    return *this;
    … …  
    153161
    154162    size_t ret = 0;
    155     Rappture::Array1D *a = getAxis(label);
     163    Array1D *a = getAxis(label);
    156164    if (a != NULL) {
    157165        *arr = a->data();
    … …  
    169177
    170178Array1D *
    171 Curve::getAxis(const char *label) const
     179Curve::getAxis(const char *name) const
    172180{
    173181    Rp_ChainLink *l = NULL;
    174     l = __searchAxisList(label);
     182    l = __searchAxisList(name);
    175183
    176184    if (l == NULL) {
    … …  
    182190
    183191Rp_ChainLink *
    184 Curve::__searchAxisList(const char *label) const
    185 {
    186     if (label == NULL) {
     192Curve::__searchAxisList(const char *name) const
     193{
     194    if (name == NULL) {
    187195        return NULL;
    188196    }
    … …  
    193201
    194202    Rp_ChainLink *l = NULL;
    195     Rp_ChainLink *retval = NULL;
     203    Path p;
    196204
    197205    // traverse the list looking for the match
    … …  
    199207    while (l != NULL) {
    200208        Array1D *a = (Array1D *) Rp_ChainGetValue(l);
    201         const char *alabel = a->label();
    202         if ((*label == *alabel) && (strcmp(alabel,label) == 0)) {
     209        const char *aname = a->name();
     210        if ((*name == *aname) && (strcmp(name,aname) == 0)) {
    203211            // we found matching entry, return it
    204             retval = l;
    205212            break;
    206213        }
    … …  
    208215    }
    209216
    210     return retval;
     217    return l;
    211218}
    212219
    … …  
    244251}
    245252
     253/**********************************************************************/
     254// METHOD: xml()
     255/// Return the xml of the object
     256/**
     257 * Return the xml of the object
     258 */
     259
     260const char *
     261Curve::xml()
     262{
     263    Path p(path());
     264
     265    Array1D *tmpAxis = NULL;
     266    size_t nmemb = 0;
     267
     268    const double *dataArr[dims()];
     269
     270    _tmpBuf.clear();
     271
     272    _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());
     279
     280    for (size_t dim=0; dim < dims(); dim++) {
     281        tmpAxis = getNthAxis(dim);
     282        nmemb = tmpAxis->nmemb();
     283        dataArr[dim] = tmpAxis->data();
     284        _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",
     291        tmpAxis->name(), tmpAxis->label(), tmpAxis->desc(),
     292        tmpAxis->units(), tmpAxis->scale(), tmpAxis->name());
     293    }
     294
     295    _tmpBuf.append("    <component>\n        <xy>\n");
     296    for (size_t idx=0; idx < nmemb; idx++) {
     297        for(size_t dim=0; dim < dims(); dim++) {
     298            _tmpBuf.appendf("%10g",dataArr[dim][idx]);
     299        }
     300        _tmpBuf.append("\n",1);
     301    }
     302    _tmpBuf.append("        </xy>\n    </component>\n</curve>");
     303    _tmpBuf.append("\0",1);
     304
     305    return _tmpBuf.bytes();
     306}
     307
     308/**********************************************************************/
     309// METHOD: is()
     310/// what kind of object is this
     311/**
     312 * return hex value telling what kind of object this is.
     313 */
     314
     315const int
     316Curve::is() const
     317{
     318    // return "curv" in hex
     319    return 0x63757276;
     320}
     321
     322
    246323// -------------------------------------------------------------------- //
    247324

  • trunk/src/objects/RpCurve.h

    r1386 r1528  
    99 */
    1010#include <errno.h>
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212#include "RpChain.h"
    1313#include "RpArray1D.h"
    … …  
    1818namespace Rappture {
    1919
    20 class Curve : public Variable
     20class Curve : public Object
    2121{
    2222    public:
    2323
    24         Curve  (const char *path);
     24        Curve();
    2525
    26         Curve  (const char *path,
    27                 const char *label,
    28                 const char *desc,
    29                 const char *group);
     26        Curve(const char *path);
    3027
    31         Curve  (const Curve& o);
     28        Curve(const char *path, const char *label, const char *desc,
     29              const char *group);
    3230
    33         virtual ~Curve  ();
     31        Curve(const Curve& o);
    3432
    35         Curve& axis (const char *label,
    36                      const char *desc,
    37                      const char *units,
    38                      const char *scale,
    39                      double *val,
    40                      size_t size);
     33        virtual ~Curve();
    4134
    42         Curve& delAxis (const char *label);
     35        Array1D *axis(const char *name, const char *label, const char *desc,
     36                      const char *units, const char *scale, const double *val,
     37                      size_t size);
    4338
    44         size_t data (const char *label,
    45                      const double **arr) const;
     39        Curve& delAxis(const char *name);
    4640
    47         Array1D *getAxis    ( const char *label) const;
    48         Array1D *getNthAxis ( size_t n) const;
     41        size_t data(const char *label, const double **arr) const;
    4942
    50         /*
    51         Array1D *firstAxis ();
    52         Array1D *lastAxis  ();
    53         Array1D *nextAxis  (   const char *prevLabel);
    54         Array1D *prevAxis  (   const char *prevLabel);
    55         */
     43        Array1D *getAxis(const char *name) const;
     44        Array1D *getNthAxis(size_t n) const;
    5645
     46        // should be a list of groups to add this curve to?
    5747        Accessor <const char *> group;
    5848        size_t dims() const;
    5949
     50        const char *xml();
     51        const int is() const;
     52
     53        static const char x[];
     54        static const char y[];
     55
    6056    private:
    6157
    62         // hash or linked list of preset values
     58        // hash or linked list of axis
    6359        Rp_Chain *_axisList;
    6460
    65         Rp_ChainLink *__searchAxisList(const char * label) const;
     61        Rp_ChainLink *__searchAxisList(const char * name) const;
    6662};
     63
    6764
    6865} // namespace Rappture
    6966
    7067/*--------------------------------------------------------------------------*/
    71 /*--------------------------------------------------------------------------*/
    7268
    7369#endif // RAPPTURE_CURVE_H

  • trunk/src/objects/RpNumber.cc

    r1386 r1528  
    1414#include "RpNumber.h"
    1515#include "RpUnits.h"
     16#include "RpSimpleBuffer.h"
    1617
    1718using namespace Rappture;
    1819
    19 Number::Number (
    20             const char *path,
    21             const char *units,
    22             double val
    23         )
    24     :   Variable    (),
    25         _minmaxSet  (0),
    26         _presets    (NULL)
     20Number::Number()
     21   : Object (),
     22     _minSet (0),
     23     _maxSet (0),
     24     _presets (NULL)
     25{
     26    this->path("");
     27    this->label("");
     28    this->desc("");
     29    this->def(0.0);
     30    this->cur(0.0);
     31    this->min(0.0);
     32    this->max(0.0);
     33    // need to set this to the None unit
     34    // this->units(units);
     35}
     36
     37Number::Number(const char *path, const char *units, double val)
     38   : Object (),
     39     _minSet (0),
     40     _maxSet (0),
     41     _presets (NULL)
    2742{
    2843    const RpUnits *u = NULL;
    … …  
    4358}
    4459
    45 Number::Number (
    46             const char *path,
    47             const char *units,
    48             double val,
    49             double min,
    50             double max,
    51             const char *label,
    52             const char *desc
    53         )
    54     :   Variable    (),
    55         _minmaxSet  (0),
    56         _presets    (NULL)
     60Number::Number(const char *path, const char *units, double val,
     61               double min, double max, const char *label,
     62               const char *desc)
     63    : Object (),
     64      _minSet (0),
     65      _maxSet (0),
     66      _presets (NULL)
    5767{
    5868    const RpUnits *u = NULL;
    … …  
    7383
    7484    if ((min == 0) && (max == 0)) {
    75         _minmaxSet = 0;
     85        _minSet = 0;
     86        _maxSet = 0;
    7687    }
    7788    else {
    7889
     90        _minSet = 1;
    7991        if (min > val) {
    8092            this->min(val);
    8193        }
    8294
     95        _maxSet = 1;
    8396        if (max < val) {
    8497            this->max(val);
    … …  
    89102// copy constructor
    90103Number::Number ( const Number& o )
    91     :   Variable(o),
    92         _minmaxSet  (o._minmaxSet)
     104    : Object (o),
     105      _minSet (o._minSet),
     106      _maxSet (o._maxSet)
    93107{
    94108    this->def(o.def());
    … …  
    105119{
    106120    // clean up dynamic memory
    107 
     121}
     122
     123const char *
     124Number::units(void) const
     125{
     126    return propstr("units");
     127}
     128
     129void
     130Number::units(const char *p)
     131{
     132    propstr("units",p);
    108133}
    109134
    … …  
    115140 */
    116141
    117 double
    118 Number::convert(const char *to) {
    119 
     142int
     143Number::convert(const char *to)
     144{
    120145    const RpUnits* toUnit = NULL;
    121146    const RpUnits* fromUnit = NULL;
    … …  
    149174    }
    150175
    151     if (err) {
    152         convertedVal = cur();
    153     }
    154 
    155     return convertedVal;
     176    return err;
     177}
     178
     179/**********************************************************************/
     180// METHOD: value()
     181/// Get the value of this object converted to specified units
     182/**
     183 * does not change the value of the object
     184 * error code is returned
     185 */
     186
     187int
     188Number::value(const char *to, double *value) const
     189{
     190    return 1;
    156191}
    157192
    … …  
    165200
    166201Number&
    167 Number::addPreset(
    168     const char *label,
    169     const char *desc,
    170     double val,
    171     const char *units)
     202Number::addPreset(const char *label, const char *desc, double val,
     203                  const char *units)
    172204{
    173205    preset *p = NULL;
    … …  
    236268}
    237269
     270/**********************************************************************/
     271// METHOD: xml()
     272/// view this object's xml
     273/**
     274 * View this object as an xml element returned as text.
     275 */
     276
     277const char *
     278Number::xml()
     279{
     280    Path p(path());
     281    _tmpBuf.clear();
     282
     283    _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());
     291
     292    if (_minSet) {
     293        _tmpBuf.appendf("    <min>%g%s</min>\n", min(),units());
     294    }
     295    if (_maxSet) {
     296        _tmpBuf.appendf("    <max>%g%s</max>\n", max(),units());
     297    }
     298
     299    _tmpBuf.appendf(
     300"    <default>%g%s</default>\n\
     301    <current>%g%s</current>\n\
     302</number>",
     303       def(),units(),cur(),units());
     304
     305    return _tmpBuf.bytes();
     306}
     307
     308/**********************************************************************/
     309// METHOD: is()
     310/// what kind of object is this
     311/**
     312 * return hex value telling what kind of object this is.
     313 */
     314
     315const int
     316Number::is() const
     317{
     318    // return "numb" in hex
     319    return 0x6E756D62;
     320}
     321
     322
    238323// -------------------------------------------------------------------- //
    239324

  • trunk/src/objects/RpNumber.h

    r1386 r1528  
    99 */
    1010#include <errno.h>
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212#include "RpChain.h"
    1313
    … …  
    1717namespace Rappture {
    1818
    19 class Number : public Variable
     19class Number : public Object
    2020{
    2121    public:
    2222
    23         Number  (  const char *path,
    24                     const char *units,
    25                     double val);
     23        Number();
     24        Number(const char *path, const char *units, double val);
    2625
    27         Number  (  const char *path,
    28                     const char *units,
    29                     double val,
    30                     double min,
    31                     double max,
    32                     const char *label,
    33                     const char *desc);
     26        Number(const char *path, const char *units, double val,
     27               double min, double max, const char *label,
     28               const char *desc);
    3429
    35         Number  ( const Number& o );
     30        Number( const Number& o );
    3631        virtual ~Number ();
    3732
    … …  
    4035        Accessor<double> min;
    4136        Accessor<double> max;
    42         Accessor<const char *> units;
    4337
    44         // need to add a way to tell user conversion failed
    45         virtual double convert (const char *to);
     38        const char *units(void) const;
     39        void units(const char *p);
    4640
    47         Number& addPreset(  const char *label,
    48                             const char *desc,
    49                             double val,
    50                             const char *units   );
     41        // convert the value stored in this object to specified units
     42        // does not return the converted value
     43        // error code is returned
     44        int convert(const char *to);
     45
     46        // get the value of this object converted to specified units
     47        // does not change the value of the object
     48        // error code is returned
     49        int value(const char *units, double *value) const;
     50
     51        Number& addPreset(const char *label, const char *desc,
     52                          double val, const char *units);
    5153
    5254        Number& delPreset(const char *label);
     55
     56        const char* xml();
     57        const int is() const;
    5358
    5459    private:
    5560
    5661        // flag tells if user specified min and max values
    57         int _minmaxSet;
     62        int _minSet;
     63        int _maxSet;
    5864
    5965        // hash or linked list of preset values
    … …  
    6369            Accessor<const char *> label;
    6470            Accessor<const char *> desc;
     71            Accessor<const char *> units;
    6572            Accessor<double> val;
    66             Accessor<const char *> units;
    6773        };
     74
    6875};
    6976

  • trunk/src/objects/RpObject.cc

    r1428 r1528  
    11/*
    22 * ----------------------------------------------------------------------
    3  *  RpVariable.cc
     3 *  RpObject.cc
    44 *
    5  *   Rappture 2.0 Variable member functions
     5 *   Rappture 2.0 Object member functions
    66 *
    77 * ======================================================================
    … …  
    1414 */
    1515
    16 #include "RpVariable.h"
     16#include "RpObject.h"
    1717#include "RpHashHelper.h"
    1818
    1919using namespace Rappture;
    2020
    21 Variable::Variable()
     21Object::Object()
    2222{
    2323    __init();
    2424}
    2525
    26 Variable::Variable (
     26Object::Object (
    2727    const char *path,
    2828    const char *label,
    … …  
    3838}
    3939
    40 Variable::Variable(const Variable& o)
     40Object::Object(const Object& o)
    4141{
    4242    path(o.path());
    … …  
    4545    hints(o.hints());
    4646    color(o.color());
    47     icon(o.icon());
     47    // icon(o.icon());
    4848
    4949    if (o._h != NULL) {
    … …  
    5252}
    5353
    54 Variable::~Variable()
     54Object::~Object()
    5555{
    5656    __clear();
    5757}
    5858
     59const char*
     60Object::path() const
     61{
     62    return propstr("path");
     63}
     64
     65void
     66Object::path(const char *p)
     67{
     68    propstr("path",p);
     69}
     70
     71const char*
     72Object::label() const
     73{
     74    return propstr("label");
     75}
     76
     77void
     78Object::label(
     79    const char *p)
     80{
     81    propstr("label",p);
     82}
     83
     84const char*
     85Object::desc() const
     86{
     87    return propstr("desc");
     88}
     89
     90void
     91Object::desc(const char *p)
     92{
     93    propstr("desc",p);
     94}
     95
     96const char*
     97Object::hints() const
     98{
     99    return propstr("hints");
     100}
     101
     102void
     103Object::hints(const char *p)
     104{
     105    propstr("hints",p);
     106}
     107
     108const char*
     109Object::color() const
     110{
     111    return propstr("color");
     112}
     113
     114void
     115Object::color(const char *p)
     116{
     117    propstr("color",p);
     118}
     119
     120// get a general property
    59121const void *
    60 Variable::property(
    61     const char *key,
    62     const void *val)
    63 {
    64     const void *r = NULL;
     122Object::property(const char *key) const
     123{
     124    if (key == NULL) {
     125        // no key to search for
     126        return NULL;
     127    }
     128
     129    if (_h == NULL) {
     130        // hash table does not exist, value is not in table
     131        return NULL;
     132    }
     133
     134    // get the value
     135    return Rp_HashSearchNode(_h,key);
     136}
     137
     138// set a general property
     139void
     140Object::property(const char *key, const void *val, size_t nbytes)
     141{
     142    if (key == NULL) {
     143        // no key for value
     144        return;
     145    }
     146
    65147    if (_h == NULL) {
    66148        // hash table does not exist, create it
    … …  
    69151    }
    70152
    71     if (val == NULL) {
    72         // get the value
    73         r = Rp_HashSearchNode(_h,key);
    74     } else {
    75         // set the value
    76         Rp_HashRemoveNode(_h,key);
    77         Rp_HashAddNode(_h,key,val);
    78         r = val;
    79     }
    80 
    81     return r;
    82 }
    83 
     153    // FIXME: this is suspect,
     154    // want to use void's and void*'s but c++ wont let me
     155    // g++ says there is no delete[] for void*
     156    void *tmp = new char[nbytes];
     157    memcpy(tmp,val,nbytes);
     158
     159    // set the value
     160    char *old = (char *) Rp_HashRemoveNode(_h,key);
     161    delete[] old;
     162    old = NULL;
     163    Rp_HashAddNode(_h,key,tmp);
     164
     165    return;
     166}
     167
     168// get a const char* property
    84169const char *
    85 Variable::propstr(
    86     const char *key,
    87     const char *val)
    88 {
    89     const char *r = NULL;
     170Object::propstr(const char *key) const
     171{
     172    if (key == NULL) {
     173        // no key for value
     174        return NULL;
     175    }
     176
     177    if (_h == NULL) {
     178        // hash table does not exist, value does not exist in table
     179        return NULL;
     180    }
     181
     182    // get the value
     183    return (const char *) Rp_HashSearchNode(_h,key);
     184}
     185
     186// set a const char* property
     187void
     188Object::propstr(const char *key, const char *val)
     189{
    90190    char *str = NULL;
     191
     192    if (key == NULL) {
     193        // no key for value
     194        return;
     195    }
     196
    91197    if (_h == NULL) {
    92198        // hash table does not exist, create it
    … …  
    95201    }
    96202
    97     if (val == NULL) {
    98         // get the value
    99         r = (const char *) Rp_HashSearchNode(_h,key);
    100     } else {
    101         // set the value
    102         //FIXME: users responsibility to free value with propremove()
    103         size_t l = strlen(val);
    104         str = new char[l+1];
    105         strcpy(str,val);
    106 
    107         // FIXME: possible memory leak here
    108         // we dont free the removed item,
    109         // it is user's responsibility to use propremove() to free it
    110         // we don't know whether to use delete or delete[].
    111         Rp_HashRemoveNode(_h,key);
    112         Rp_HashAddNode(_h,key,str);
    113         r = val;
    114     }
    115 
    116     return r;
    117 }
    118 
    119 void *
    120 Variable::propremove(
    121     const char *key)
     203    // set the value
     204    // FIXME: this is suspect,
     205    // want to use void's and void*'s but c++ wont let me
     206    // g++ says there is no delete[] for void*
     207    size_t l = strlen(val);
     208    str = new char[l+1];
     209    strcpy(str,val);
     210
     211    char *old = (char *) Rp_HashRemoveNode(_h,key);
     212    delete[] old;
     213    old = NULL;
     214    Rp_HashAddNode(_h,key,str);
     215
     216    return;
     217}
     218
     219// remove a property from the hash table
     220void
     221Object::propremove(const char *key)
    122222{
    123223    if ((key == NULL) || (_h == NULL)) {
    124224        // key or hash table does not exist
    125         return NULL;
    126     }
    127 
    128     return Rp_HashRemoveNode(_h,key);
    129 }
    130 
    131 void
    132 Variable::__init()
     225        return;
     226    }
     227
     228    char *tmp = (char *) Rp_HashRemoveNode(_h,key);
     229    delete[] tmp;
     230    tmp = NULL;
     231    return;
     232}
     233
     234void
     235Object::__init()
    133236{
    134237    _h = NULL;
    … …  
    139242    // icon(NULL);
    140243    path("");
    141 }
    142 
    143 void
    144 Variable::__clear()
    145 {
    146     // who frees the Accessors?
    147 
     244
     245    _tmpBuf.clear();
     246
     247    _h = (Rp_HashTable*) malloc(sizeof(Rp_HashTable));
     248    Rp_InitHashTable(_h,RP_STRING_KEYS);
     249}
     250
     251void
     252Object::__clear()
     253{
     254    _tmpBuf.clear();
     255
     256    // traverse the hash table to delete values, then delete hash table
    148257    if (_h != NULL) {
     258        Rp_HashEntry *hEntry = NULL;
     259        Rp_HashSearch hSearch;
     260
     261        hEntry = Rp_FirstHashEntry(_h,&hSearch);
     262        while (hEntry != NULL) {
     263            // FIXME: this is suspect,
     264            // want to use void's and void*'s but c++ wont let me
     265            // g++ says there is no delete[] for void*
     266            char *v = (char *) Rp_GetHashValue(hEntry);
     267            delete[] v;
     268            v = NULL;
     269            hEntry = Rp_NextHashEntry(&hSearch);
     270        }
     271
    149272        Rp_DeleteHashTable(_h);
    150     }
    151 
    152     __init();
    153 }
    154 
     273        _h = NULL;
     274    }
     275}
     276
     277const char *
     278Object::xml() const
     279{
     280    return NULL;
     281}
     282
     283void
     284Object::xml(const char *xmltext)
     285{
     286    return;
     287}
     288
     289const int
     290Object::is() const
     291{
     292    // return "var" in hex
     293    return 0x766172;
     294}
    155295
    156296// -------------------------------------------------------------------- //

  • trunk/src/objects/RpObject.h

    r1428 r1528  
    99 */
    1010
    11 #ifndef RAPPTURE_VARIABLE_H
    12 #define RAPPTURE_VARIABLE_H
     11#ifndef RAPPTURE_OBJECT_H
     12#define RAPPTURE_OBJECT_H
    1313
    1414#include "RpInt.h"
    … …  
    1616#include "RpAccessor.h"
    1717#include "RpBuffer.h"
     18#include "RpPath.h"
    1819
    1920namespace Rappture {
    2021
    21 class Variable
     22class Object
    2223{
    2324    public:
    24         Variable ();
    25         Variable (  const char *path,
    26                     const char *label,
    27                     const char *desc,
    28                     const char *hints,
    29                     const char *color   );
    30         Variable (const Variable& o);
    31         virtual ~Variable();
     25        Object ();
     26        Object (const char *path,
     27                const char *label,
     28                const char *desc,
     29                const char *hints,
     30                const char *color);
     31        Object (const Object& o);
     32        virtual ~Object();
    3233
    33         Accessor<const char *> path;
    34         Accessor<const char *> label;
    35         Accessor<const char *> desc;
    36         Accessor<const char *> hints;
    37         Accessor<const char *> color;
    38         Accessor<Buffer> icon;
     34        const char *path(void) const;
     35        void path(const char *p);
     36
     37        const char *label(void) const;
     38        void label(const char *p);
     39
     40        const char *desc(void) const;
     41        void desc(const char *p);
     42
     43        const char *hints(void) const;
     44        void hints(const char *p);
     45
     46        const char *color(void) const;
     47        void color(const char *);
     48
     49        // void *icon(void) const;
     50        // void icon(void *p, size_t nbytes);
    3951
    4052        // these functions are not completely improper use proof
    4153        // user is responsible for calling propremove() on any item
    4254        // they put into the hash table.
    43         const void *property (const char *key, const void *val);
    44         const char *propstr (const char *key, const char *val);
    45         void *propremove (const char *key);
     55
     56        // get/set void* property
     57        const void *property (const char *key) const;
     58        void property (const char *key, const void *val, size_t nbytes);
     59
     60        // get/set const char * property
     61        const char *propstr (const char *key) const;
     62        void propstr (const char *key, const char *val);
     63
     64        // remove property from hash table
     65        void propremove (const char *key);
     66
     67        // get the Rappture1.1 xml text for this object
     68        virtual const char *xml() const;
     69
     70        // set the object properties based on Rappture1.1 xml text
     71        virtual void xml(const char *xmltext);
     72
     73        virtual const int is() const;
     74
     75    protected:
     76
     77        /// temprorary buffer for returning text to the user
     78        SimpleCharBuffer _tmpBuf;
    4679
    4780    private:
    … …  
    5588        /// close out the object, freeing its memory
    5689        void __clear();
     90
    5791};
    5892
    59 } // RAPPTURE_VARIABLE_H
     93} // RAPPTURE_OBJECT_H
    6094
    6195/*--------------------------------------------------------------------------*/

  • trunk/src/objects/RpPlot.cc

    r1386 r1528  
    1616using namespace Rappture;
    1717
    18 const char Plot::format[] = "RAPPTURE::PLOT::FORMAT";
    19 const char Plot::id[]     = "RAPPTURE::PLOT::ID";
    20 const char Plot::xaxis[]  = "RAPPTURE::PLOT::XAXIS";
    21 const char Plot::yaxis[]  = "RAPPTURE::PLOT::YAXIS";
     18const char Plot::format[]  = "RAPPTURE::PLOT::FORMAT";
     19const char Plot::id[]      = "RAPPTURE::PLOT::ID";
     20const char Plot::xaxis[]   = "xaxis";
     21const char Plot::yaxis[]   = "yaxis";
     22const char Plot::creator[] = "RAPPTURE::PLOT::CREATOR";
     23
     24/*
     25const char *Plot::creator[] = {
     26    "plot",
     27    "user"
     28};
     29*/
    2230
    2331Plot::Plot ()
    24     :   Variable    (),
     32    :   Object    (),
    2533        _curveList  (NULL)
    2634{
    … …  
    3341// copy constructor
    3442Plot::Plot ( const Plot& o )
    35     :   Variable(o)
     43    :   Object(o)
    3644{
    3745    _curveList = Rp_ChainCreate();
    … …  
    4856    Rp_ChainLink *l = Rp_ChainFirstLink(_curveList);
    4957    while (l != NULL) {
    50         char *str = NULL;
    5158        Curve * c = (Curve *) Rp_ChainGetValue(l);
    52 
    53         str = (char *) c->propremove(Plot::format);
    54         delete str;
    55 
    56         str = (char *) c->propremove(Plot::id);
    57         delete str;
    58 
     59        c->propremove(Plot::format);
     60        c->propremove(Plot::id);
    5961        delete c;
    6062        c = NULL;
    … …  
    8991    }
    9092
     93    Path cpath;
     94    cpath.id(name);
     95    c->path(cpath.path());
     96
    9197    // can't use "xaxis" kinda strings here have to allocate it forreal
    92     c->axis(xaxis,"xdesc","xunits","xcale",x,nPts);
    93     c->axis(yaxis,"ydesc","yunits","ycale",y,nPts);
    94     c->propstr(format,fmt);
    95     c->propstr(id,name);
     98    c->axis(Plot::xaxis,"","","","",x,nPts);
     99    c->axis(Plot::yaxis,"","","","",y,nPts);
     100    c->propstr(Plot::format,fmt);
     101    c->propstr(Plot::creator,"plot");
    96102
    97103    if (_curveList == NULL) {
    … …  
    109115
    110116/**********************************************************************/
     117// METHOD: add()
     118/// Add an xy curve to the object
     119/**
     120 * Add an xy curve to the object.
     121 * returns curve id
     122 */
     123
     124Plot&
     125Plot::add(
     126    Curve *c,
     127    const char *name)
     128{
     129    if (c == NULL) {
     130       // raise memory error and exit
     131       return *this;
     132    }
     133
     134    c->propstr(Plot::id,name);
     135
     136    if (_curveList == NULL) {
     137        _curveList = Rp_ChainCreate();
     138        if (_curveList == NULL) {
     139            // raise error and exit
     140        }
     141    }
     142
     143    Rp_ChainAppend(_curveList,c);
     144
     145    return *this;
     146}
     147
     148
     149/**********************************************************************/
    111150// METHOD: count()
    112151/// return number of curves in this object
    … …  
    143182    }
    144183    return c;
     184}
     185
     186/**********************************************************************/
     187// METHOD: getNthCurve()
     188/// Return the Nth Curve object
     189/**
     190 * Return the Nth Curve
     191 */
     192
     193Curve *
     194Plot::getNthCurve(size_t n) const
     195{
     196    Rp_ChainLink *l = NULL;
     197    l = Rp_ChainGetNthLink(_curveList,n);
     198
     199    if (l == NULL) {
     200        return NULL;
     201    }
     202
     203    return (Curve *) Rp_ChainGetValue(l);
    145204}
    146205
    … …  
    163222    while (l != NULL) {
    164223        Curve *c = (Curve *) Rp_ChainGetValue(l);
    165         const char *cname = (const char *) c->property(id,NULL);
     224        const char *cname = c->propstr(Plot::id);
    166225        if (cname != NULL) {
    167226            if((*cname == *name) && (strcmp(cname,name) == 0)) {
    … …  
    191250}
    192251
     252/**********************************************************************/
     253// METHOD: xml()
     254/// Return the xml of this object
     255/**
     256 * returns the xml of this object
     257 */
     258
     259const char *
     260Plot::xml()
     261{
     262
     263    Rp_ChainLink *l = NULL;
     264
     265    _tmpBuf.clear();
     266
     267    l = Rp_ChainFirstLink(_curveList);
     268    while (l != NULL) {
     269        Curve *c = (Curve *) Rp_ChainGetValue(l);
     270
     271        //find who created the curve
     272        const char *ccreator = c->propstr(Plot::creator);
     273        if ((ccreator != NULL) &&
     274            (*ccreator == 'p') &&
     275            (strcmp(ccreator,"plot") == 0)) {
     276            // FIXME: check fields to see if the user specified value
     277            // plot defined curve, use plot's labels in curve's xml
     278            const char *xlabel = propstr("xlabel");
     279            const char *xdesc  = propstr("xdesc");
     280            const char *xunits = propstr("xunits");
     281            const char *xscale = propstr("xscale");
     282            const char *ylabel = propstr("ylabel");
     283            const char *ydesc  = propstr("ydesc");
     284            const char *yunits = propstr("yunits");
     285            const char *yscale = propstr("yscale");
     286
     287            if (xlabel || xdesc || xunits || xscale) {
     288                Array1D *cxaxis = c->getAxis(Plot::xaxis);
     289                cxaxis->label(xlabel);
     290                cxaxis->desc(xdesc);
     291                cxaxis->units(xunits);
     292                cxaxis->scale(xscale);
     293            }
     294
     295            if (ylabel || ydesc || yunits || yscale) {
     296                Array1D *cyaxis = c->getAxis(Plot::yaxis);
     297                cyaxis->label(ylabel);
     298                cyaxis->desc(ydesc);
     299                cyaxis->units(yunits);
     300                cyaxis->scale(yscale);
     301            }
     302        }
     303
     304        _tmpBuf.append(c->xml());
     305        _tmpBuf.append("\n",1);
     306        l = Rp_ChainNextLink(l);
     307    }
     308
     309    // remove trailing newline
     310    _tmpBuf.remove(1);
     311    // append terminating null character
     312    _tmpBuf.append("\0",1);
     313
     314    return _tmpBuf.bytes();
     315}
     316
     317/**********************************************************************/
     318// METHOD: is()
     319/// what kind of object is this
     320/**
     321 * return hex value telling what kind of object this is.
     322 */
     323
     324const int
     325Plot::is() const
     326{
     327    // return "plot" in hex
     328    return 0x706C6F74;
     329}
     330
    193331// -------------------------------------------------------------------- //

  • trunk/src/objects/RpPlot.h

    r1386 r1528  
    99 */
    1010#include <errno.h>
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212#include "RpChainHelper.h"
    1313#include "RpCurve.h"
    … …  
    1818namespace Rappture {
    1919
    20 class Plot : public Variable
     20class Plot : public Object
    2121{
    2222    public:
    … …  
    3333                    const char *name);
    3434
     35        Plot& add (Curve *c, const char *name);
     36
    3537        // count the number of curves in the object
    3638        size_t count() const;
    … …  
    3840        // retrieve a curve from the object
    3941        Curve *curve (const char* name) const;
     42        Curve *getNthCurve(size_t n) const;
     43
     44        const char *xml();
     45        const int is() const;
     46
     47    private:
     48
     49        // hash or linked list of preset values
     50        Rp_Chain *_curveList;
    4051
    4152        static const char format[];
    … …  
    4354        static const char xaxis[];
    4455        static const char yaxis[];
     56        static const char creator[];
    4557
    46     private:
    47 
    48         // hash or linked list of preset values
    49         Rp_Chain *_curveList;
     58        // static const char *creator[];
    5059
    5160        Rp_ChainLink *__searchCurveList(const char *name) const;

  • trunk/src/objects/RpString.cc

    r1386 r1528  
    2020            const char *val
    2121        )
    22     :   Variable    ()
     22    :   Object    ()
    2323{
    2424    this->path(path);
    … …  
    4141            size_t height
    4242        )
    43     :   Variable    ()
     43    :   Object    ()
    4444{
    4545    this->path(path);
    … …  
    5555// copy constructor
    5656String::String ( const String& o )
    57     :   Variable(o)
     57    :   Object(o)
    5858{
    5959    this->hints(o.hints());
    … …  
    7070}
    7171
     72/**********************************************************************/
     73// METHOD: xml()
     74/// view this object's xml
     75/**
     76 * View this object as an xml element returned as text.
     77 */
     78
     79const char *
     80String::xml()
     81{
     82    Path p(path());
     83    _tmpBuf.clear();
     84
     85    _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());
     97
     98    return _tmpBuf.bytes();
     99}
     100
     101/**********************************************************************/
     102// METHOD: is()
     103/// what kind of object is this
     104/**
     105 * return hex value telling what kind of object this is.
     106 */
     107
     108const int
     109String::is() const
     110{
     111    // return "stri" in hex
     112    return 0x73747269;
     113}
     114
    72115// -------------------------------------------------------------------- //
    73116

  • trunk/src/objects/RpString.h

    r1386 r1528  
    99 */
    1010#include <errno.h>
    11 #include "RpVariable.h"
     11#include "RpObject.h"
    1212
    1313#ifndef RAPPTURE_STRING_H
    … …  
    1616namespace Rappture {
    1717
    18 class String : public Variable
     18class String : public Object
    1919{
    2020public:
    … …  
    3434    virtual ~String ();
    3535
    36     Accessor<const char *> hints;
    3736    Accessor<const char *> def;
    3837    Accessor<const char *> cur;
    3938    Accessor<size_t> width;
    4039    Accessor<size_t> height;
     40
     41    const char *xml();
     42    const int is() const;
    4143
    4244private:
Note: See TracChangeset for help on using the changeset viewer.