Index: /trunk/include/cee/RpUnitsCInterface.h
===================================================================
--- /trunk/include/cee/RpUnitsCInterface.h	(revision 19)
+++ /trunk/include/cee/RpUnitsCInterface.h	(revision 19)
@@ -0,0 +1,53 @@
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif 
+
+    typedef struct RpUnits RpUnits;
+
+    // unit definition functions
+    RpUnits* defineUnit(const char* unitSymbol, RpUnits* basis);
+
+    // conversion definition functions
+    RpUnits* defineConv(    RpUnits* fromUnit,
+                            RpUnits* toUnit,
+                            double (*convForwFxnPtr)(double),
+                            double (*convBackFxnPtr)(double)    );
+
+    // unit attribute access functions
+    const char* getUnits(RpUnits* unit);
+
+    const char* getUnitsName(RpUnits* unit);
+    
+    double getExponent(RpUnits* unit);
+    
+    RpUnits* getBasis(RpUnits* unit);
+
+    RpUnits* find(const char* unitSymbol);
+
+    int makeMetric(RpUnits* basis);
+
+    // convert functions 
+    const char* convert_str(    RpUnits* fromUnits, 
+                                RpUnits* toUnits, 
+                                double val,
+                                int showUnits   );
+    
+    const char* convert_str_result( RpUnits* fromUnits, 
+                                    RpUnits* toUnits, 
+                                    double val, 
+                                    int showUnits,
+                                    int* result );
+
+    double convert_double(RpUnits* fromUnits, RpUnits* toUnits, double val);
+
+    double convert_double_result(   RpUnits* fromUnits, 
+                                    RpUnits* toUnits, 
+                                    double val, 
+                                    int* result );
+
+
+#ifdef __cplusplus
+}
+#endif
Index: /trunk/include/cee/rappture_interface.h
===================================================================
--- /trunk/include/cee/rappture_interface.h	(revision 19)
+++ /trunk/include/cee/rappture_interface.h	(revision 19)
@@ -0,0 +1,37 @@
+// #include <stdio.h>
+// #include <assert.h>
+// #include <python2.3/Python.h> // "/usr/include/python2.3/Python.h" //  
+#include "python2.4/Python.h" // "/usr/include/python2.3/Python.h" //  
+
+/*
+#ifdef _cplusplus 
+extern "C" {
+#endif    
+*/
+
+PyObject* importRappture    ();
+PyObject* createRapptureObj (PyObject* rpObj, const char* path);
+
+void*       rpElement   (PyObject* lib, const char* path, const char* flavor);
+void**      rpChildren  (PyObject* lib, const char* path, const char* flavor);
+PyObject*   rpChildren_f  (PyObject* lib, const char* path, const char* flavor);
+const char* rpGet       (PyObject* lib, const char* path);
+void        rpPut       (PyObject* lib, 
+                            const char* path, 
+                            const char* value, 
+                            const char* id, 
+                            int append );
+void        rpPutObj    (PyObject* lib,
+                            const char* path,
+                            PyObject* value,
+                            const char* id,
+                            int append );
+
+PyObject*   rpRemove    (PyObject* lib, const char* path);
+const char* rpXml       (PyObject* lib);
+
+/*
+#ifdef _cplusplus 
+}
+#endif    
+*/
Index: /trunk/include/core/RpDict.h
===================================================================
--- /trunk/include/core/RpDict.h	(revision 19)
+++ /trunk/include/core/RpDict.h	(revision 19)
@@ -0,0 +1,316 @@
+#include <iostream>
+#include <cassert>
+#include <string>
+#include <stdlib.h>
+#include <errno.h>
+#include <malloc.h>
+
+#ifndef _RpDICT_H 
+#define _RpDICT_H
+
+/**************************************************************************/
+
+
+/**************************************************************************/
+
+template <typename KeyType, typename ValType> class RpDict;
+template <typename KeyType, typename ValType> class RpDictEntry;
+
+/**************************************************************************/
+
+template <typename KeyType, typename ValType> class RpDictIterator
+{
+
+    public:
+
+        // public data members
+
+        // public member functions
+
+        // retrieve the table the iterator is iterating
+        // virtual RpDict<KeyType,ValType>& getTable();
+
+        // send the search iterator to the beginning of the hash table
+        virtual RpDictEntry<KeyType,ValType>* first();
+
+        // send the search iterator to the next element of the hash table
+        virtual RpDictEntry<KeyType,ValType>* next();
+/*
+        RpDictIterator(RpDict* table_Ptr)
+            : tablePtr( (RpDict&) *table_Ptr),
+              srchNextEntryPtr(NULL),
+              srchNextIndex(0)
+        {
+        }
+*/
+        RpDictIterator(RpDict<KeyType,ValType>& table_Ptr)
+            : tablePtr(table_Ptr),
+              srchNextIndex(0),
+              srchNextEntryPtr(NULL)
+        {
+        }
+
+        // copy constructor
+        RpDictIterator(RpDictIterator<KeyType,ValType>& iterRef)
+            : tablePtr(iterRef.tablePtr),
+              srchNextIndex(iterRef.srchNextIndex),
+              srchNextEntryPtr(iterRef.srchNextEntryPtr)
+        {
+        }
+
+        // destructor
+
+    private:
+
+        RpDict<KeyType,ValType>& 
+            tablePtr;                   /* pointer to the table we want to 
+                                         * iterate */
+        int srchNextIndex;              /* Index of next bucket to be
+                                         * enumerated after present one. */
+        RpDictEntry<KeyType,ValType>* 
+            srchNextEntryPtr;           /* Next entry to be enumerated in the
+                                         * the current bucket. */
+
+};
+
+
+template <typename KeyType, typename ValType> class RpDictEntry
+{
+    public:
+
+        // public member functions 
+
+        operator int() const;
+        // operator==(const RpDictEntry& entry) const;
+        //
+        //operator!=(const RpDictEntry& lhs, const RpDictEntry& rhs) const 
+        //{
+        //    if (lhs.key != rhs.key)
+        //}
+        const KeyType* getKey() const;
+        const ValType* getValue() const;
+        // const void* setValue(const void* value);
+        const ValType* setValue(const ValType& value);
+
+        // erases this entry from its table
+        void erase();
+
+        // template <KeyType,ValType> friend class RpDict;
+        // template <KeyType,ValType> friend class RpDictIterator;
+
+        friend class RpDict<KeyType,ValType>;
+        friend class RpDictIterator<KeyType,ValType>;
+
+        // no_arg constructor
+        // use the key and clientData's default [no-arg] constructor
+        RpDictEntry()
+           : nextPtr (NULL), 
+             tablePtr (NULL), 
+             hash (0) // , 
+             // clientData (),
+             // key ()
+        {
+        }
+
+        // one-arg constructor
+        // maybe get rid of this one?
+        RpDictEntry(KeyType newKey)
+           : nextPtr    (NULL), 
+             tablePtr   (NULL), 
+             hash       (0), 
+             clientData (NULL),
+             key        (newKey)
+        {
+        }
+
+        // two-arg constructor
+        RpDictEntry(KeyType newKey, ValType newVal)
+           : nextPtr    (NULL), 
+             tablePtr   (NULL), 
+             hash       (0), 
+             clientData (newVal),
+             key        (newKey)
+        {
+        }
+
+/*
+        RpDictEntry(KeyType* newKey, ValType* newVal)
+           : nextPtr    (NULL), 
+             tablePtr   (NULL), 
+             hash       (0), 
+             clientData (*newVal),
+             key        (*newKey)
+        {
+        }
+
+        RpDictEntry(KeyType newKey, RpDict* table)
+           : nextPtr    (NULL), 
+             tablePtr   (table), 
+             hash       (0), 
+             // clientData (NULL),
+             key        (newKey)
+        {
+        }
+*/
+        // copy constructor
+        RpDictEntry (const RpDictEntry<KeyType,ValType>& entry)
+        {
+            nextPtr     = entry.nextPtr;
+            tablePtr    = entry.tablePtr;
+            hash        = entry.hash;
+            clientData  = (ValType) entry.getValue();
+            key         = (KeyType) entry.getKey();
+        }
+
+    private:
+
+        // private data members
+        RpDictEntry<KeyType,ValType>*
+            nextPtr;                /* Pointer to next entry in this
+                                     * hash bucket, or NULL for end of
+                                     * chain. */
+
+        RpDict<KeyType,ValType> 
+            *tablePtr;              /* Pointer to table containing entry. */
+
+        unsigned int hash;          /* Hash value. */
+
+        ValType clientData;        /* Application stores something here
+                                     * with Tcl_SetHashValue. */
+
+        KeyType key;               /* entry key */
+
+
+
+        
+};
+
+
+template <typename KeyType, typename ValType> class RpDict
+{
+    public:
+
+        
+        // functionality for the user to access/adjust data members
+        
+        // checks table size
+        virtual const int size() const;
+
+        // insert new object into table
+        // returns 0 on success (object inserted or already exists)
+        // returns !0 on failure (object cannot be inserted or dne)
+        //
+        virtual RpDict<KeyType,ValType>& 
+                        set(    KeyType& key, 
+                                ValType& value, 
+                                int *newPtr=NULL );   
+
+        // find an RpUnits object that should exist in RpUnitsTable
+        // 
+        virtual RpDictEntry<KeyType,ValType>& 
+                        find( KeyType& key );
+
+        virtual RpDictEntry<KeyType,ValType>& operator[]( KeyType& key) 
+        { 
+            return find(key); 
+        }
+
+        // clear the entire table
+        // iterate through the table and call erase on each element
+        virtual RpDict<KeyType,ValType>& clear();
+
+        // get the nullEntry hash entry for initialization of references
+        virtual RpDictEntry<KeyType,ValType>& getNullEntry();
+
+        // template <KeyType, ValType> friend class RpDictEntry;
+        // template <KeyType, ValType> friend class RpDictIterator;
+
+        friend class RpDictEntry<KeyType, ValType>;
+        friend class RpDictIterator<KeyType, ValType>;
+
+        // default constructor
+        RpDict () 
+            : SMALL_RP_DICT_SIZE(4),
+              REBUILD_MULTIPLIER(3),
+              buckets(staticBuckets),
+              numBuckets(SMALL_RP_DICT_SIZE),
+              numEntries(0),
+              rebuildSize(SMALL_RP_DICT_SIZE*REBUILD_MULTIPLIER),
+              downShift(28),
+              mask(3)
+        { 
+
+            staticBuckets[0] = staticBuckets[1] = 0;
+            staticBuckets[2] = staticBuckets[3] = 0;
+
+            // setup a dummy entry of NULL
+            nullEntry = new RpDictEntry<KeyType,ValType>();
+
+            // std::cout << "inside RpDict Constructor" << std::endl;
+
+        }
+        
+        // copy constructor 
+        // RpDict (const RpDict& dict);
+
+        // assignment operator
+        // RpDict& operator=(const RpDict& dict);
+
+        // destructor
+        virtual ~RpDict() 
+        {
+            // probably need to delete all the entries as well
+            delete nullEntry;
+        }
+        // make sure to go through the hash table and free all RpDictEntries
+        // because the space is malloc'd in RpDict::set()
+
+
+    private:
+        const int SMALL_RP_DICT_SIZE;
+        const int REBUILD_MULTIPLIER;
+        
+        RpDictEntry<KeyType,ValType> 
+                    **buckets;        /* Pointer to bucket array.  Each
+                                       * element points to first entry in
+                                       * bucket's hash chain, or NULL. */
+        // RpDictEntry *staticBuckets[SMALL_RP_DICT_SIZE];
+        RpDictEntry<KeyType,ValType>
+                    *staticBuckets[4];
+                                      /* Bucket array used for small tables
+                                       * (to avoid mallocs and frees). */
+        int numBuckets;               /* Total number of buckets allocated
+                                       * at **bucketPtr. */
+        int numEntries;               /* Total number of entries present
+                                       * in table. */
+        int rebuildSize;              /* Enlarge table when numEntries gets
+                                       * to be this large. */
+        int downShift;                /* Shift count used in hashing
+                                       * function.  Designed to use high-
+                                       * order bits of randomized keys. */
+        int mask;                     /* Mask value used in hashing
+                                       * function. */
+        RpDictEntry<KeyType,ValType>
+                    *nullEntry;   /* if not const, compiler complains*/
+
+
+
+        // private member fxns
+
+        // static void RpDict::RebuildTable ();
+        void RebuildTable ();
+
+        unsigned int hashFxn(const void* keyPtr) const;
+        unsigned int hashFxn(std::string* keyPtr) const;
+        unsigned int hashFxn(char* keyPtr) const;
+
+        int randomIndex(unsigned int hash);
+};
+
+
+/*--------------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------*/
+
+#include "../src/RpDict.cc"
+
+#endif
Index: /trunk/include/core/RpUnits.h
===================================================================
--- /trunk/include/core/RpUnits.h	(revision 19)
+++ /trunk/include/core/RpUnits.h	(revision 19)
@@ -0,0 +1,445 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <stdlib.h>
+#include <errno.h>
+
+// #include "../include/RpDebug.h"
+#include "../include/RpDict.h"
+#include "../include/RpUnitsStd.h"
+// #include "../include/expr_eval_simple.h"
+
+#ifndef _RpUNITS_H 
+#define _RpUNITS_H
+
+class RpUnits; 
+
+class unit
+{
+
+    public:
+
+        const std::string getUnits(){ return units; };
+        double getExponent() {return exponent;};
+        RpUnits * getBasis() {return basis;};
+
+        friend class RpUnits;
+
+    private:
+        const std::string units;
+        double exponent;
+        // RpUnits* basis[4]; 
+        RpUnits* basis; 
+
+        unit* prev;
+        unit* next;
+
+        unit ( 
+                const std::string& units, 
+                double&            exponent, 
+                // RpUnits**           basis, 
+                RpUnits*           basis, 
+                unit*              next
+             )
+            :   units    (units), 
+                exponent (exponent), 
+                basis    (basis), 
+                prev     (NULL),
+                next     (next)
+            { };
+
+
+        void newExponent(double newExponent) {exponent = newExponent;};
+
+
+};
+
+// simple class to hold info about a conversion.
+// holds where we are converting from
+// holds where we are converting to
+// hold the pointer to a function to do the forward conversion (from->to)
+// hold the pointer to a function to do the backward conversion (to->from)
+// 
+class conversion
+{
+    public:
+
+        const RpUnits* getFrom()    { return (const RpUnits*) fromPtr; };
+        const RpUnits* getTo()      { return (const RpUnits*) toPtr; };
+        
+        friend class RpUnits;
+
+    private:
+
+        RpUnits* fromPtr;
+        RpUnits* toPtr;
+        double (*convForwFxnPtr)(double);
+        double (*convBackFxnPtr)(double);
+        void* (*convForwFxnPtrVoid)(void*, void*);
+        void* convForwData;
+        void* (*convBackFxnPtrVoid)(void*, void*);
+        void* convBackData;
+
+        conversion* prev;
+        conversion* next;
+
+        // constructor
+        // private because i only want RpUnits to be able to 
+        // create a conversion
+        conversion ( 
+                RpUnits* fromPtr, 
+                RpUnits* toPtr, 
+                double (*convForwFxnPtr)(double),
+                double (*convBackFxnPtr)(double),
+                conversion* prev,
+                conversion* next
+             )
+            :   fromPtr             (fromPtr),
+                toPtr               (toPtr), 
+                convForwFxnPtr      (convForwFxnPtr),
+                convBackFxnPtr      (convBackFxnPtr),
+                convForwFxnPtrVoid  (NULL),
+                convForwData        (NULL),
+                convBackFxnPtrVoid  (NULL),
+                convBackData        (NULL),
+                prev                (prev),
+                next                (next)
+            { 
+            };
+
+        conversion ( 
+                RpUnits* fromPtr, 
+                RpUnits* toPtr, 
+                void* (*convForwFxnPtrVoid)(void*, void*),
+                void* convForwData,
+                void* (*convBackFxnPtrVoid)(void*, void*),
+                void* convBackData,
+                conversion* prev,
+                conversion* next
+             )
+            :   fromPtr             (fromPtr),
+                toPtr               (toPtr), 
+                convForwFxnPtr      (NULL),
+                convBackFxnPtr      (NULL),
+                convForwFxnPtrVoid  (convForwFxnPtrVoid),
+                convForwData        (convForwData),
+                convBackFxnPtrVoid  (convBackFxnPtrVoid),
+                convBackData        (convBackData),
+                prev                (prev),
+                next                (next)
+            { 
+            };
+
+        // copy constructor
+
+        // destructor
+};
+
+// used by the RpUnits class to create a linked list of the conversions
+// associated with the specific unit.
+// 
+// we could templitize this and make a generic linked list
+// or could use generic linked list class from book programming with objects
+//
+class convEntry
+{
+
+    public:
+
+        friend class RpUnits;
+
+    private:
+
+        conversion* conv;
+        convEntry*  prev;
+        convEntry*  next;
+
+        convEntry ( 
+                conversion* conv, 
+                convEntry*  prev,
+                convEntry*  next
+             )
+            :   conv    (conv), 
+                prev    (prev),
+                next    (next)
+            { };
+
+        /*
+        ~convEntry()
+        {
+
+        }
+        */
+};
+
+class RpUnits
+{
+    /* 
+     * helpful units site
+     * http://aurora.regenstrief.org/~gunther/units.html
+     */
+
+    public:
+        
+        // users member fxns
+        std::string getUnits();
+        std::string getUnitsName();
+        double getExponent();
+        RpUnits* getBasis();
+
+        // convert from one RpUnits to another if the conversion is defined
+        double convert(RpUnits* toUnits, double val, int* result = NULL); 
+        // convert from one RpUnits to another if the conversion is defined
+        void* convert(RpUnits* toUnits, void* val, int* result = NULL); 
+        // convert from one RpUnits to another if the conversion is defined
+        double convert(std::string, double val); 
+        // convert from one RpUnits to another if the conversion is defined
+        std::string convert (   RpUnits* toUnits, 
+                                double val, 
+                                int showUnits = 0, 
+                                int* result = NULL  ); 
+
+        // dictionary to store the units.
+        // static RpDict<std::string,RpUnits> dict;
+
+        // turn the current unit to the metric system
+        // this should only be used for units that are part of the 
+        // metric system. doesnt deal with exponents, just prefixes
+        double makeBasis(double value, int* result = NULL);
+        RpUnits & makeBasis(double* value, int* result = NULL);
+        
+        static int makeMetric(RpUnits * basis);
+
+        // find an RpUnits object that should exist in RpUnitsTable
+        // returns 0 on success (object was found)
+        // returns !0 on failure (object not found)
+        static RpUnits* find(std::string key)
+        {
+            // dict.find seems to return a (RpUnits* const) so i had to 
+            // cast it as a (RpUnits*)
+
+            // dict pointer
+             // RpUnits* unitEntry = (RpUnits*) *(dict.find(key).getValue());
+             RpUnits* unitEntry = (RpUnits*) *(dict->find(key).getValue());
+
+            // RpUnits* unitEntry = (RpUnits*) dEntr.getValue();
+
+            // dict pointer
+            // if (unitEntry == (RpUnits*)dict.getNullEntry().getValue()) {
+            if (unitEntry == (RpUnits*)dict->getNullEntry().getValue()) {
+                unitEntry = NULL;
+            }
+
+            return unitEntry;
+        };
+
+        // user calls define to add a RpUnits object or to add a relation rule
+        //
+        // add RpUnits Object
+        static RpUnits * define(const std::string units, RpUnits * basis);
+        //
+        // add relation rule 
+
+        static RpUnits * define(RpUnits* from, 
+                                RpUnits* to, 
+                                double (*convForwFxnPtr)(double),
+                                double (*convBackFxnPtr)(double));
+
+        static RpUnits * define(RpUnits* from, 
+                                RpUnits* to, 
+                                void* (*convForwFxnPtr)(void*, void*),
+                                void* convForwData,
+                                void* (*convBackFxnPtr)(void*, void*),
+                                void* convBackData);
+
+        // undefining a relation rule is probably not needed 
+        // int undefine(); // delete a relation
+
+        // convert fxn will be taken care of in the RpUnitsConversion class
+        // i think
+        // int convert(const char* from, const char* to);
+
+        // why are these functions friends...
+        // probably need to find a better way to let RpUnits 
+        // use the RpDict and RpDictEntry fxns
+        friend class RpDict<std::string,RpUnits*>;
+        friend class RpDictEntry<std::string,RpUnits*>;
+
+        // copy constructor
+        RpUnits ( const RpUnits& myRpUnit )
+        { 
+
+            /*
+            from = myRpUnit.from;
+            to = myRpUnit.to;
+            convertForw = myRpUnit.convertForw;
+            convertBack = myRpUnit.convertBack;
+            */
+
+            // copy constructor for unit 
+            unit* tmp = NULL;
+            unit* newUnit = NULL;
+            unit* p = myRpUnit.head;
+
+            while (p != NULL) {
+                newUnit = new unit(p->units, p->exponent,p->basis,NULL);
+
+                newUnit->prev = tmp;
+                if (tmp) {
+                    tmp->next = newUnit;
+                }
+
+                tmp = newUnit;
+                p = p->next;
+            }
+
+            if (tmp) {
+                while (tmp->prev != NULL) {
+                   tmp = tmp->prev;
+                }
+            }
+
+            head = tmp;
+                
+        };
+
+    private:
+
+        // i hope to replace these vars with a small class representing a
+        // of a linked list of units. that way we can handle complex units.
+        // this will also require that we move the getUnits, getExponent, 
+        // and getBasis, makeBasis functionality into the smaller class,
+        // that represents each part of the units. we should keep getUnits,
+        // getBasis, and makeBasis in this class, but modify them to go
+        // through the linked list of units and combine the units back into
+        // what the caller expects to see.
+        // ie. cm2/Vms (mobility), will be split into the objects cm2, V, ms
+        // when getUnits is called, the user should see cm2/Vms again.
+        // for basis, possibly let the user choose a basis, and for makeBasis
+        // move through the linked list, only converting the metric elements.
+        //
+        
+        // used by the RpUnits when defining units elements
+        unit* head;
+
+        // linked list of units this RpUnit can convert to
+        convEntry* convList;
+
+        // used by the RpUnits when defining conversion elements
+        conversion* conv;
+
+        // dictionary to store the units.
+        // dict pointer
+        // static RpDict<std::string,RpUnits*> dict;
+        static RpDict<std::string,RpUnits*>* dict;
+
+        // create a units element
+        // class takes in three pieces of info
+        // 1) string describing the units
+        // 2) double describing the exponent
+        // 3) pointer to RpUnits object describing the basis 
+        //      of the units (the fundamental unit)
+        //
+        RpUnits ( 
+                    const std::string& units, 
+                    double& exponent, 
+                    // RpUnits* basis[] 
+                    RpUnits* basis
+                )
+            :   head        ( new unit( units, exponent, basis, NULL) ),
+                convList    (NULL),
+                conv        (NULL)
+        {};
+
+        // create a conversion element
+
+        RpUnits ( 
+                    RpUnits* from,
+                    RpUnits* to,
+                    double (*convForwFxnPtr)(double),
+                    double (*convBackFxnPtr)(double),
+                    conversion* prev,
+                    conversion* next
+                )
+            :   head (NULL),
+                convList (NULL),
+                conv (new conversion 
+                        (from,to,convForwFxnPtr,convBackFxnPtr,prev,next))
+        { 
+            connectConversion(from);
+            connectConversion(to);
+        };
+
+        RpUnits ( 
+                    RpUnits* from,
+                    RpUnits* to,
+                    void* (*convForwFxnPtr)(void*, void*),
+                    void* convForwData,
+                    void* (*convBackFxnPtr)(void*, void*),
+                    void* convBackData,
+                    conversion* prev,
+                    conversion* next
+                )
+            :   head (NULL),
+                convList (NULL),
+                conv (new conversion (  from, to,
+                                        convForwFxnPtr, convForwData,
+                                        convBackFxnPtr, convBackData,
+                                        prev, next
+                                     )
+                     )
+        { 
+            connectConversion(from);
+            connectConversion(to);
+        };
+
+        // default destructor
+        //
+        //~RpUnits ();
+        ~RpUnits ()
+        {
+            // clean up dynamic memory
+
+            unit* p = head;
+            while (p != NULL) {
+                unit* tmp = p;
+                p = p->next;
+                delete tmp;
+            }
+        }
+
+        void RpUnits::connectConversion(RpUnits* myRpUnit);
+
+        void RpUnits::fillMetricMap();
+
+        // create the container keeping track of defined units
+        // returns 0 on success (table created or already exists)
+        // returns !0 on failure (table not created or cannot exist)
+        int RpUnits::createUnitsTable();
+
+        // insert new RpUnits object into RpUnitsTable
+        // returns 0 on success (object inserted or already exists)
+        // returns !0 on failure (object cannot be inserted or dne)
+        int RpUnits::insert(std::string key);   
+
+        // link two RpUnits objects that already exist in RpUnitsTable
+        // returns 0 on success (linking within table was successful)
+        // returns !0 on failure (linking was not successful)
+        int RpUnits::link(RpUnits * unitA);
+
+
+        static int pre_compare( std::string& units, RpUnits* basis = NULL);
+        void addUnit( const std::string& units,
+                      double &  exponent,
+                      RpUnits * basis
+                     );
+
+
+};
+
+/*--------------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------*/
+
+// #include "../src/RpUnits.cc"
+
+#endif
Index: /trunk/include/core/RpUnitsStd.h
===================================================================
--- /trunk/include/core/RpUnitsStd.h	(revision 19)
+++ /trunk/include/core/RpUnitsStd.h	(revision 19)
@@ -0,0 +1,48 @@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+double centi2base   (double centi);
+double milli2base   (double milli);
+double micro2base   (double micro);
+double nano2base    (double nano);
+double pico2base    (double pico);
+double femto2base   (double femto);
+double atto2base    (double atto);
+double kilo2base    (double kilo);
+double mega2base    (double mega);
+double giga2base    (double giga);
+double tera2base    (double tera);
+double peta2base    (double peta);
+
+
+double base2centi   (double base);
+double base2milli   (double base);
+double base2micro   (double base);
+double base2nano    (double base);
+double base2pico    (double base);
+double base2femto   (double base);
+double base2atto    (double base);
+double base2kilo    (double base);
+double base2mega    (double base);
+double base2giga    (double base);
+double base2tera    (double base);
+double base2peta    (double base);
+
+
+
+double angstrom2meter (double angstrom);
+double meter2angstrom (double meters);
+
+
+
+double fahrenheit2centigrade (double F);
+double centigrade2fahrenheit (double C);
+double centigrade2kelvin (double C);
+double kelvin2centigrade (double K);
+
+
+#ifdef __cplusplus
+}
+#endif
