source: branches/blt4/src/core/RpUnits.h @ 1824

Last change on this file since 1824 was 1527, checked in by dkearney, 15 years ago

various code cleanups, mainly tabs. adding units ohms and amps, adding appendf interface to the simple buffer so we can append formatted strings.
  • Property svn:executable set to *
File size: 27.7 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  RpUnits.h - Header file for Rappture Units
4 *
5 *   RpUnits Class Declaration / Definition
6 *
7 * ======================================================================
8 *  AUTHOR:  Derrick Kearney, Purdue University
9 *  Copyright (c) 2004-2007  Purdue Research Foundation
10 *
11 *  See the file "license.terms" for information on usage and
12 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13 * ======================================================================
14 */
15
16#ifndef _RpUNITS_H
17#define _RpUNITS_H
18
19enum RP_UNITS_CONSTS {
20    RPUNITS_UNITS_OFF           = 0,
21    RPUNITS_UNITS_ON            = 1,
22
23    // units naming flags
24    RPUNITS_POS_EXP             = 1,
25    RPUNITS_NEG_EXP             = 2,
26    RPUNITS_STRICT_NAME         = 4,
27    RPUNITS_ORIG_EXP            = 7
28};
29
30// RpUnits Case Insensitivity define
31#define RPUNITS_CASE_INSENSITIVE true
32
33#define RPUNITS_METRIC          true
34
35//define our different types of units
36#define RP_TYPE_ENERGY      "energy"
37#define RP_TYPE_EPOT        "electric_potential"
38#define RP_TYPE_LENGTH      "length"
39#define RP_TYPE_TEMP        "temperature"
40#define RP_TYPE_TIME        "time"
41#define RP_TYPE_VOLUME      "volume"
42#define RP_TYPE_ANGLE       "angle"
43#define RP_TYPE_MASS        "mass"
44#define RP_TYPE_PREFIX      "prefix"
45#define RP_TYPE_PRESSURE    "pressure"
46#define RP_TYPE_CONC        "concentration"
47#define RP_TYPE_FORCE       "force"
48#define RP_TYPE_MAGNETIC    "magnetic"
49#define RP_TYPE_MISC        "misc"
50#define RP_TYPE_POWER       "power"
51
52
53#ifdef __cplusplus
54
55#include <iostream>
56#include <string>
57#include <list>
58#include <sstream>
59#include <stdlib.h>
60#include <errno.h>
61#include <math.h>
62
63#include "RpDict.h"
64#include "RpUnitsStd.h"
65
66#define LIST_TEMPLATE RpUnitsListEntry
67
68class RpUnits;
69
70class RpUnitsPreset {
71    public:
72        RpUnitsPreset () {
73            addPresetAll();
74        };
75
76        static int  addPresetAll();
77        static int  addPresetEnergy();
78        static int  addPresetLength();
79        static int  addPresetTemp();
80        static int  addPresetTime();
81        static int  addPresetVolume();
82        static int  addPresetAngle();
83        static int  addPresetMass();
84        static int  addPresetPrefix();
85        static int  addPresetPressure();
86        static int  addPresetConcentration();
87        static int  addPresetForce();
88        static int  addPresetMagnetic();
89        static int  addPresetMisc();
90        static int  addPresetPower();
91};
92
93class RpUnitsTypes {
94    public:
95
96        typedef bool (*RpUnitsTypesHint)(RpUnits*);
97        static RpUnitsTypesHint getTypeHint (std::string type);
98
99        static bool hintTypePrefix    ( RpUnits* unitObj );
100        static bool hintTypeNonPrefix ( RpUnits* unitObj );
101        static bool hintTypeEnergy    ( RpUnits* unitObj );
102        static bool hintTypeEPot      ( RpUnits* unitObj );
103        static bool hintTypeLength    ( RpUnits* unitObj );
104        static bool hintTypeTemp      ( RpUnits* unitObj );
105        static bool hintTypeTime      ( RpUnits* unitObj );
106        static bool hintTypeVolume    ( RpUnits* unitObj );
107        static bool hintTypeAngle     ( RpUnits* unitObj );
108        static bool hintTypeMass      ( RpUnits* unitObj );
109        static bool hintTypePressure  ( RpUnits* unitObj );
110        static bool hintTypeConc      ( RpUnits* unitObj );
111        static bool hintTypeForce     ( RpUnits* unitObj );
112        static bool hintTypeMagnetic  ( RpUnits* unitObj );
113        static bool hintTypeMisc      ( RpUnits* unitObj );
114        static bool hintTypePower     ( RpUnits* unitObj );
115
116    private:
117
118        RpUnitsTypes () {};
119};
120
121// simple class to hold info about a conversion.
122// holds where we are converting from
123// holds where we are converting to
124// hold the pointer to a function to do the forward conversion (from->to)
125// hold the pointer to a function to do the backward conversion (to->from)
126//
127class conversion
128{
129    public:
130
131        const RpUnits* getFrom()    { return (const RpUnits*) fromPtr; };
132        const RpUnits* getTo()      { return (const RpUnits*) toPtr; };
133
134        friend class RpUnits;
135
136        // copy constructor
137        conversion ( conversion& other)
138            :   fromPtr             (other.fromPtr),
139                toPtr               (other.toPtr),
140                convForwFxnPtr      (other.convForwFxnPtr),
141                convBackFxnPtr      (other.convBackFxnPtr),
142                convForwFxnPtrDD    (other.convForwFxnPtrDD),
143                convBackFxnPtrDD    (other.convBackFxnPtrDD),
144                convForwFxnPtrVoid  (other.convForwFxnPtrVoid),
145                convForwData        (other.convForwData),
146                convBackFxnPtrVoid  (other.convBackFxnPtrVoid),
147                convBackData        (other.convBackData)
148            {};
149
150        // copy assignment operator
151        conversion& operator= ( conversion& other )
152            {
153                fromPtr             = other.fromPtr;
154                toPtr               = other.toPtr;
155                convForwFxnPtr      = other.convForwFxnPtr;
156                convBackFxnPtr      = other.convBackFxnPtr;
157                convForwFxnPtrDD    = other.convForwFxnPtrDD;
158                convBackFxnPtrDD    = other.convBackFxnPtrDD;
159                convForwFxnPtrVoid  = other.convForwFxnPtrVoid;
160                convForwData        = other.convForwData;
161                convBackFxnPtrVoid  = other.convBackFxnPtrVoid;
162                convBackData        = other.convBackData;
163                return *this;
164            }
165
166        // default destructor
167        virtual ~conversion ()
168        {}
169
170    private:
171
172        const RpUnits* fromPtr;
173        const RpUnits* toPtr;
174        double (*convForwFxnPtr)(double);
175        double (*convBackFxnPtr)(double);
176        double (*convForwFxnPtrDD)(double,double);
177        double (*convBackFxnPtrDD)(double,double);
178        void* (*convForwFxnPtrVoid)(void*, void*);
179        void* convForwData;
180        void* (*convBackFxnPtrVoid)(void*, void*);
181        void* convBackData;
182
183        // constructor
184        // private because i only want RpUnits to be able to
185        // create a conversion
186        conversion (
187                const RpUnits* fromPtr,
188                const RpUnits* toPtr,
189                double (*convForwFxnPtr)(double),
190                double (*convBackFxnPtr)(double)
191             )
192            :   fromPtr             (fromPtr),
193                toPtr               (toPtr),
194                convForwFxnPtr      (convForwFxnPtr),
195                convBackFxnPtr      (convBackFxnPtr),
196                convForwFxnPtrDD    (NULL),
197                convBackFxnPtrDD    (NULL),
198                convForwFxnPtrVoid  (NULL),
199                convForwData        (NULL),
200                convBackFxnPtrVoid  (NULL),
201                convBackData        (NULL)
202            {};
203
204        // constructor for 2 argument conversion functions
205        conversion (
206                const RpUnits* fromPtr,
207                const RpUnits* toPtr,
208                double (*convForwFxnPtr)(double,double),
209                double (*convBackFxnPtr)(double,double)
210             )
211            :   fromPtr             (fromPtr),
212                toPtr               (toPtr),
213                convForwFxnPtr      (NULL),
214                convBackFxnPtr      (NULL),
215                convForwFxnPtrDD    (convForwFxnPtr),
216                convBackFxnPtrDD    (convBackFxnPtr),
217                convForwFxnPtrVoid  (NULL),
218                convForwData        (NULL),
219                convBackFxnPtrVoid  (NULL),
220                convBackData        (NULL)
221            {};
222
223        // constructor for user defined void* returning 1 arg conversion fxns.
224        // the 1 arg is a user defined void* object
225        conversion (
226                const RpUnits* fromPtr,
227                const RpUnits* toPtr,
228                void* (*convForwFxnPtrVoid)(void*, void*),
229                void* convForwData,
230                void* (*convBackFxnPtrVoid)(void*, void*),
231                void* convBackData
232             )
233            :   fromPtr             (fromPtr),
234                toPtr               (toPtr),
235                convForwFxnPtr      (NULL),
236                convBackFxnPtr      (NULL),
237                convForwFxnPtrDD    (NULL),
238                convBackFxnPtrDD    (NULL),
239                convForwFxnPtrVoid  (convForwFxnPtrVoid),
240                convForwData        (convForwData),
241                convBackFxnPtrVoid  (convBackFxnPtrVoid),
242                convBackData        (convBackData)
243            {};
244
245};
246
247// used by the RpUnits class to create a linked list of the conversions
248// associated with the specific unit.
249//
250// we could templitize this and make a generic linked list
251// or could use generic linked list class from book programming with objects
252//
253class convEntry
254{
255
256    public:
257
258        friend class RpUnits;
259
260        virtual ~convEntry()
261        {}
262
263    private:
264
265        conversion* conv;
266        convEntry*  prev;
267        convEntry*  next;
268
269        convEntry (
270                conversion* conv,
271                convEntry*  prev,
272                convEntry*  next
273             )
274            :   conv    (conv),
275                prev    (prev),
276                next    (next)
277            {};
278
279};
280
281// used by the RpUnits class to create a linked list of the incarnated units
282// associated with the specific unit.
283//
284// we could templitize this and make a generic linked list
285// or could use generic linked list class from book programming with objects
286//
287class incarnationEntry
288{
289
290    public:
291
292        friend class RpUnits;
293
294        virtual ~incarnationEntry()
295        {}
296
297    private:
298
299        const RpUnits* unit;
300        incarnationEntry*  prev;
301        incarnationEntry*  next;
302
303        incarnationEntry (
304                const RpUnits* unit,
305                incarnationEntry*  prev,
306                incarnationEntry*  next
307             )
308            :   unit    (unit),
309                prev    (prev),
310                next    (next)
311            {};
312
313};
314
315class RpUnitsListEntry
316{
317
318    public:
319
320        // constructor
321        RpUnitsListEntry (const RpUnits* unit, double exponent, const RpUnits* prefix=NULL)
322            : unit     (unit),
323              exponent (exponent),
324              prefix   (prefix)
325        {};
326
327        // copy constructor
328        RpUnitsListEntry (const RpUnitsListEntry& other)
329            : unit     (other.unit),
330              exponent (other.exponent),
331              prefix   (other.prefix)
332        {};
333
334        // copy assignment operator
335        RpUnitsListEntry& operator= (const RpUnitsListEntry& other) {
336            unit = other.unit;
337            exponent = other.exponent;
338            prefix = other.prefix;
339            return *this;
340        }
341
342        // negate the exponent
343        void negateExponent() const;
344
345        // print the name of the object
346        std::string name(int flags=RPUNITS_ORIG_EXP) const;
347
348        // report the basis of the RpUnits object being stored.
349        const RpUnits* getBasis() const;
350
351        // return the RpUnits*
352        const RpUnits* getUnitsObj() const;
353
354        // return the exponent
355        double getExponent() const;
356
357        // return the metric prefix associated with this object
358        const RpUnits* getPrefix() const;
359
360        // destructor
361        virtual ~RpUnitsListEntry ()
362        {}
363
364    private:
365
366        const RpUnits* unit;
367        mutable double exponent;
368        const RpUnits* prefix;
369};
370
371class RpUnits
372{
373    /*
374     * helpful units site
375     * http://aurora.regenstrief.org/~gunther/units.html
376     * http://www.nodc.noaa.gov/dsdt/ucg/
377     * http://www.cellml.org/meeting_minutes/archive/
378     *        20010110_meeting_minutes.html
379     */
380
381    public:
382
383        static bool cmpFxn (char c1, char c2)
384        {
385            int lc1 = toupper(static_cast<unsigned char>(c1));
386            int lc2 = toupper(static_cast<unsigned char>(c2));
387
388            if ( (lc1 < lc2) || (lc1 > lc2) ) {
389                return false;
390            }
391
392            return true;
393
394        }
395        struct _key_compare:
396            public
397            std::binary_function<std::string,std::string,bool> {
398
399                bool operator() (   const std::string& lhs,
400                                    const std::string& rhs ) const
401                {
402                    return std::lexicographical_compare( lhs.begin(),lhs.end(),
403                                                         rhs.begin(),rhs.end(),
404                                                         RpUnits::cmpFxn  );
405                }
406            };
407
408        // why are these functions friends...
409        // probably need to find a better way to let RpUnits
410        // use the RpDict and RpDictEntry fxns
411        friend class RpDict<std::string,RpUnits*,_key_compare>;
412        friend class RpDictEntry<std::string,RpUnits*,_key_compare>;
413        // users member fxns
414        std::string getUnits() const;
415        std::string getUnitsName(int flags=RPUNITS_ORIG_EXP) const;
416        std::string getSearchName() const;
417        double getExponent() const;
418        const RpUnits* getBasis() const;
419        RpUnits& setMetric(bool newVal);
420
421        // retrieve a units type.
422        std::string getType() const;
423
424        // retrieve the case insensitivity of this unit object
425        bool getCI() const;
426
427        // retrieve a list of compatible units.
428        std::list<std::string> getCompatible(double expMultiplier=1.0) const;
429
430
431        // convert from one RpUnits to another if the conversion is defined
432        double convert(         const RpUnits* toUnits,
433                                double val,
434                                int* result=NULL    ) const;
435        // convert from one RpUnits to another if the conversion is defined
436        void* convert(          const RpUnits* toUnits,
437                                void* val,
438                                int* result=NULL) const;
439        // convert from one RpUnits to another if the conversion is defined
440        // double convert(std::string, double val);
441        // convert from one RpUnits to another if the conversion is defined
442        std::string convert (   const RpUnits* toUnits,
443                                double val,
444                                int showUnits = RPUNITS_UNITS_OFF,
445                                int* result = NULL  ) const;
446
447        static std::string convert ( std::string val,
448                                     std::string toUnits,
449                                     int showUnits = RPUNITS_UNITS_OFF,
450                                     int* result = NULL );
451
452        // turn the current unit to the metric system
453        // this should only be used for units that are part of the
454        // metric system. doesnt deal with exponents, just prefixes
455        double makeBasis(double value, int* result = NULL) const;
456        const RpUnits & makeBasis(double* value, int* result = NULL) const;
457
458        static int makeMetric(RpUnits * basis);
459
460        // find a RpUnits object that should exist in RpUnitsTable
461        // returns 0 on success (object was found)
462        // returns !0 on failure (object not found)
463        static const RpUnits* find( std::string key,
464        RpDict<std::string,RpUnits*,_key_compare>::RpDictHint hint = NULL);
465
466        // validate is very similar to find, but it works better
467        // for seeing complex units can be interpreted.
468        // it validates that if the a certain units string is
469        // provided as a unit type, then all of the base components
470        // of that unit are available for conversions.
471        // returns 0 on success (units are valid)
472        // returns !0 on failure (units not valid)
473        static int validate(std::string& inUnits,
474                            std::string& type,
475                            std::list<std::string>* compatList=NULL);
476
477        // user calls define to add a RpUnits object or to add a relation rule
478        //
479        // add RpUnits Object
480        static RpUnits * define(const std::string units,
481                                const RpUnits* basis=NULL,
482                                const std::string type="",
483                                bool metric=false,
484                                bool caseInsensitive=RPUNITS_CASE_INSENSITIVE);
485
486        // add relation rule
487
488        static RpUnits * define(const RpUnits* from,
489                                const RpUnits* to,
490                                double (*convForwFxnPtr)(double),
491                                double (*convBackFxnPtr)(double));
492
493        static RpUnits * define(const RpUnits* from,
494                                const RpUnits* to,
495                                double (*convForwFxnPtr)(double,double),
496                                double (*convBackFxnPtr)(double,double));
497
498        static RpUnits * define(const RpUnits* from,
499                                const RpUnits* to,
500                                void* (*convForwFxnPtr)(void*, void*),
501                                void* convForwData,
502                                void* (*convBackFxnPtr)(void*, void*),
503                                void* convBackData);
504
505        static int incarnate (  const RpUnits* abstraction,
506                                const RpUnits* entity);
507
508        // populate the dictionary with a set of units specified by group
509        // if group equals........................then load................
510        //                    "all"           load all available units
511        //  RP_TYPE_ENERGY    "energy"        load units related to energy
512        //  RP_TYPE_EPOT      "electric_potential" load units related to electric potential
513        //  RP_TYPE_LENGTH    "length"        load units related to length
514        //  RP_TYPE_TEMP      "temperature"   load units related to temperature
515        //  RP_TYPE_TIME      "time"          load units related to time
516        //  RP_TYPE_VOLUME    "volume"        load units related to volume
517        //  RP_TYPE_ANGLE     "angle"         load units related to angles
518        //  RP_TYPE_MASS      "mass"          load units related to mass
519        //  RP_TYPE_PREFIX    "prefix"        load unit prefixes
520        //  RP_TYPE_PRESSURE  "pressure"      load units related to pressure
521        //  RP_TYPE_CONC      "concentration" load units related to concentration
522        //  RP_TYPE_FORCE     "force"         load units related to force
523        //  RP_TYPE_MAGNETIC  "magnetic"      load units related to magnetics
524        //  RP_TYPE_MISC      "misc"          load units related to everything else
525        //  RP_TYPE_POWER     "power"         load units related to power
526        //  (no other groups have been created)
527
528        static int addPresets (const std::string group);
529
530        // undefining a relation rule is probably not needed
531        // int undefine(); // delete a relation
532
533
534        friend int insert(std::string key,RpUnits* val);
535
536
537        // copy constructor
538        RpUnits (RpUnits &other)
539            : units    (other.units),
540              exponent (other.exponent),
541              basis    (other.basis),
542              type     (other.type),
543              metric   (other.metric),
544              ci       (other.ci),
545              convList (NULL)
546        {
547            convEntry* q = NULL;
548            convEntry* curr = NULL;
549
550            incarnationEntry* r = NULL;
551            incarnationEntry* rcurr = NULL;
552
553            dict = other.dict;
554
555            if (other.convList) {
556                q = other.convList;
557                convList = new convEntry (q->conv,NULL,NULL);
558                curr = convList;
559                while (q->next) {
560                    q = q->next;
561                    curr->next = new convEntry (q->conv,curr,NULL);
562                    curr = curr->next;
563                }
564            }
565
566            if (other.incarnationList) {
567                r = other.incarnationList;
568                incarnationList = new incarnationEntry (r->unit,NULL,NULL);
569                rcurr = incarnationList;
570                while (r->next) {
571                    r = r->next;
572                    rcurr->next = new incarnationEntry (r->unit,rcurr,NULL);
573                    rcurr = rcurr->next;
574                }
575            }
576
577        }
578
579        // copy assignment operator
580        RpUnits& operator= (const RpUnits& other) {
581
582            convEntry* q = NULL;
583            convEntry* curr = NULL;
584
585            incarnationEntry* r = NULL;
586            incarnationEntry* rcurr = NULL;
587
588            if ( this != &other ) {
589                delete convList;
590            }
591
592            dict = other.dict;
593            units = other.units;
594            exponent = other.exponent;
595            basis = other.basis;
596            type = other.type;
597            metric = other.metric;
598            ci = other.ci;
599
600            if (other.convList) {
601                q = other.convList;
602                convList = new convEntry (q->conv,NULL,NULL);
603                curr = convList;
604                while (q->next) {
605                    q = q->next;
606                    curr->next = new convEntry (q->conv,curr,NULL);
607                    curr = curr->next;
608                }
609            }
610
611            if (other.incarnationList) {
612                r = other.incarnationList;
613                incarnationList = new incarnationEntry (r->unit,NULL,NULL);
614                rcurr = incarnationList;
615                while (r->next) {
616                    r = r->next;
617                    rcurr->next = new incarnationEntry (r->unit,rcurr,NULL);
618                    rcurr = rcurr->next;
619                }
620            }
621
622            return *this;
623        }
624
625        // default destructor
626        //
627        ~RpUnits ()
628        {
629            // go to the type list and remove a variable by this name
630
631
632            // clean up dynamic memory
633
634            convEntry* p = convList;
635            convEntry* tmp = p;
636
637            incarnationEntry* r = incarnationList;
638            incarnationEntry* rtmp = r;
639
640            while (p != NULL) {
641                tmp = p;
642                p = p->next;
643                delete tmp;
644            }
645
646            while (p != NULL) {
647                rtmp = r;
648                r = r->next;
649                delete rtmp;
650            }
651        }
652
653    private:
654
655        // i hope to replace these vars with a small class representing a
656        // of a linked list of units. that way we can handle complex units.
657        // this will also require that we move the getUnits, getExponent,
658        // and getBasis, makeBasis functionality into the smaller class,
659        // that represents each part of the units. we should keep getUnits,
660        // getBasis, and makeBasis in this class, but modify them to go
661        // through the linked list of units and combine the units back into
662        // what the caller expects to see.
663        // ie. cm2/Vms (mobility), will be split into the objects cm2, V, ms
664        // when getUnits is called, the user should see cm2/Vms again.
665        // for basis, possibly let the user choose a basis, and for makeBasis
666        // move through the linked list, only converting the metric elements.
667        //
668
669        std::string units;
670        double exponent;
671        const RpUnits* basis;
672        std::string type;
673
674        // tell if the unit can accept metric prefixes
675        bool metric;
676
677        // should this unit be inserted as a case insensitive unit?
678        bool ci;
679
680        // linked list of units this RpUnit can convert to
681        // its mutable because the connectConversion function takes in a
682        // const RpUnits* and attempts to change the convList variable
683        // within the RpUnits Object
684        mutable convEntry* convList;
685
686        // linked list of incarnation units for this RpUnit
687        // its mutable because the connectIncarnation function takes in a
688        // const RpUnits* and attempts to change the incarnationList variable
689        // within the RpUnits Object
690        mutable incarnationEntry* incarnationList;
691
692        // dictionary to store the units.
693        static RpDict<std::string,RpUnits*,_key_compare>* dict;
694
695        // create a units element
696        // class takes in three pieces of info
697        // 1) string describing the units
698        // 2) double describing the exponent
699        // 3) pointer to RpUnits object describing the basis
700        //      of the units (the fundamental unit)
701        //
702
703        RpUnits (
704                    const std::string& units,
705                    double& exponent,
706                    const RpUnits* basis,
707                    const std::string type,
708                    bool metric,
709                    bool caseInsensitive
710                )
711            :   units           (units),
712                exponent        (exponent),
713                basis           (basis),
714                type            (type),
715                metric          (metric),
716                ci              (caseInsensitive),
717                convList        (NULL),
718                incarnationList (NULL)
719        {};
720
721        // insert new RpUnits object into RpUnitsTable
722        // returns 0 on success (object inserted or already exists)
723        // returns !0 on failure (object cannot be inserted or dne)
724        // int RpUnits::insert(std::string key) const;
725
726        typedef std::list<LIST_TEMPLATE> RpUnitsList;
727        typedef double (*convFxnPtrD) (double);
728        typedef std::list<convFxnPtrD> convertList;
729        typedef RpUnitsList::iterator RpUnitsListIter;
730
731        // void newExponent                (double newExponent) {exponent = newExponent;};
732
733        static int      units2list          ( const std::string& inUnits,
734                                              RpUnitsList& outList,
735                                              std::string& type         );
736        static int      list2units          ( RpUnitsList& inList,
737                                              std::string& outUnitsStr  );
738        static int      grabExponent        ( const std::string& inStr,
739                                              double* exp               );
740        static int      grabUnitString      ( const std::string& inStr  );
741        static int      grabUnits           ( std::string inStr,
742                                              int* offset,
743                                              const RpUnits** unit,
744                                              const RpUnits** prefix    );
745        static int      checkMetricPrefix   ( std::string inStr,
746                                              int* offset,
747                                              const RpUnits** prefix    );
748        static int      negateListExponents ( RpUnitsList& unitsList    );
749        static int      printList           ( RpUnitsList& unitsList    );
750
751        static int compareListEntryBasis    ( RpUnitsList& fromList,
752                                              RpUnitsListIter& fromIter,
753                                              RpUnitsListIter& toIter   );
754
755        static int compareListEntrySearch   ( RpUnitsList& fromList,
756                                              RpUnitsListIter& fromIter,
757                                              RpUnitsListIter& toIter   );
758
759        void            connectConversion   ( conversion* conv      ) const;
760        void            connectIncarnation  ( const RpUnits* unit   ) const;
761
762        // return the conversion object that will convert
763        // from this RpUnits to the proovided toUnits object
764        // if the conversion is defined
765        int             getConvertFxnList   ( const RpUnits* toUnits,
766                                              convertList& cList    ) const;
767        static int      applyConversion     ( double* val,
768                                              convertList& cList    );
769        static int      combineLists        ( convertList& l1,
770                                              convertList& l2       );
771        static int      printList           ( convertList& l1       );
772
773};
774
775/*--------------------------------------------------------------------------*/
776/*--------------------------------------------------------------------------*/
777
778int list2str (std::list<std::string>& inList, std::string& outString);
779
780int unitSlice (std::string inStr, std::string& outUnits, double& outVal);
781
782#endif // ifdef __cplusplus
783
784#endif // ifndef _RpUNITS_H
Note: See TracBrowser for help on using the repository browser.