release: 1.1.1

[lilypond.git] / flower / include / virtual-methods.hh

diff --git a/flower/include/virtual-methods.hh b/flower/include/virtual-methods.hh
index 39795ce1158a86a1f5184885ce7e01506cfa2768..909267165b01ae9d6c801393af0c6f998cef1d83 100644 (file)
--- a/flower/include/virtual-methods.hh
+++ b/flower/include/virtual-methods.hh
@@ -10,6 +10,7 @@
 #ifndef VIRTUAL_METHODS_HH
 #define VIRTUAL_METHODS_HH
 
+#include <typeinfo>
 #include "stdlib.h"            // size_t
 
 /**  Declare the classes name as a static and virtual function.
@@ -17,49 +18,79 @@
   s->name() != S::static_name (). Overlapping strings need not be merged in C++
  */
 #define DECLARE_MY_RUNTIME_TYPEINFO    \
-static bool static_is_type_b (const char*s);\
-virtual bool is_type_b (const char *s) const { return static_is_type_b (s); } \
-virtual char const *name() const{ return static_name (); } \
-virtual size_t class_size () const { return static_class_size (); }\
-static size_t static_class_size (); \
+virtual char const *name() const{ return static_name (); }\
 static char const *static_name()
 
-#define IMPLEMENT_STATIC_NAME(c)\
-    char const *c::static_name() { return #c; } \
-    size_t c::static_class_size () { return sizeof (c); }
 
+#if 0
+  /*
+    oops.  before() has nothing to do with inheritance
+   */
+inline bool operator > (type_info const &a1, type_info const &a2)
+{
+  return a2.before (a1);
+}
 
+inline bool operator < (type_info const &a1, type_info const &a2)
+{
+  return a1.before (a2);
+}
 
-#define VIRTUAL_COPY_CONS(T, R)\
-  virtual R *clone() const { return  new T(*this); } \
-  int  yet_another_stupid_function_to_allow_semicolon()
+inline bool operator <= (type_info const &a1, type_info const &a2)
+{
+  return a1 == a2 ||  a1 < a2;
+}
+
+inline bool operator >= (type_info const &a1, type_info const &a2)
+{
+  return a1 == a2 ||  a1 > a2;
+}
+#endif
+
+#define IMPLEMENT_STATIC_NAME(c)\
+    char const *c::static_name() { return #c; }
+
+     /*
+    size_t c::static_class_size () { return sizeof (c); }
+    */
 
+#define VIRTUAL_COPY_CONS(T, R)\
+  virtual R *clone() const { return  new T(*this); } 
 
 #define DECLARE_VIRTUAL_COPY_CONS(T, R)\
       virtual R *clone() const
+
 #define IMPLEMENT_VIRTUAL_COPY_CONS(T, R)\
        R *T::clone() const { return  new T(*this); }\
 
     
 #define IMPLEMENT_IS_TYPE_B(D)\
-  IMPLEMENT_STATIC_NAME(D)\
+  IMPLEMENT_STATIC_NAME(D)
+
+/*
   bool D::static_is_type_b (const char *s)\
 {\
   return s == static_name();\
-}
+}*/
 
 #define IMPLEMENT_IS_TYPE_B1(D, B)\
-  IMPLEMENT_STATIC_NAME(D)\
+  IMPLEMENT_STATIC_NAME(D)
+/*
   bool D::static_is_type_b (const char *s)\
 {\
   return s == static_name() || B::static_is_type_b (s);\
 }
+*/
 
 #define IMPLEMENT_IS_TYPE_B2(D, BA, BB)\
-  IMPLEMENT_STATIC_NAME(D)\
+  IMPLEMENT_STATIC_NAME(D)
+
+/*
+     
   bool D::static_is_type_b (const char *s)\
 {\
   return s == static_name() || BA::static_is_type_b (s) || BB::static_is_type_b (s);\
 }
+*/
 
 #endif