simBase.h

Go to the documentation of this file.

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

//simBase.h


#ifndef __SIMIAN_BASE_DOT_H
#define __SIMIAN_BASE_DOT_H

#include <string>
#include <iostream>

typedef std::string SNameType;

/////////////////////////////////////////////////////////////////////////////
/// SimBase, base object for simianlib.
///   Provides some basic functionality and a common base class for all
///   simian objects.
/////////////////////////////////////////////////////////////////////////////
class SimBase {
public:
   SimBase():_name_(),_changed(0) {}
   virtual ~SimBase(){}

   ////////////////////////////////////////////////////
   ///@name Text object-name 
   ///  from SimBase
   /// 
   ///@{
   std::string getObjName() {return std::string(typeid(*this).name());}
   std::string getName() {return _name_;}
   void        setName(std::string name) {_name_ = name;}
   void        setName(const char *name) {if(name) _name_ = name;}
   ///@}
   ////////////////////////////////////////////////////

   ////////////////////////////////////////////////////
   ///@name Debug prints 
   ///  from SimBase:
   ///  These print the object name with the error, mostly for
   ///  convenience, but they are compiled to inline-no-op if you
   ///  build in release mode
   ///@{
   inline
      void derr(const char *when, const char *where=0) const;
   template<class T>
      void derr(const char *when, const char *where, const T stuff) const;
   ///@}
   ////////////////////////////////////////////////////

   ///////////////////////////////////////////////////
   ///@name Modification, AKA "changed" 
   ///  from SimBase:
   ///  id based, you can capture the current id for 
   ///  comparison later, if the id's don't match the 
   ///  class has been changed
   ///@{
   virtual int  getChangeID()               {return _changed;}
   virtual int  getChangeID() const         {return _changed;}
   virtual void setChanged()                {++_changed;}
   ///@}
   ////////////////////////////////////////////////////

   ///////////////////////////////////////////////////
   ///@name Serialization: 
   ///   from SimBase
   ///   You MUST override these pure
   ///   virtual functions, they "should" do something
   ///   usefull.  It is also nice if you declare a 
   ///   static std::istream &create(std::istream &is) const;
   ///   function, to create a class from a stream. This is
   ///   done on a per-concrete class basis. 
   ///
   ///  These aren't pure virutal yet, but will be soon!
   ///@{

   /// serialize
   virtual std::ostream &saveSelf(std::ostream &os) { return os;}
   /// unserialize
   virtual std::istream &readSelf(std::istream &is) { return is;}

   ///@}
   ////////////////////////////////////////////////////

protected:
   /// a text name for the object, SimBase
   std::string _name_; 
   /// change id, incremented whenever setChanged is called, SimBase
   int _changed;       
};

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Implementation
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

inline
void SimBase::derr(const char *when, const char *where) const
{
   /// only prints in debug mode, -D_DEBUG
#ifdef _DEBUG
   std::cerr << "Simain::" << typeid(*this).name() << "::";
   if(!_name_.empty())
      std::cerr << _name_;
   std::cerr << std::endl;
   std::cerr << "     " << when;
   if(where)
      std::cerr << " " << where;
   std::cerr << std::endl;
#endif
}

template<class T>
inline
void SimBase::derr(const char *when, const char *where, const T stuff) const
{
   /// only prints in debug mode, -D_DEBUG
#ifdef _DEBUG
   std::cerr << "Simain::" << typeid(*this).name() << "::";
   if(!_name_.empty())
      std::cerr << _name_;
   std::cerr << std::endl;
   std::cerr << "     " << when;
   if(where)
      std::cerr << " - " << where;
   std::cerr << stuff;
   std::cerr << std::endl;
#endif
}

#endif

---

Send questions, comments, and bug reports to: