Changeset 1386 for trunk/src/objects


Ignore:
Timestamp:
Apr 6, 2009 3:16:39 PM (13 years ago)
Author:
dkearney
Message:

adding a few object prototypes we can play with for future developement. the plot object is probably the most interesting. examples are located in examples/objects dirs

Location:
trunk/src/objects
Files:
9 added
4 deleted
15 edited

Legend:

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

    r1270 r1386  
    11
    22bindir          = @bindir@
    3 datadir         = @datadir@
    4 datarootdir     = @datarootdir@
     3datadir         = @datadir@
     4datarootdir     = @datarootdir@
    55exec_prefix     = @exec_prefix@
    66includedir      = @includedir@
     
    88mandir          = @mandir@
    99prefix          = @prefix@
    10 srcdir          = @srcdir@
    11 incdir          = $(prefix)/include
     10srcdir          = @srcdir@
     11incdir          = $(prefix)/include
    1212
    13 INSTALL         = @INSTALL@
     13INSTALL         = @INSTALL@
    1414
    1515CXX             = @CXX@
     
    1717CCC             = @CC@
    1818CFLAGS_DEBUG    = @CFLAGS_DEBUG@
     19CFLAGS_WARNING  = -Wall
    1920CFLAGS_OPTIMIZE = @CFLAGS_OPTIMIZE@
    2021STLIB_LD        = @STLIB_LD@
     
    2627LIB_SEARCH_DIRS = @LIB_SEARCH_DIRS@
    2728CFLAGS          = @CFLAGS@
    28 RM              = rm -f
    29 CC_SWITCHES     = $(CFLAGS) $(INCLUDES) $(DEFINES)
     29RM              = rm -f
     30CC_SWITCHES = $(CFLAGS) $(INCLUDES) $(DEFINES) $(CFLAGS_DEBUG)
    3031
    31 INCLUDES        = \
     32INCLUDES    = \
    3233                -I. \
    3334                -I../core \
     
    3536                -I$(srcdir)/../core \
    3637                -I$(includedir)
    37 LIBS            = -L../core -lrappture
     38LIBS        = -L../core -lrappture
    3839
    39 RANLIB          = @RANLIB@
    40 AR              = ar
    41 VPATH           = $(srcdir)
     40RANLIB      = @RANLIB@
     41AR          = ar
     42VPATH       = $(srcdir)
    4243
    4344# tell make where to find the expat & libscew headers
     
    4546
    4647# define our compiling environment
    47 #
    48 DEBUG           = -g -Wall
    49 DEBUG_PLUS      = -g -DDEBUG
    5048LN              = ln -s
    5149
    5250HEADERS = \
     51                RpAccessor.h \
     52                RpArray1D.h \
     53                RpBoolean.h \
    5354                RpChain.h \
     55                RpChainHelper.h \
     56                RpChoice.h \
     57                RpCurve.h \
    5458                RpInt.h \
    5559                RpHash.h \
    5660                RpHashHelper.h \
    5761                RpNumber.h \
     62                RpPlot.h \
    5863                RpPool.h \
     64                RpString.h \
    5965                RpVariable.h
    6066
    61 #               RpBoolean.h \
    62                 RpAbout.h \
    63                 RpNumber.h \
    64                 RpOption.h \
    65                 RpString.h \
    66                 RpChoice.h \
    67                 RpVariable.h
    6867
    6968OBJS = \
     69                RpArray1D.o \
     70                RpBoolean.o \
    7071                RpChain.o \
     72                RpChoice.o \
     73                RpCurve.o \
     74                RpChainHelper.o \
    7175                RpHash.o \
    7276                RpHashHelper.o \
    7377                RpNumber.o \
     78                RpPlot.o \
    7479                RpPool.o \
     80                RpString.o \
     81                RpUtils2.o \
    7582                RpVariable.o
    7683
    77 #               RpAbout.o \
    78                 RpBoolean.o \
    79                 RpChoice.o \
    80                 RpNumber.o \
    81                 RpOption.o \
    82                 RpString.o \
    83                 RpVariable.o
    8484
    85 name            = RpObjects
    86 lib             = lib$(name).a
    87 shared_lib      = lib$(name)$(SHLIB_SUFFIX)
     85name        = RpObjects
     86lib         = lib$(name).a
     87shared_lib  = lib$(name)$(SHLIB_SUFFIX)
    8888
    8989all: build_lib
     
    108108        done
    109109
    110 .cc.o: 
    111         $(CXX) $(CC_SWITCHES) -c $? 
     110.cc.o:
     111        $(CXX) $(CC_SWITCHES) -c $?
    112112.c.o:
    113         $(CCC) $(CC_SWITCHES) -c $? 
     113        $(CCC) $(CC_SWITCHES) -c $?
    114114
    115 clean: 
     115clean:
    116116        $(RM) $(OBJS) $(lib) $(shared_lib)
    117117
  • trunk/src/objects/RpBoolean.cc

    r1018 r1386  
    11/*
    22 * ----------------------------------------------------------------------
    3  *  RpBoolean - Rappture 2.0 About XML object
     3 *  Rappture 2.0 Boolean Object Source
    44 *
    55 * ======================================================================
    66 *  AUTHOR:  Derrick Kearney, Purdue University
    7  *  Copyright (c) 2004-2005  Purdue Research Foundation
     7 *  Copyright (c) 2005-2009  Purdue Research Foundation
    88 *
    99 *  See the file "license.terms" for information on usage and
     
    1212 */
    1313
    14  #include "RpBoolean.h"
     14#include "RpBoolean.h"
     15#include "RpUnits.h"
    1516
    16 /**********************************************************************/
    17 // METHOD: setDefaultValue()
    18 /// Set the default value of this object
    19 /**
    20  */
     17using namespace Rappture;
    2118
    22 RpBoolean&
    23 RpBoolean::setDefaultValue(std::string newDefaultVal)
     19Boolean::Boolean (
     20            const char *path,
     21            int val
     22        )
     23    :   Variable    ()
    2424{
    25     std::string* def = NULL;
    26    
    27     def = (std::string*) RpVariable::getDefaultValue();
    28 
    29     if (!def) {
    30         RpVariable::setDefaultValue(new std::string (newDefaultVal));
    31     }
    32     else {
    33         *def = newDefaultVal;
    34     }
    35 
    36     return *this;
     25    this->path(path);
     26    this->def(val);
     27    this->cur(val);
    3728}
    3829
    39 /**********************************************************************/
    40 // METHOD: setCurrentValue()
    41 /// Set the current value of this object.
    42 /**
    43  */
    44 
    45 RpBoolean&
    46 RpBoolean::setCurrentValue(std::string newCurrentVal)
     30Boolean::Boolean (
     31            const char *path,
     32            int val,
     33            const char *label,
     34            const char *desc
     35        )
     36    :   Variable    ()
    4737{
    48     std::string* cur = (std::string*) RpVariable::getCurrentValue();
    49     std::string* def = (std::string*) RpVariable::getDefaultValue();
    50 
    51     if (cur == def) {
    52         RpVariable::setCurrentValue(new std::string (newCurrentVal));
    53     }
    54     else {
    55         *cur = newCurrentVal;
    56     }
    57 
    58     return *this;
     38    this->path(path);
     39    this->label(label);
     40    this->desc(desc);
     41    this->def(val);
     42    this->cur(val);
    5943}
    6044
     45// copy constructor
     46Boolean::Boolean ( const Boolean& o )
     47    :   Variable(o)
     48{
     49    this->def(o.def());
     50    this->cur(o.cur());
    6151
    62 /**********************************************************************/
    63 // METHOD: getDefaultValue()
    64 /// Report the default value of this object.
    65 /**
    66  */
    67 
    68 std::string
    69 RpBoolean::getDefaultValue(void* null_val) const
    70 {
    71     return *((std::string*) RpVariable::getDefaultValue());
    7252}
    7353
    74 /**********************************************************************/
    75 // METHOD: getCurrentValue()
    76 /// Report the current value of this object.
    77 /**
    78  */
    79 
    80 std::string
    81 RpBoolean::getCurrentValue(void* null_val) const
     54// default destructor
     55Boolean::~Boolean ()
    8256{
    83     return *((std::string*) RpVariable::getCurrentValue());
    8457}
    8558
    8659// -------------------------------------------------------------------- //
    87 
  • trunk/src/objects/RpBoolean.h

    r1018 r1386  
    11/*
    22 * ======================================================================
    3  *  Copyright (c) 2004-2005  Purdue Research Foundation
     3 *  AUTHOR:  Derrick Kearney, Purdue University
     4 *  Copyright (c) 2005-2009  Purdue Research Foundation
    45 *
    56 *  See the file "license.terms" for information on usage and
     
    78 * ======================================================================
    89 */
    9 #include <iostream>
    10 #include <string>
    11 #include <sstream>
    12 #include <stdlib.h>
    13 #include <errno.h>
    1410
     11#include "RpVariable.h"
    1512
    16 // #include "RpLibrary.h"
     13#ifndef RAPPTURE_BOOLEAN_H
     14#define RAPPTURE_BOOLEAN_H
    1715
    18 #ifndef _RpVARIABLE_H
    19     #include "RpVariable.h"
    20 #endif
     16namespace Rappture {
    2117
    22 #ifndef _RpBOOLEAN_H
    23 #define _RpBOOLEAN_H
    24 
    25 class RpBoolean : public RpVariable
     18class Boolean : public Variable
    2619{
    2720    public:
    28        
    29         // users member fxns
    3021
    31         virtual RpBoolean& setDefaultValue   (std::string newDefaultVal);
    32         virtual RpBoolean& setCurrentValue   (std::string newCurrentVal);
     22        Boolean  (  const char *path,
     23                    int val);
    3324
    34         // base class makes
    35         // these functions virtual and derived class has a different
    36         // return type. compiler doesnt like this. need to find another
    37         // way around this
    38         //
    39         // if we keep the null_val=NULL will that give us undefined behavior?
    40         //
    41         std::string getDefaultValue         (void* null_val=NULL) const;
    42         std::string getCurrentValue         (void* null_val=NULL) const;
     25        Boolean  (  const char *path,
     26                    int val,
     27                    const char *label,
     28                    const char *desc);
    4329
    44         // place the information from this object into the xml library 'lib'
    45         // virtual RpBoolean& put(RpLibrary lib);
    46         // RpBoolean& put() const;
     30        Boolean  ( const Boolean& o );
     31        virtual ~Boolean ();
    4732
    48         RpBoolean (
    49                     std::string path,
    50                     std::string defaultVal
    51                 )
    52             :   RpVariable  (path, new std::string (defaultVal) )
    53         { }
    54 
    55         RpBoolean (
    56                     std::string path,
    57                     std::string defaultVal,
    58                     std::string label,
    59                     std::string desc
    60                 )
    61             :   RpVariable  (path, new std::string (defaultVal), label, desc)
    62         { }
    63        
    64         // copy constructor
    65         RpBoolean ( const RpBoolean& myRpBoolean )
    66             :   RpVariable(myRpBoolean)
    67         {}
    68 
    69         // default destructor
    70         virtual ~RpBoolean ()
    71         {
    72             // clean up dynamic memory
    73         }
    74 
    75     private:
     33        Accessor<int> def;
     34        Accessor<int> cur;
    7635
    7736};
     37
     38} // namespace Rappture
    7839
    7940/*--------------------------------------------------------------------------*/
  • trunk/src/objects/RpChain.h

    r1270 r1386  
    2424#ifndef _RP_CHAIN_H
    2525#define _RP_CHAIN_H
     26
     27#ifdef __cplusplus
     28extern "C" {
     29#endif
    2630
    2731typedef struct Rp_ChainLinkStruct Rp_ChainLink;
     
    8387    (Rp_ChainLinkAfter((c), (l), (Rp_ChainLink *)NULL))
    8488
     89#ifdef __cplusplus
     90}
     91#endif
     92
    8593#endif /* _RP_CHAIN_H */
  • trunk/src/objects/RpChoice.cc

    r1018 r1386  
    11/*
    2  *  RpChoice - Rappture 2.0 About XML object
     2 * ----------------------------------------------------------------------
     3 *  Rappture 2.0 Choice Object Source
    34 *
    45 * ======================================================================
    56 *  AUTHOR:  Derrick Kearney, Purdue University
    6  *  Copyright (c) 2004-2005  Purdue Research Foundation
     7 *  Copyright (c) 2005-2009  Purdue Research Foundation
    78 *
    89 *  See the file "license.terms" for information on usage and
     
    1314#include "RpChoice.h"
    1415
     16using namespace Rappture;
     17
     18Choice::Choice (
     19            const char *path,
     20            const char *val
     21        )
     22    :   Variable    (),
     23        _options    (NULL)
     24{
     25    this->path(path);
     26    this->label("");
     27    this->desc("");
     28    this->def(val);
     29    this->cur(val);
     30}
     31
     32Choice::Choice (
     33            const char *path,
     34            const char *val,
     35            const char *label,
     36            const char *desc
     37        )
     38    :   Variable    (),
     39        _options    (NULL)
     40{
     41    this->path(path);
     42    this->label(label);
     43    this->desc(desc);
     44    this->def(val);
     45    this->cur(val);
     46}
     47
     48// copy constructor
     49Choice::Choice ( const Choice& o )
     50    :   Variable(o)
     51{
     52    this->def(o.def());
     53    this->cur(o.cur());
     54
     55    // need to copy _options
     56}
     57
     58// default destructor
     59Choice::~Choice ()
     60{
     61    // clean up dynamic memory
     62    // unallocate the _options?
     63
     64}
     65
    1566/**********************************************************************/
    16 // METHOD: setDefaultValue()
    17 /// Set the default value of a RpChoice object.
     67// METHOD: addOption()
     68/// Add an option value to the object
    1869/**
     70 * Add an option value to the object. Currently all
     71 * labels must be unique.
    1972 */
    2073
    21 RpChoice&
    22 RpChoice::setDefaultValue(std::string newDefaultVal)
     74Choice&
     75Choice::addOption(
     76    const char *label,
     77    const char *desc,
     78    const char *val)
    2379{
    24     std::string* def = NULL;
     80    option *p = NULL;
    2581
    26     def = (std::string*) RpVariable::getDefaultValue();
     82    p = new option;
     83    if (!p) {
     84        // raise error and exit
     85    }
    2786
    28     if (!def) {
    29         RpVariable::setDefaultValue(new std::string (newDefaultVal));
     87    p->label(label);
     88    p->desc(desc);
     89    p->val(val);
     90
     91    if (_options == NULL) {
     92        _options = Rp_ChainCreate();
     93        if (_options == NULL) {
     94            // raise error and exit
     95        }
    3096    }
    31     else {
    32         *def = newDefaultVal;
    33     }
     97
     98    Rp_ChainAppend(_options,p);
    3499
    35100    return *this;
     
    37102
    38103/**********************************************************************/
    39 // METHOD: setCurrentValue()
    40 /// Set the current value of a RpChoice object.
     104// METHOD: delOption()
     105/// Delete an option value from the object
    41106/**
     107 * Delete an option value from the object.
    42108 */
    43109
    44 RpChoice&
    45 RpChoice::setCurrentValue(std::string newCurrentVal)
     110Choice&
     111Choice::delOption(const char *label)
    46112{
    47     std::string* cur = (std::string*) RpVariable::getCurrentValue();
    48     std::string* def = (std::string*) RpVariable::getDefaultValue();
     113    if (label == NULL) {
     114        return *this;
     115    }
    49116
    50     if (cur == def) {
    51         RpVariable::setCurrentValue(new std::string (newCurrentVal));
     117    if (_options == NULL) {
     118        return *this;
    52119    }
    53     else {
    54         *cur = newCurrentVal;
     120
     121    option *p = NULL;
     122    const char *plabel = NULL;
     123    Rp_ChainLink *l = NULL;
     124
     125    // traverse the list looking for the matching option
     126    l = Rp_ChainFirstLink(_options);
     127    while (l != NULL) {
     128        p = (option *) Rp_ChainGetValue(l);
     129        plabel = p->label();
     130        if ((*label == *plabel) && (strcmp(plabel,label) == 0)) {
     131            // we found matching entry, remove it
     132            if (p) {
     133                delete p;
     134                Rp_ChainDeleteLink(_options,l);
     135            }
     136            break;
     137        }
    55138    }
     139
    56140
    57141    return *this;
    58142}
    59143
     144// -------------------------------------------------------------------- //
    60145
    61 /**********************************************************************/
    62 // METHOD: setOption()
    63 /// Set an option for this object.
    64 /**
    65  */
    66 
    67 RpChoice&
    68 RpChoice::setOption(std::string newOption)
    69 {
    70     options.push_back(RpOption(newOption));
    71     return *this;
    72 }
    73 
    74 /**********************************************************************/
    75 // METHOD: deleteOption()
    76 /// Delete the provided option from this object.
    77 /**
    78  */
    79 
    80 RpChoice&
    81 RpChoice::deleteOption(std::string optionName)
    82 {
    83     int lvc = 0;
    84     int vsize = options.size();
    85     // std::vector<RpOption>::iterator tempIterator;
    86     /*
    87     for (lvc=0,tempIterator=options.begin();lvc<vsize;lvc++,tempIterator++) {
    88         if (option[lvc] == option) {
    89             option.erase(tempIterator);
    90             break;
    91         }
    92     }
    93     */
    94     for (lvc = 0;lvc < vsize; lvc++) {
    95         if (options[lvc].getLabel() == optionName) {
    96             options.erase(options.begin()+lvc);
    97             break;
    98         }
    99     }
    100     return *this;
    101 }
    102 
    103 /**********************************************************************/
    104 // METHOD: getDefaultValue()
    105 /// Report the default value of this object.
    106 /**
    107  */
    108 
    109 std::string
    110 RpChoice::getDefaultValue(void* null_val) const
    111 {
    112     return *((std::string*) RpVariable::getDefaultValue());
    113 }
    114 
    115 /**********************************************************************/
    116 // METHOD: getCurrentValue()
    117 /// Report the current value of the object.
    118 /**
    119  */
    120 
    121 std::string
    122 RpChoice::getCurrentValue(void* null_val) const
    123 {
    124     return *((std::string*) RpVariable::getCurrentValue());
    125 }
    126 
    127 
    128 /************************************************************************
    129  *                                                                     
    130  * report the options of the object
    131  *                                                                     
    132  ************************************************************************/
    133 
    134 /**********************************************************************/
    135 // METHOD: setLabel()
    136 /// Set the label of this object.
    137 /**
    138  */
    139 
    140 std::string
    141 RpChoice::getFirstOption()
    142 {
    143     optionsIter = options.begin();
    144     return ((*optionsIter).getLabel());
    145 }
    146 
    147 /**********************************************************************/
    148 // METHOD: getNextOption()
    149 /// Report the next options of the object.
    150 /**
    151  * If you get to the end of the options list, "" is returned.
    152  */
    153 
    154 std::string
    155 RpChoice::getNextOption()
    156 {
    157     optionsIter++;
    158     if (optionsIter == options.end()) {
    159         return std::string("");
    160     }
    161     return ((*optionsIter).getLabel());
    162 }
    163 
    164 /**********************************************************************/
    165 // METHOD: getOptListSize()
    166 /// Report the number of options (items) in this object.
    167 /**
    168  */
    169 
    170 unsigned int
    171 RpChoice::getOptListSize() const
    172 {
    173     return options.size();
    174 }
    175 
    176 // -------------------------------------------------------------------- //
  • trunk/src/objects/RpChoice.h

    r1018 r1386  
    11/*
    22 * ======================================================================
    3  *  Copyright (c) 2004-2005  Purdue Research Foundation
     3 *  AUTHOR:  Derrick Kearney, Purdue University
     4 *  Copyright (c) 2005-2009  Purdue Research Foundation
    45 *
    56 *  See the file "license.terms" for information on usage and
     
    78 * ======================================================================
    89 */
    9 #include <iostream>
    10 #include <string>
    11 #include <sstream>
    12 #include <stdlib.h>
    1310#include <errno.h>
    14 #include <vector>
     11#include "RpVariable.h"
     12#include "RpChain.h"
    1513
     14#ifndef RAPPTURE_CHOICE_H
     15#define RAPPTURE_CHOICE_H
    1616
    17 // #include "RpLibrary.h"
     17namespace Rappture {
    1818
    19 #ifndef _RpVARIABLE_H
    20     #include "RpVariable.h"
    21 #endif
    22 
    23 #ifndef _RpOPTION_H
    24     #include "RpOption.h"
    25 #endif
    26 
    27 #ifndef _RpCHOICE_H
    28 #define _RpCHOICE_H
    29 
    30 class RpChoice : public RpVariable
     19class Choice : public Variable
    3120{
    3221    public:
    33        
    34         // users member fxns
    3522
    36         virtual RpChoice& setDefaultValue   (std::string newDefaultVal);
    37         virtual RpChoice& setCurrentValue   (std::string newCurrentVal);
    38         virtual RpChoice& setOption         (std::string newOption);
    39         virtual RpChoice& deleteOption      (std::string newOption);
     23        Choice  (   const char *path,
     24                    const char *val );
    4025
    41         // changed from "Value" to "Val" because base class makes
    42         // these functions virtual and derived class has a different
    43         // return type. compiler doesnt like this. need to find another
    44         // way around this
    45         //
    46         // if we keep the null_val=NULL will that give us undefined behavior?
    47         //
    48         virtual std::string getDefaultValue (void* null_val=NULL) const;
    49         virtual std::string getCurrentValue (void* null_val=NULL) const;
    50         virtual std::string getFirstOption  ();
    51         virtual std::string getNextOption   ();
    52         virtual unsigned int getOptListSize () const;
     26        Choice  (   const char *path,
     27                    const char *val,
     28                    const char *label,
     29                    const char *desc);
    5330
    54        
    55         // place the information from this object into the xml library 'lib'
    56         // virtual RpChoice& put(RpLibrary lib);
    57         // RpChoice& put() const;
     31        Choice  (   const Choice& o );
     32        virtual ~Choice ();
    5833
    59         RpChoice (
    60                     std::string path,
    61                     std::string defaultVal,
    62                     std::string optionList
    63                 )
    64             :   RpVariable  (path, new std::string (defaultVal) )
    65         {
    66             // optionList is a comma separated list of options
     34        Accessor<const char *> def;
     35        Accessor<const char *> cur;
    6736
    68             optionsIter = options.begin();
    69             std::string::size_type pos = optionList.find (',',0);
    70             std::string::size_type lastPos = 0;
    71             std::string tmpStr;
    72            
     37        Choice& addOption ( const char *label,
     38                            const char *desc,
     39                            const char *val );
    7340
    74             while (pos != std::string::npos) {
    75                 tmpStr = optionList.substr(lastPos, pos-lastPos);
    76                 setOption(tmpStr);
    77                 lastPos = pos + 1;
    78                 pos = optionList.find (",",lastPos);
    79             }
     41        Choice& delOption ( const char *label);
    8042
    81             tmpStr = optionList.substr(lastPos);
    82             setOption(tmpStr);
    83 
    84         }
    85 
    86         RpChoice (
    87                     std::string path,
    88                     std::string defaultVal,
    89                     std::string label,
    90                     std::string desc,
    91                     std::string optionList
    92                 )
    93             :   RpVariable  (path, new std::string (defaultVal), label, desc)
    94         {
    95             // optionList is a comma separated list of options
    96 
    97             optionsIter = options.begin();
    98             std::string::size_type pos = optionList.find (',',0);
    99             std::string::size_type lastPos = 0;
    100             std::string tmpStr;
    101            
    102 
    103             while (pos != std::string::npos) {
    104                 tmpStr = optionList.substr(lastPos, pos-lastPos);
    105                 setOption(tmpStr);
    106                 lastPos = pos + 1;
    107                 pos = optionList.find (",",lastPos);
    108             }
    109 
    110             tmpStr = optionList.substr(lastPos);
    111             setOption(tmpStr);
    112 
    113         }
    114        
    115         // copy constructor
    116         RpChoice ( const RpChoice& myRpChoice )
    117             :   RpVariable      (myRpChoice),
    118                 options         (myRpChoice.options)
    119         {
    120         }
    121 
    122         // default destructor
    123         virtual ~RpChoice ()
    124         {
    125             // clean up dynamic memory
    126 
    127         }
    12843    private:
    12944
    130         std::vector<RpOption> options;
    131         std::vector<RpOption>::iterator optionsIter;
     45        // hash or linked list of preset values
     46        Rp_Chain *_options;
     47
     48        struct option{
     49            Accessor<const char *> label;
     50            Accessor<const char *> desc;
     51            Accessor<const char *> val;
     52        };
    13253};
     54
     55} // namespace Rappture
    13356
    13457/*--------------------------------------------------------------------------*/
  • trunk/src/objects/RpHashHelper.c

    r1270 r1386  
    44#include <ctype.h>
    55#include "RpHashHelper.h"
     6
     7#ifdef __cplusplus
     8extern "C" {
     9#endif
     10
    611
    712int
     
    254259}
    255260
     261#ifdef __cplusplus
     262}
     263#endif
     264
  • trunk/src/objects/RpHashHelper.h

    r1270 r1386  
    44#include "RpInt.h"
    55#include "RpHash.h"
     6
     7#ifdef __cplusplus
     8extern "C" {
     9#endif
     10
    611
    712int Rp_HashPrint        ( Rp_HashTable *h);
     
    3641int charCmpFxn( void *to, void *from);
    3742
     43#ifdef __cplusplus
     44}
     45#endif
     46
    3847#endif // _RP_HASH_HELPER_H
  • trunk/src/objects/RpNumber.cc

    r1270 r1386  
    1212 */
    1313
    14 #include <cstring>
    15 #include <stdlib.h>
    1614#include "RpNumber.h"
    17 
    18 #ifndef _RpUNITS_H
    19     #include "RpUnits.h"
    20 #endif
    21 
    22 RpNumber::RpNumber (
     15#include "RpUnits.h"
     16
     17using namespace Rappture;
     18
     19Number::Number (
    2320            const char *path,
    24             const char *unit,
     21            const char *units,
    2522            double val
    2623        )
    27     :   RpVariable  (),
    28         _default    (val),
    29         _current    (val),
    30         _min        (0.0),
    31         _max        (0.0),
    32         _minmaxSet  (0.0)
     24    :   Variable    (),
     25        _minmaxSet  (0),
     26        _presets    (NULL)
    3327{
    3428    const RpUnits *u = NULL;
    3529
    36     property("path",(const void *)path);
    37 
    38     u = RpUnits::find(std::string(unit));
     30    this->path(path);
     31    this->label("");
     32    this->desc("");
     33    this->def(val);
     34    this->cur(val);
     35    this->min(0.0);
     36    this->max(0.0);
     37
     38    u = RpUnits::find(std::string(units));
    3939    if (!u) {
    40         u = RpUnits::define(unit,NULL);
    41     }
    42     property("units",(const void *)unit);
    43 
    44     property("default",(const void *)&_default);
    45     property("current",(const void *)&_current);
    46     property("min",(const void *)&_min);
    47     property("max",(const void *)&_max);
    48 }
    49 
    50 RpNumber::RpNumber (
     40        u = RpUnits::define(units,NULL);
     41    }
     42    this->units(units);
     43}
     44
     45Number::Number (
    5146            const char *path,
    52             const char *unit,
     47            const char *units,
    5348            double val,
    5449            double min,
     
    5752            const char *desc
    5853        )
    59     :   RpVariable  (),
    60         _default    (val),
    61         _current    (val),
    62         _min         (min),
    63         _max         (max),
    64         _minmaxSet   (0)
     54    :   Variable    (),
     55        _minmaxSet  (0),
     56        _presets    (NULL)
    6557{
    6658    const RpUnits *u = NULL;
    6759
    68     property("path",(const void *)path);
    69 
    70     u = RpUnits::find(std::string(unit));
     60    this->path(path);
     61    this->label(label);
     62    this->desc(desc);
     63    this->def(val);
     64    this->cur(val);
     65    this->min(min);
     66    this->max(max);
     67
     68    u = RpUnits::find(std::string(units));
    7169    if (! u) {
    72         u = RpUnits::define(unit,NULL);
    73     }
    74     property("units",(const void *)unit);
     70        u = RpUnits::define(units,NULL);
     71    }
     72    this->units(units);
    7573
    7674    if ((min == 0) && (max == 0)) {
     
    8078
    8179        if (min > val) {
    82             _min = val;
     80            this->min(val);
    8381        }
    8482
    8583        if (max < val) {
    86             _max = val;
    87         }
    88     }
    89 
    90     property("default",(const void *)&_default);
    91     property("current",(const void *)&_current);
    92     property("min",(const void *)&_min);
    93     property("max",(const void *)&_max);
     84            this->max(val);
     85        }
     86    }
    9487}
    9588
    9689// copy constructor
    97 RpNumber::RpNumber ( const RpNumber& o )
    98     :   RpVariable(o),
    99         _default    (o._default),
    100         _current    (o._current),
    101         _min        (o._min),
    102         _max        (o._max),
     90Number::Number ( const Number& o )
     91    :   Variable(o),
    10392        _minmaxSet  (o._minmaxSet)
    104 {}
     93{
     94    this->def(o.def());
     95    this->cur(o.cur());
     96    this->min(o.min());
     97    this->max(o.max());
     98    this->units(o.units());
     99
     100    // need to copy _presets
     101}
    105102
    106103// default destructor
    107 RpNumber::~RpNumber ()
     104Number::~Number ()
    108105{
    109106    // clean up dynamic memory
    110107
    111108}
    112 
    113 /**********************************************************************/
    114 // METHOD: units()
    115 /// get / set the units of this number
    116 /**
    117  * get / set the units property of this object
    118  */
    119 
    120 const char *
    121 RpNumber::units(
    122     const char *val)
    123 {
    124     return (const char *) property("units",val);
    125 }
    126 
    127109
    128110/**********************************************************************/
     
    134116
    135117double
    136 RpNumber::convert(const char *to) {
     118Number::convert(const char *to) {
    137119
    138120    const RpUnits* toUnit = NULL;
    139121    const RpUnits* fromUnit = NULL;
    140     double convertedVal = _current;
     122    double convertedVal = cur();
    141123    int err = 0;
    142124
     
    146128        // should raise error!
    147129        // conversion not defined because unit does not exist
    148         return _current;
    149     }
    150 
    151     fromUnit = RpUnits::find(std::string(units(NULL)));
     130        return convertedVal;
     131    }
     132
     133    fromUnit = RpUnits::find(std::string(units()));
    152134    if (!fromUnit) {
    153135        // should raise error!
    154136        // conversion not defined because unit does not exist
    155         return _current;
     137        return convertedVal;
    156138    }
    157139
    158140    // perform the conversion
    159     convertedVal = fromUnit->convert(toUnit,_default, &err);
     141    convertedVal = fromUnit->convert(toUnit,def(), &err);
    160142    if (!err) {
    161         _default = convertedVal;
    162     }
    163 
    164     convertedVal = fromUnit->convert(toUnit,_current, &err);
     143        def(convertedVal);
     144    }
     145
     146    convertedVal = fromUnit->convert(toUnit,cur(), &err);
    165147    if (!err) {
    166         _current = convertedVal;
     148        cur(convertedVal);
    167149    }
    168150
    169151    if (err) {
    170         convertedVal = _current;
     152        convertedVal = cur();
    171153    }
    172154
     
    174156}
    175157
     158/**********************************************************************/
     159// METHOD: addPreset()
     160/// Add a preset / suggessted value to the object
     161/**
     162 * Add a preset value to the object. Currently all
     163 * labels must be unique.
     164 */
     165
     166Number&
     167Number::addPreset(
     168    const char *label,
     169    const char *desc,
     170    double val,
     171    const char *units)
     172{
     173    preset *p = NULL;
     174
     175    p = new preset;
     176    if (!p) {
     177        // raise error and exit
     178    }
     179
     180    p->label(label);
     181    p->desc(desc);
     182    p->val(val);
     183    p->units(units);
     184
     185    if (_presets == NULL) {
     186        _presets = Rp_ChainCreate();
     187        if (_presets == NULL) {
     188            // raise error and exit
     189        }
     190    }
     191
     192    Rp_ChainAppend(_presets,p);
     193
     194    return *this;
     195}
     196
     197/**********************************************************************/
     198// METHOD: delPreset()
     199/// Delete a preset / suggessted value from the object
     200/**
     201 * Delete a preset value from the object.
     202 */
     203
     204Number&
     205Number::delPreset(const char *label)
     206{
     207    if (label == NULL) {
     208        return *this;
     209    }
     210
     211    if (_presets == NULL) {
     212        return *this;
     213    }
     214
     215    preset *p = NULL;
     216    const char *plabel = NULL;
     217    Rp_ChainLink *l = NULL;
     218
     219    // traverse the list looking for the matching preset
     220    l = Rp_ChainFirstLink(_presets);
     221    while (l != NULL) {
     222        p = (preset *) Rp_ChainGetValue(l);
     223        plabel = p->label();
     224        if ((*label == *plabel) && (strcmp(plabel,label) == 0)) {
     225            // we found matching entry, remove it
     226            if (p) {
     227                delete p;
     228                Rp_ChainDeleteLink(_presets,l);
     229            }
     230            break;
     231        }
     232    }
     233
     234
     235    return *this;
     236}
     237
    176238// -------------------------------------------------------------------- //
    177239
  • trunk/src/objects/RpNumber.h

    r1270 r1386  
    99 */
    1010#include <errno.h>
     11#include "RpVariable.h"
     12#include "RpChain.h"
    1113
    12 #ifndef _RpVARIABLE_H
    13     #include "RpVariable.h"
    14 #endif
     14#ifndef RAPPTURE_NUMBER_H
     15#define RAPPTURE_NUMBER_H
    1516
    16 #ifndef _RpNUMBER_H
    17 #define _RpNUMBER_H
     17namespace Rappture {
    1818
    19 class RpNumber : public RpVariable
     19class Number : public Variable
    2020{
    2121    public:
    2222
    23         RpNumber (  const char *path,
    24                     const char *unit,
     23        Number (  const char *path,
     24                    const char *units,
    2525                    double val);
    2626
    27         RpNumber (  const char *path,
    28                     const char *unit,
     27        Number (  const char *path,
     28                    const char *units,
    2929                    double val,
    3030                    double min,
     
    3333                    const char *desc);
    3434
    35         RpNumber ( const RpNumber& o );
    36         virtual ~RpNumber ();
     35        Number  ( const Number& o );
     36        virtual ~Number ();
    3737
    38         virtual const double defaultValue    (double val);
    39         virtual const double currentValue    (double val);
    40         virtual const double min             (double val);
    41         virtual const double max             (double val);
    42         virtual const char *units            (const char *val);
     38        Accessor<double> def;
     39        Accessor<double> cur;
     40        Accessor<double> min;
     41        Accessor<double> max;
     42        Accessor<const char *> units;
     43
    4344        // need to add a way to tell user conversion failed
    44         virtual double convert               (const char *to);
     45        virtual double convert (const char *to);
     46
     47        Number& addPreset(  const char *label,
     48                            const char *desc,
     49                            double val,
     50                            const char *units   );
     51
     52        Number& delPreset(const char *label);
    4553
    4654    private:
    4755
    48         double _default;
    49         double _current;
    50         double _min;
    51         double _max;
    52 
    5356        // flag tells if user specified min and max values
    5457        int _minmaxSet;
     58
     59        // hash or linked list of preset values
     60        Rp_Chain *_presets;
     61
     62        struct preset{
     63            Accessor<const char *> label;
     64            Accessor<const char *> desc;
     65            Accessor<double> val;
     66            Accessor<const char *> units;
     67        };
    5568};
     69
     70} // namespace Rappture
    5671
    5772/*--------------------------------------------------------------------------*/
  • trunk/src/objects/RpString.cc

    r1018 r1386  
    55 * ======================================================================
    66 *  AUTHOR:  Derrick Kearney, Purdue University
    7  *  Copyright (c) 2004-2005  Purdue Research Foundation
     7 *  Copyright (c) 2005-2009  Purdue Research Foundation
    88 *
    99 *  See the file "license.terms" for information on usage and
     
    1414#include "RpString.h"
    1515
    16 /**********************************************************************/
    17 // METHOD: setDefaultValue()
    18 /// set the default value of this object.
    19 /**
    20  */
     16using namespace Rappture;
    2117
    22 RpString&
    23 RpString::setDefaultValue(std::string newDefaultVal)
     18String::String (
     19            const char *path,
     20            const char *val
     21        )
     22    :   Variable    ()
    2423{
    25     std::string* def = NULL;
    26    
    27     def = (std::string*) RpVariable::getDefaultValue();
    28 
    29     if (!def) {
    30         RpVariable::setDefaultValue(new std::string (newDefaultVal));
    31     }
    32     else {
    33         *def = newDefaultVal;
    34     }
    35 
    36     return *this;
     24    this->path(path);
     25    this->label("");
     26    this->desc("");
     27    this->hints("");
     28    this->def(val);
     29    this->cur(val);
     30    this->width(0);
     31    this->height(0);
    3732}
    3833
    39 /**********************************************************************/
    40 // METHOD: setCurrentValue()
    41 /// set the current value of this object
    42 /**
    43  */
    44 
    45 RpString&
    46 RpString::setCurrentValue(std::string newCurrentVal)
     34String::String (
     35            const char *path,
     36            const char *val,
     37            const char *label,
     38            const char *desc,
     39            const char *hints,
     40            size_t width,
     41            size_t height
     42        )
     43    :   Variable    ()
    4744{
    48     std::string* cur = (std::string*) RpVariable::getCurrentValue();
    49     std::string* def = (std::string*) RpVariable::getDefaultValue();
    50 
    51     if (cur == def) {
    52         RpVariable::setCurrentValue(new std::string (newCurrentVal));
    53     }
    54     else {
    55         *cur = newCurrentVal;
    56     }
    57 
    58     return *this;
     45    this->path(path);
     46    this->label(label);
     47    this->desc(desc);
     48    this->hints(hints);
     49    this->def(val);
     50    this->cur(val);
     51    this->width(width);
     52    this->height(height);
    5953}
    6054
    61 /**********************************************************************/
    62 // METHOD: setSize()
    63 /// set the size (width and height) of this object.
    64 /**
    65  */
    66 
    67 RpString&
    68 RpString::setSize(std::string sizeWxH)
     55// copy constructor
     56String::String ( const String& o )
     57    :   Variable(o)
    6958{
    70     unsigned int xloc = sizeWxH.find("x");
    71 
    72     if (xloc == std::string::npos) {
    73         // sizeWxH is of incorrect format
    74         // raise error!
    75 
    76     }
    77     else {           
    78         this->width = atoi(sizeWxH.substr(0,xloc).c_str());
    79         this->height = atoi(sizeWxH.substr(xloc).c_str());
    80     }
    81 
    82     return *this;
     59    this->hints(o.hints());
     60    this->def(o.def());
     61    this->cur(o.cur());
     62    this->width(o.width());
     63    this->height(o.height());
    8364}
    8465
    85 /**********************************************************************/
    86 // METHOD: setWidth()
    87 /// set the width of this object
    88 /**
    89  */
    90 
    91 RpString&
    92 RpString::setWidth(int newWidth)
     66// default destructor
     67String::~String ()
    9368{
    94     this->width = newWidth;
    95     return *this;
    96 }
    97 
    98 /**********************************************************************/
    99 // METHOD: setHeight()
    100 /// set the height of this object.
    101 /**
    102  */
    103 
    104 RpString&
    105 RpString::setHeight(int newHeight)
    106 {
    107     this->height = newHeight;
    108     return *this;
    109 }
    110 
    111 
    112 /**********************************************************************/
    113 // METHOD: getDefaultValue()
    114 /// report the default value of this object.
    115 /**
    116  */
    117 
    118 std::string
    119 RpString::getDefaultValue(void* null_val) const
    120 {
    121     return *((std::string*) RpVariable::getDefaultValue());
    122 }
    123 
    124 /**********************************************************************/
    125 // METHOD: getCurrentValue()
    126 /// report the current value of this object.
    127 /**
    128  */
    129 
    130 std::string
    131 RpString::getCurrentValue(void* null_val) const
    132 {
    133     return *((std::string*) RpVariable::getCurrentValue());
    134 }
    135 
    136 /**********************************************************************/
    137 // METHOD: getSize()
    138 /// report the size of this object  in the form  Height x Width
    139 /**
    140  */
    141 
    142 std::string
    143 RpString::getSize() const
    144 {
    145     std::stringstream tmpStr;
    146 
    147     tmpStr << getWidth() << "x" << getHeight();
    148     return (tmpStr.str());
    149 }
    150 
    151 /**********************************************************************/
    152 // METHOD: getHeight()
    153 /// report the Height of this object.
    154 /**
    155  */
    156 
    157 int
    158 RpString::getHeight() const
    159 {
    160     return height;
    161 }
    162 
    163 /**********************************************************************/
    164 // METHOD: getWidth()
    165 /// report the Width of this object.
    166 /**
    167  */
    168 
    169 int
    170 RpString::getWidth() const
    171 {
    172     return width;
     69    // clean up dynamic memory
    17370}
    17471
  • trunk/src/objects/RpString.h

    r1018 r1386  
    11/*
    22 * ======================================================================
    3  *  AUTHOR: Derrick S. Kearney, Purdue University
    4  *  Copyright (c) 2004-2005  Purdue Research Foundation
     3 *  AUTHOR:  Derrick Kearney, Purdue University
     4 *  Copyright (c) 2005-2009  Purdue Research Foundation
    55 *
    66 *  See the file "license.terms" for information on usage and
     
    88 * ======================================================================
    99 */
    10 #include <iostream>
    11 #include <string>
    12 #include <sstream>
    13 #include <stdlib.h>
    1410#include <errno.h>
     11#include "RpVariable.h"
    1512
     13#ifndef RAPPTURE_STRING_H
     14#define RAPPTURE_STRING_H
    1615
    17 // #include "RpLibrary.h"
     16namespace Rappture {
    1817
    19 #ifndef _RpVARIABLE_H
    20     #include "RpVariable.h"
    21 #endif
     18class String : public Variable
     19{
     20public:
    2221
    23 #ifndef _RpSTRING_H
    24 #define _RpSTRING_H
     22    String  ( const char *path,
     23              const char *val);
    2524
    26 class RpString : public RpVariable
    27 {
    28     public:
    29        
    30         // users member fxns
     25    String  ( const char *path,
     26              const char *val,
     27              const char *label,
     28              const char *desc,
     29              const char *hints,
     30              size_t width,
     31              size_t height);
    3132
    32         virtual RpString& setDefaultValue   (std::string newDefaultVal);
    33         virtual RpString& setCurrentValue   (std::string newCurrentVal);
    34         virtual RpString& setSize           (std::string newSize);
    35         virtual RpString& setHeight         (int newHeight);
    36         virtual RpString& setWidth          (int newWidth);
     33    String  ( const String& o );
     34    virtual ~String ();
    3735
    38         // base class makes
    39         // these functions virtual and derived class has a different
    40         // return type. compiler doesnt like this. need to find another
    41         // way around this
    42         //
    43         // if we keep the null_val=NULL will that give us undefined behavior?
    44         //
    45         std::string getDefaultValue         (void* null_val=NULL) const;
    46         std::string getCurrentValue         (void* null_val=NULL) const;
    47         std::string getSize                 () const;
    48         int         getHeight               () const;
    49         int         getWidth                () const;
     36    Accessor<const char *> hints;
     37    Accessor<const char *> def;
     38    Accessor<const char *> cur;
     39    Accessor<size_t> width;
     40    Accessor<size_t> height;
    5041
    51         // place the information from this object into the xml library 'lib'
    52         // virtual RpString& put(RpLibrary lib);
    53         // RpString& put() const;
    54 
    55         RpString (
    56                     std::string path,
    57                     std::string defaultVal
    58                 )
    59             :   RpVariable  (path, new std::string (defaultVal) ),
    60                 width       (0),
    61                 height      (0)
    62         {}
    63 
    64         RpString (
    65                     std::string path,
    66                     std::string defaultVal,
    67                     std::string sizeWxH
    68                 )
    69             :   RpVariable  (path, new std::string (defaultVal) ),
    70                 width       (0),
    71                 height      (0)
    72         {
    73             setSize(sizeWxH);
    74         }
    75 
    76         RpString (
    77                     std::string path,
    78                     std::string defaultVal,
    79                     std::string sizeWxH,
    80                     std::string label,
    81                     std::string desc
    82                 )
    83             :   RpVariable  (path, new std::string (defaultVal), label, desc),
    84                 width       (0),
    85                 height      (0)
    86         {
    87             setSize(sizeWxH);
    88         }
    89 
    90         // copy constructor
    91         RpString ( const RpString& myRpString )
    92             :   RpVariable(myRpString),
    93                 width       (myRpString.width),
    94                 height      (myRpString.height)
    95         {}
    96 
    97         // default destructor
    98         virtual ~RpString ()
    99         {
    100             // clean up dynamic memory
    101         }
    102 
    103     private:
    104         int width;
    105         int height;
    106         std::string hints;
    107 
    108 
     42private:
    10943
    11044};
     45
     46} // namespace Rappture
    11147
    11248/*--------------------------------------------------------------------------*/
    11349/*--------------------------------------------------------------------------*/
    11450
    115 #endif
     51#endif // RAPPTURE_STRING_H
  • trunk/src/objects/RpUtils2.c

    r1270 r1386  
    11#include <stdio.h>
     2#include <stdlib.h>
    23#include <stdarg.h>
    34
  • trunk/src/objects/RpVariable.cc

    r1270 r1386  
    1414 */
    1515
    16 #include <cstring>
    17 #include <stdlib.h>
    1816#include "RpVariable.h"
    1917#include "RpHashHelper.h"
    2018
    21 RpVariable::RpVariable()
     19using namespace Rappture;
     20
     21Variable::Variable()
    2222{
    2323    __init();
    2424}
    2525
    26 RpVariable::RpVariable(const RpVariable& o)
    27     :
    28         _path (o._path)
     26Variable::Variable (
     27    const char *path,
     28    const char *label,
     29    const char *desc,
     30    const char *hints,
     31    const char *color   )
    2932{
     33    this->path(path);
     34    this->label(label);
     35    this->desc(desc);
     36    this->hints(hints);
     37    this->color(color);
     38}
     39
     40Variable::Variable(const Variable& o)
     41{
     42    path(o.path());
     43    label(o.label());
     44    desc(o.desc());
     45    hints(o.hints());
     46    color(o.color());
     47    icon(o.icon());
     48
    3049    if (o._h != NULL) {
    3150        Rp_HashCopy(_h,o._h,charCpyFxn);
     
    3352}
    3453
    35 RpVariable::~RpVariable()
     54Variable::~Variable()
    3655{
    37     __close();
    38 }
    39 
    40 const char *
    41 RpVariable::label(
    42     const char *val)
    43 {
    44     return (const char *) property("label",val);
    45 }
    46 
    47 const char *
    48 RpVariable::desc(
    49     const char *val)
    50 {
    51     return (const char *) property("desc",val);
    52 }
    53 
    54 const char *
    55 RpVariable::hints(
    56     const char *val)
    57 {
    58     return (const char *) property("hints",val);
    59 }
    60 
    61 const char *
    62 RpVariable::color(
    63     const char *val)
    64 {
    65     return (const char *) property("color",val);
    66 }
    67 
    68 const char *
    69 RpVariable::icon(
    70     const char *val)
    71 {
    72     return (const char *) property("icon",val);
    73 }
    74 
    75 const char *
    76 RpVariable::path(
    77     const char *val)
    78 {
    79     return (const char *) property("path",val);
     56    __clear();
    8057}
    8158
    8259const void *
    83 RpVariable::property(
     60Variable::property(
    8461    const char *key,
    8562    const void *val)
     
    9067        _h = (Rp_HashTable*) malloc(sizeof(Rp_HashTable));
    9168        Rp_InitHashTable(_h,RP_STRING_KEYS);
    92         return NULL;
    9369    }
    9470
     
    9773        r = Rp_HashSearchNode(_h,key);
    9874    } else {
    99         //set the value
     75        // set the value
    10076        Rp_HashRemoveNode(_h,key);
    10177        Rp_HashAddNode(_h,key,val);
     
    10682}
    10783
    108 void
    109 RpVariable::__init()
     84const char *
     85Variable::propstr(
     86    const char *key,
     87    const char *val)
    11088{
    111     _path = NULL;
    112     _h = NULL;
     89    const char *r = NULL;
     90    char *str = NULL;
     91    if (_h == NULL) {
     92        // hash table does not exist, create it
     93        _h = (Rp_HashTable*) malloc(sizeof(Rp_HashTable));
     94        Rp_InitHashTable(_h,RP_STRING_KEYS);
     95    }
     96
     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
     119void *
     120Variable::propremove(
     121    const char *key)
     122{
     123    if ((key == NULL) || (_h == NULL)) {
     124        // key or hash table does not exist
     125        return NULL;
     126    }
     127
     128    return Rp_HashRemoveNode(_h,key);
    113129}
    114130
    115131void
    116 RpVariable::__close()
     132Variable::__init()
    117133{
    118     if (_path != NULL) {
    119         free((void *)_path);
    120     }
     134    _h = NULL;
     135    label("");
     136    desc("");
     137    hints("");
     138    color("");
     139    // icon(NULL);
     140    path("");
     141}
     142
     143void
     144Variable::__clear()
     145{
     146    // who frees the Accessors?
    121147
    122148    if (_h != NULL) {
  • trunk/src/objects/RpVariable.h

    r1270 r1386  
    99 */
    1010
    11 #ifndef _RpVARIABLE_H
    12 #define _RpVARIABLE_H
     11#ifndef RAPPTURE_VARIABLE_H
     12#define RAPPTURE_VARIABLE_H
    1313
    1414#include "RpInt.h"
    1515#include "RpHash.h"
     16#include "RpAccessor.h"
     17#include "RpBuffer.h"
    1618
    17 class RpVariable
     19namespace Rappture {
     20
     21class Variable
    1822{
    1923    public:
    20         RpVariable ();
    21         RpVariable (const RpVariable& o);
    22         virtual ~RpVariable();
     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();
    2332
    24         virtual const char *label           (const char *val);
    25         virtual const char *desc            (const char *val);
    26         virtual const char *hints           (const char *val);
    27         virtual const char *color           (const char *val);
    28         virtual const char *icon            (const char *val);
    29         virtual const char *path            (const char *val);
    30         virtual const void *property        (const char *key, const void *val);
     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;
     39
     40        // these functions are not completely improper use proof
     41        // user is responsible for calling propremove() on any item
     42        // 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);
    3146
    3247    private:
    33 
    34         /// path of the object in the xml tree and key in hash tables
    35         const char *_path;
    3648
    3749        /// hash table holding other object properties
     
    4254
    4355        /// close out the object, freeing its memory
    44         void __close();
     56        void __clear();
    4557};
     58
     59} // RAPPTURE_VARIABLE_H
    4660
    4761/*--------------------------------------------------------------------------*/
Note: See TracChangeset for help on using the changeset viewer.