source/opdispatchcase.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <iostream>
  20
  21 #include "/home/rt/tidefelt/include/refcount.h"
  22
  23 using namespace std;
  24
  25 class Value;
  26 class A;
  27 class B;
  28 class C;
  29
  30 /* The closest to the one level recursion needed is to start from two sets of symmetric macros.
  31  * One set ends in "1", the other ends in "2".
  32  */
  33
  34 /* Define the class heierarcy in macros:
  35  */
  36 #define CLASSTREE1_A( Ma, S, Mb ) Ma( S, Mb, A )
  37 #define CLASSTREE1_B( Ma, S, Mb ) Ma( S, Mb, B ) CLASSTREE1_C( Ma, S, Mb )
  38 #define CLASSTREE1_C( Ma, S, Mb ) Ma( S, Mb, C )
  39 #define CLASSTREE1_ROOT( Ma, S, Mb ) \
  40         CLASSTREE1_A( Ma, S, Mb )\
  41         CLASSTREE1_B( Ma, S, Mb )
  42
  43 #define CLASSTREE2_A( Ma, S, Mb ) Ma( S, Mb, A )
  44 #define CLASSTREE2_B( Ma, S, Mb ) Ma( S, Mb, B ) CLASSTREE2_C( Ma, S, Mb )
  45 #define CLASSTREE2_C( Ma, S, Mb ) Ma( S, Mb, C )
  46 #define CLASSTREE2_ROOT( Ma, S, Mb ) \
  47         CLASSTREE2_A( Ma, S, Mb )\
  48         CLASSTREE2_B( Ma, S, Mb )
  49
  50
  51
  52 /* Define convenient macros for looping.
  53  */
  54 #define SINGLELOOP1_( Sb, M, T ) M( T )
  55 #define SINGLELOOP1( Sa, M ) Sa( SINGLELOOP1_,, M )
  56 #define DOUBLELOOP1__( M, Ta, Tb ) M( Ta, Tb )
  57 #define DOUBLELOOP1_( Sb, M, Ta ) Sb( DOUBLELOOP1__, M, Ta )
  58 #define DOUBLELOOP1( Sa, Sb, M ) Sa( DOUBLELOOP1_, Sb, M )
  59
  60 #define SINGLELOOP2_( Sb, M, T ) M( T )
  61 #define SINGLELOOP2( Sa, M ) Sa( SINGLELOOP2_,, M )
  62 #define DOUBLELOOP2__( M, Ta, Tb ) M( Ta, Tb )
  63 #define DOUBLELOOP2_( Sb, M, Ta ) Sb( DOUBLELOOP2__, M, Ta )
  64 #define DOUBLELOOP2( Sa, Sb, M ) Sa( DOUBLELOOP2_, Sb, M )
  65
  66 /* Define a macro that only uses the first argument,
  67  * resulting in a macro that calls another macro for each class.
  68  */
  69 #define FORALLCLASSESM( M ) SINGLELOOP1( CLASSTREE1_ROOT, M )
  70
  71 /* Define a macro that calls another macro with a given first argument,
  72  * varying the second argument over all classes.
  73  */
  74 #define FORALLCLASSESMT( M, T ) CLASSTREE2_ROOT( DOUBLELOOP2__, M, T )
  75
  76 /* Use the two looping macros above in a nested manner to produce a default method
  77  * for each pair combination of classes.
  78  */
  79 #define DEFAULTOP__( Ta, Tb ) virtual int op( RefCountPtr< const Ta > x1, RefCountPtr< const Tb > x2 ) const { return 0; }
  80 #define DEFAULTOP_( Ta ) FORALLCLASSESMT( DEFAULTOP__, Ta )
  81 #define DEFAULTOP FORALLCLASSESM( DEFAULTOP_ )
  82
  83 /* Define a macro for hiding the default method for a set of classes:
  84  */
  85 #define HIDEDEFAULT_( Ta, Tb ) virtual int op( Ta * v1, Tb * v2 ) const { return 0; }
  86 #define HIDEDEFAULT( Sa, Sb ) DOUBLELOOP2( Sa, Sb, HIDEDEFAULT_ )
  87
  88 /* Define a macro for hiding the default method for a set of classes:
  89  */
  90 #define CALLIMPL_( Ta, Tb )     virtual int op( RefCountPtr< const Ta > x1, RefCountPtr< const Tb > x2 ) const { return impl( x1.getPtr( ), x1, x2.getPtr( ), x2 ); }
  91 #define CALLIMPL( Sa, Sb ) DOUBLELOOP2( Sa, Sb, CALLIMPL_ )
  92
  93 class BinOp
  94 {
  95 public:
  96         int call( RefCountPtr< const Value > v1, RefCountPtr< const Value > v2 ) const;
  97         DEFAULTOP;
  98 };
  99
 100 #define DISPATCH1NULLDECL_ virtual int dispatch1( RefCountPtr< const Value > self, RefCountPtr< const Value > other, const BinOp * op ) const = 0;
 101 #define DISPATCH2NULLDECL_( Ts, To ) virtual int dispatch2( RefCountPtr< const To > other, RefCountPtr< const Value > self, const BinOp * op ) const = 0;
 102
 103 #define DISPATCHCASE_LEVEL2( T2 )\
 104         case TYPEID_ ## T2 :                                                             \
 105         {\
 106                 RefCountPtr< const T2 > arg2 = other.down_cast< const T2 >( );                          \
 107                 if( arg2 == NullPtr< const T2 >( ) )                                                                                                                            \
 108                         {\
 109                                 throw Exceptions::InternalError( "Downcast in dispatch level 2 failed, " #T2 ); \
 110                         }\
 111                 return op->op( arg1, arg2 );                            \
 112         }\
 113         break;
 114
 115 #define DISPATCHCASE_LEVEL1( T1 )\
 116         case TYPEID_ ## T1 :                                                             \
 117         {\
 118                 RefCountPtr< const T1 > arg1 = self.down_cast< const T1 >( );                           \
 119                 if( arg1 == NullPtr< const T1 >( ) )                                                                                                                            \
 120                         {\
 121                                 throw Exceptions::InternalError( "Downcast in dispatch level 1 failed, " #T1 ); \
 122                         }\
 123                 switch( other->getTypeID( ) )                                                           \
 124                         {                                                                                                                                                                                                                                                                                               \
 125                                 SINGLELOOP2( CLASSTREE2_ROOT, DISPATCHCASE_LEVEL2 );                                                            \
 126                         default:                                                                                                                                                                                                                                                                \
 127                                 throw Exceptions::InternalError( "QuickTypeID out of range in dispatch level 2" ); \
 128                         }                                                                                                                                                                                                                                                                                               \
 129         }\
 130         break;
 131
 132 #define DISPATCHCASEDECL static int dispatch1( RefCountPtr< const Value > self, RefCountPtr< const Value > other, const BinOp * op )
 133 #define DISPATCHCASEIMPL \
 134 int Value::dispatch1( RefCountPtr< const Value > self, RefCountPtr< const Value > other, const BinOp * op )\
 135 {\
 136         switch( self->getTypeID( ) )\
 137                 {\
 138                         SINGLELOOP1( CLASSTREE1_ROOT, DISPATCHCASE_LEVEL1 );                                                            \
 139                 default:\
 140                         throw Exceptions::InternalError( "QuickTypeID out of range in dispatch level 1" ); \
 141                 }\
 142 }
 143
 144 #define DISPATCHNULLDECL DISPATCHCASEDECL
 145 /*DISPATCH1NULLDECL_ FORALLCLASSESMT( DISPATCH2NULLDECL_, )*/
 146
 147 #define MAKE_TYPEID( T ) TYPEID_ ## T ,
 148 enum QuickTypeID
 149         { SINGLELOOP1( CLASSTREE1_ROOT, MAKE_TYPEID )
 150                 NUMBER_OF_TYPEID };
 151
 152 class Value
 153 {
 154 public:
 155         virtual QuickTypeID getTypeID( ) const = 0;
 156         DISPATCHNULLDECL;
 157 };
 158
 159 DISPATCHCASEIMPL;
 160
 161 int
 162 BinOp::call( RefCountPtr< const Value > v1, RefCountPtr< const Value > v2 ) const
 163 {
 164         return v1->dispatch1( v1, v2, this );
 165 }
 166
 167 #define DISPATCH1DECL_ virtual int dispatch1( RefCountPtr< const Value > self, RefCountPtr< const Value > other, const BinOp * op ) const;
 168 #define DISPATCH1IMPL_( Ts ) \
 169 int Ts::dispatch1( RefCountPtr< const Value > self, RefCountPtr< const Value > other, const BinOp * op ) const                          \
 170         {\
 171                 RefCountPtr< const Ts > typedSelf = self.down_cast< const Ts >( );                              \
 172                 if( typedSelf == NullPtr< const Ts >( ) )                                                                                                                               \
 173                         {\
 174                                 cerr << "Downcast in dispatch1 failed" << endl ;\
 175                         }\
 176                 return other->dispatch2( typedSelf, other, op );\
 177         }\
 178
 179 #define DISPATCH2DECL_( Ts, To ) virtual int dispatch2( RefCountPtr< const To > other, RefCountPtr< const Value > self, const BinOp * op ) const;
 180 #define DISPATCH2IMPL_( Ts, To ) \
 181 int Ts::dispatch2( RefCountPtr< const To > other, RefCountPtr< const Value > self, const BinOp * op ) const\
 182         {\
 183                 RefCountPtr< const Ts > typedSelf = self.down_cast< const Ts >( );                              \
 184                 if( typedSelf == NullPtr< const Ts >( ) )                                                                                                                               \
 185                         {\
 186                                 cerr << "Downcast in dispatch1 failed" << endl ;\
 187                         }\
 188                 return op->op( other, typedSelf );\
 189         }
 190
 191 #define GETTYPEIDDECL virtual QuickTypeID getTypeID( ) const;
 192
 193 #define DISPATCHDECL GETTYPEIDDECL
 194 /* DISPATCH1DECL_ FORALLCLASSESMT( DISPATCH2DECL_, )*/
 195 #define DISPATCHIMPL( Ts )
 196 /* DISPATCH1IMPL_( Ts ) FORALLCLASSESMT( DISPATCH2IMPL_, Ts )*/
 197
 198 class A : public Value
 199 {
 200 public:
 201         DISPATCHDECL;
 202 };
 203
 204 class B : public Value
 205 {
 206 public:
 207         DISPATCHDECL;
 208 };
 209
 210 class C : public B
 211 {
 212 public:
 213         DISPATCHDECL;
 214 };
 215
 216 DISPATCHIMPL( A );
 217 DISPATCHIMPL( B );
 218 DISPATCHIMPL( C );
 219
 220 #define DUMMYANDREF( T ) T *, RefCountPtr< T >
 221
 222 class Plus : public BinOp
 223 {
 224 public:
 225         CALLIMPL( CLASSTREE1_B, CLASSTREE2_A )
 226 private:
 227         int impl( DUMMYANDREF( const B ) v1, DUMMYANDREF( const A ) v2 ) const { return 1; }
 228         int impl( DUMMYANDREF( const C ) v1, DUMMYANDREF( const A ) v2 ) const { return 2; }
 229 };
 230
 231 class Star : public BinOp
 232 {
 233 public:
 234         CALLIMPL( CLASSTREE1_B, CLASSTREE2_B )
 235         CALLIMPL( CLASSTREE1_A, CLASSTREE2_B )
 236 private:
 237         int impl( DUMMYANDREF( const B ) v1, DUMMYANDREF( const B ) v2 ) const { return 1; }
 238         int impl( DUMMYANDREF( const A ) v1, DUMMYANDREF( const B ) v2 ) const { return 7; }
 239 };
 240
 241 #define GETTYPEID_MAKER( T ) \
 242 QuickTypeID \
 243 T::getTypeID( ) const \
 244 {\
 245         return TYPEID_ ## T; \
 246 }
 247
 248 SINGLELOOP1( CLASSTREE1_ROOT, GETTYPEID_MAKER )
 249
 250 int
 251 main( )
 252 {
 253         RefCountPtr< A > a;
 254         RefCountPtr< B > b;
 255         RefCountPtr< C > c;
 256         {
 257                 Plus op;
 258                 const char opstr[] = "+";
 259                 cout << "A" << opstr << "A => " << op.call( a, a ) << endl ;
 260                 cout << "A" << opstr << "B => " << op.call( a, b ) << endl ;
 261                 cout << "A" << opstr << "C => " << op.call( a, c ) << endl ;
 262                 cout << "B" << opstr << "A => " << op.call( b, a ) << endl ;
 263                 cout << "B" << opstr << "B => " << op.call( b, b ) << endl ;
 264                 cout << "B" << opstr << "C => " << op.call( b, c ) << endl ;
 265                 cout << "C" << opstr << "A => " << op.call( c, a ) << endl ;
 266                 cout << "C" << opstr << "B => " << op.call( c, b ) << endl ;
 267                 cout << "C" << opstr << "C => " << op.call( c, c ) << endl ;
 268         }
 269         cout << endl ;
 270         {
 271                 Star op;
 272                 const char opstr[] = "*";
 273                 cout << "A" << opstr << "A => " << op.call( a, a ) << endl ;
 274                 cout << "A" << opstr << "B => " << op.call( a, b ) << endl ;
 275                 cout << "A" << opstr << "C => " << op.call( a, c ) << endl ;
 276                 cout << "B" << opstr << "A => " << op.call( b, a ) << endl ;
 277                 cout << "B" << opstr << "B => " << op.call( b, b ) << endl ;
 278                 cout << "B" << opstr << "C => " << op.call( b, c ) << endl ;
 279                 cout << "C" << opstr << "A => " << op.call( c, a ) << endl ;
 280                 cout << "C" << opstr << "B => " << op.call( c, b ) << endl ;
 281                 cout << "C" << opstr << "C => " << op.call( c, c ) << endl ;
 282         }
 283         return 0;
 284 }