// ********** BrigdeDemo.cpp
#include <iostream>
#include <time.h>
using namespace std;

// Interface Hierarchy
class AbstractionIF { public: virtual void x() {} };
class SpecializedAbstractionAIF : public AbstractionIF { public: virtual void a() {} };
class SpecializedAbstractionBIF : public AbstractionIF { public: virtual void b() {} };

// Abstraction Hierarchy
class Abstraction {
  private:
    AbstractionIF* absIF;
  protected: AbstractionIF* getAbstraction() { return absIF; }
  public:
    Abstraction(AbstractionIF* absIF) { this->absIF = absIF; }
    void x() { absIF->x(); }
     
};
class SpecializedAbstractionA : public Abstraction {
  public:
    SpecializedAbstractionA(SpecializedAbstractionAIF* specAbsAIF):Abstraction(specAbsAIF){}
    void a() { 
      SpecializedAbstractionAIF* specAbsAIF = 
        dynamic_cast<SpecializedAbstractionAIF *>(getAbstraction()); 
      specAbsAIF->a();
     }
};
class SpecializedAbstractionB : public Abstraction {
  public:
    SpecializedAbstractionB(SpecializedAbstractionBIF* specAbsBIF):Abstraction(specAbsBIF){}
    void b() { 
      SpecializedAbstractionBIF* specAbsBIF = 
        dynamic_cast<SpecializedAbstractionBIF *>(getAbstraction()); 
      specAbsBIF->b();
     }
};

// Implementation Hierarchy 1
class AbstractionImpl1 : public AbstractionIF { public: void x() {} };
class SpecializedImplA1 : public AbstractionImpl1, public SpecializedAbstractionAIF { public: void a() {} };
class SpecializedImplB1 : public AbstractionImpl1, public SpecializedAbstractionBIF { public: void b() {} };

// Implementation Hierarchy 2
class AbstractionImpl2 : public AbstractionIF { public: void x() {} };
class SpecializedImplA2 : public AbstractionImpl2, public SpecializedAbstractionAIF { public: void a() {} };
class SpecializedImplB2 : public AbstractionImpl2, public SpecializedAbstractionBIF { public: void b() {} };

const int MAX = 100000;
int main() {
  hrtime_t t1 = gethrtime();
  for (int i=0; i<MAX; i++) {
    // using Impl1 Hierarchy
    Abstraction* abs = new Abstraction(new AbstractionImpl1());
    abs->x();
    SpecializedAbstractionA* specAbsA = new SpecializedAbstractionA(new SpecializedImplA1());
    specAbsA->x();
    specAbsA->a();
    SpecializedAbstractionB* specAbsB = new SpecializedAbstractionB(new SpecializedImplB1());
    specAbsB->x();
    specAbsB->b();
    // using Impl2 Hierarchy
    abs = new Abstraction(new AbstractionImpl2());
    abs->x();
    specAbsA = new SpecializedAbstractionA(new SpecializedImplA2());
    specAbsA->x();
    specAbsA->a();
    specAbsB = new SpecializedAbstractionB(new SpecializedImplB2());
    specAbsB->x();
    specAbsB->b();
   } 
  hrtime_t t2 = gethrtime();
  cout << (t2-t1)/1000000 << " ";
  return 1;
}