Keys.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     3-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

///Keys.h

/// things you need to know about to play.

#ifndef __GRINDER_KEYS_DOT_H
#define __GRINDER_KEYS_DOT_H

#include <simBase/simBase.h>
#include <string>
#include <map>
#include <limits>
#include <mathGutz.h>
#include <smartptr.h>

/// key "name" type for grinder,
/// the type of object used for indexing into a
/// keyMap
typedef std::string GKeyType;

/// the key map compare
struct __KeyMapCmp__
{
   bool operator()(const GKeyType &k1 , const GKeyType &k2) const
   {
      return (k1 < k1);
   }
};

/// forward decl
struct KeyPair;

///////////////////////////////////////
/// a single key
///   use a std::numeric_limits<double>::quiet_NaN()
///   to indicate that a value is unused. also declared
///   in Key. Not really designed for speed :(
class Key : 
   public SimBase, 
   public gutz::Counted 
{
public:
   /// the key map
   typedef gutz::SmartPtr<Key> KeySP;
   typedef std::map<GKeyType, KeySP, __KeyMapCmp__> KeySPMap;
   typedef KeySPMap::iterator                       KeySPMapIter;

   Key();
   Key(const std::string &name, int type, const KeyPair *subKeys=0, int nSubKeys=0);
   virtual ~Key();

   /// the key's name isn't the same as it's index into 
   ///   the key map.
   std::string getName() const           {return _name;}
   void        setName(std::string name) {_name = name;}

   /// text, may not always be valid
   std::string getText() const           {return _text;}
   void        setText(std::string text) {_text = text;}

   /// feel free to invent your own types, start after
   ///  KEY_LAST
   enum KEY_TYPES {
      UNKNOWN   = 0,
      DEFINE    = 1<<0,
      VALUE     = 1<<1,
      VARIABLE  = 1<<2,
      CONSTANT  = 1<<3,
      FUNCTION  = 1<<4,
      SCOPE     = 1<<5,
      KEY_LAST  = 1<<6
   };
   
   int  getType() const   {return _type;}
   void setType(int type) {_type = type;}

   /// data type for double 4 vectors
   typedef gutz::vec4d DVEC_TYPE; 
   const DVEC_TYPE DVEC_UNUSED;  /// for comparisons

   virtual DVEC_TYPE getDVec() const       {return _dv;}
   virtual void      setDVec(DVEC_TYPE vec){_dv = vec; }

   /// data type for integral 4 vectors
   typedef gutz::vec4i IVEC_TYPE;
   const IVEC_TYPE  IVEC_UNUSED; /// for comparisons

   virtual IVEC_TYPE getIVec() const       {return _iv;}
   virtual void      setIVec(IVEC_TYPE vec){_iv = vec; }

   /// these accessors will be null if there was an error,
   /// or un-found key, ie. retKey.isNull() == true
   /// a key may have sub keys, get them...
   KeySPMap getAllKeys() const {return _keys;}
   /// get a specific key, returns Null key if not found
   KeySP    getKey(const GKeyType kn) const;
   /// set a specific key, returns Null if key not found
   KeySP    setKey(const GKeyType kn, const KeySP key);
   /// add a key
   KeySP    addKey(const GKeyType kn, const KeySP key);
   KeySP    addKey(const KeyPair kp);
   /// delete a key, returns Null if key not found
   KeySP    delKey(const GKeyType kn);
   /// test if a key exists
   bool     hasKey(const GKeyType kn) const;

   /// operators, used for felt and sudo compiling
   int   getOp() const { return _op; }
   void  setOp(int op) { _op = op; }

   /// size of subKey map
   int   size() { return int(_keys.size()); }

protected:
   std::string _name;
   std::string _text;
   int         _type;
   int         _op;
   KeySPMap    _keys;

   DVEC_TYPE    _dv;
   IVEC_TYPE    _iv;
   
};

/// declared externally for convenience
typedef Key::KeySP         KeySP;
typedef Key::KeySPMap      KeySPMap;
typedef Key::KeySPMapIter  KeySPMapIter;

/// key-name key pairs
struct KeyPair {
   KeyPair(const GKeyType keyName, const Key theKey)
      : kn(keyName), key(theKey) {}
   GKeyType kn;  /// key name
   Key      key; /// key
};

#endif

---

Send questions, comments, and bug reports to: