---

general/STypeInfo.h

Go to the documentation of this file.

/* #start# ***********************************************************

           Scheduling Simulator
        Lehrstuhl f"ur Effiziente Algorithmen
           Technische Universit"at M"unchen

 File    : $Id: STypeInfo.h,v 1.4 2003/01/08 18:57:12 meierb Exp $

 Purpose : A small typechecking-system for the classes which are part of the
           general classification scheme.
     To use it inherit from STypeInfo and include one of the macros
     TYPEINFO0,1,2 or 3 -- depending on the number of classes from which
     you are subclassing -- as the first statement in the class 
     declaration.
     Include TYPEINFOVAR in the corresponding .cpp file.

 RCS-Log:
 $Log: STypeInfo.h,v $
 Revision 1.4  2003/01/08 18:57:12  meierb
 added randomized release times

 Revision 1.1.1.1  2002/12/02 22:26:19  meierb
 my_schedule

 Revision 1.2  2002/11/09 02:51:03  taeubig
 Replaced <iostream.h> header inclusion by <iostream>, cerr by std::cerr...

 Revision 1.1  2002/08/29 12:59:58  taeubig
 Added the sources

 Revision 1.8  2000/05/24 12:28:51  taeubig
 New compiler (gcc-2.95) and new Qt (2.1)
 Replaced "list" by "leda_list" etc.

 Revision 1.7  2000/01/11 17:26:15  zoidl
 added javadoc comments

 Revision 1.6  1999/03/30 12:13:39  schickin
 dynamic_cast added, constructors for task system classes added

 Revision 1.5  1999/03/19 16:45:09  hall
 nc

 Revision 1.4  1999/02/10 15:53:31  hall
 TypeInfo, Observer works


 * #end# ************************************************************* */

#ifndef STYPEINFO_H
#define STYPEINFO_H

// system header files
#include <iostream>
#include <cmath>

#include <LEDA/list.h>
#include <LEDA/string.h>

// project header files
#include "SUtil.h"

// -----------------------------------------------------------------------
class STypeInfo {
public:
  
  virtual leda_string getClassifier() const =0;
  
  virtual bool isInstanceOf(const leda_string &classifier) const =0;
  
  virtual void assureInstanceOf(const leda_string &classifier) const =0;
};
// -----------------------------------------------------------------------

// -----------------------------------------------------------------------
#define TYPEINFOSTART       \
private:          \
  static bool _validAncesAndSelf;   \
  static leda_list<leda_string> _ancesAndSelf;  \
public:           \
  static const leda_list<leda_string> &getTypeInfo() {  \
    if( _validAncesAndSelf )      \
      return _ancesAndSelf;     \
                \
    leda_list<leda_string> l;

// -----------------------------------------------------------------------
#undef dbgOn
#define dbgOn false
#define TYPEINFOEND(theName, theClassifier)           \
    _ancesAndSelf.sort();             \
    _ancesAndSelf.unique();             \
    _ancesAndSelf.append(theClassifier);          \
    dbgVar("ancesAndSelf", _ancesAndSelf);                                      \
    _validAncesAndSelf = true;                                                  \
    return _ancesAndSelf;             \
  };                    \
  virtual leda_string getClassifier() const { return theClassifier; };          \
  virtual bool isInstanceOf(const leda_string &classifier) const {              \
    return ( NULL != theName::getTypeInfo().search(classifier) );   \
  };                    \
  virtual void assureInstanceOf(const leda_string &classifier) const {    \
    if( !isInstanceOf(classifier) ) {                                           \
      std::cerr << "You tried to use an object of the class \""           \
           << theClassifier << "\" as an instance of the \"" << classifier  \
     << "\" class" << std::endl;                                          \
      std::cerr << "A cast isn't possible here!" << std::endl                   \
     << "This object is an instance of:" << std::endl                     \
     << theName::getTypeInfo() << std::endl;              \
      exit(1);                  \
    }                   \
  }
// -----------------------------------------------------------------------
#define TYPEINFO0(theName, theClassifier) \
  TYPEINFOSTART         \
  TYPEINFOEND(theName, theClassifier)

#define TYPEINFO1(theName, theClassifier, theSuper1)  \
  TYPEINFOSTART           \
    l = theSuper1::getTypeInfo();     \
    _ancesAndSelf.conc(l);        \
  TYPEINFOEND(theName, theClassifier)

#define TYPEINFO2(theName, theClassifier, theSuper1, theSuper2) \
  TYPEINFOSTART             \
    l = theSuper1::getTypeInfo();       \
    _ancesAndSelf.conc(l);          \
    l = theSuper2::getTypeInfo();       \
    _ancesAndSelf.conc(l);          \
  TYPEINFOEND(theName, theClassifier)

#define TYPEINFO3(theName, theClassifier, theSuper1, theSuper2, theSuper3)  \
  TYPEINFOSTART                 \
    l = theSuper1::getTypeInfo();           \
    _ancesAndSelf.conc(l);              \
    l = theSuper2::getTypeInfo();           \
    _ancesAndSelf.conc(l);              \
    l = theSuper3::getTypeInfo();           \
    _ancesAndSelf.conc(l);              \
  TYPEINFOEND(theName, theClassifier)
  
// -----------------------------------------------------------------------
#define TYPEINFOVAR(theName)      \
  bool theName::_validAncesAndSelf = false; \
  leda_list<leda_string> theName::_ancesAndSelf;
  
// -----------------------------------------------------------------------

#endif //STYPEINFO_H

---