// Purpose.  Bridge                     class DateImp;
//
// Discussion.  Even though Date has    class Date {
// a clean interface and a well encap-  public:
// sulated implementation, the client      Date( int y, int m, int d );
// still has to recompile if the class     ~Date();
// architect changes his/her mind.         void output();
// Instead, create a wrapper (or inter-    static void setImp( char* t ) {
// face) class that contains and dele-        strcpy( impType_, t ); }
// gates to a body (or implementation)  private:
// class.  Client can now specify at       DateImp*    rep_;
// run-time exactly what s/he wants.       static char impType_[10];
                                        };
#include <iostream.h>                   char Date::impType_[] = "Ok";
#include <stdio.h>
                                        class DateImp { public:
class Date {                               virtual void output() = 0;
                                        };
public:
   Date( int y, int m, int d );         class DateOk : public DateImp {
   void output();                       public:
                                           DateOk( int y, int m, int d );
private:                                   void output();
                                        private:
#ifdef OK                                  int  year_, month_, day_;
   int  year_, month_, day_;            };
#endif
                                        class DateAA : public DateImp {
#ifdef AA                               public:
   int        toJulian(int,int,int);       DateAA( int y, int m, int d );
   char*      fromJulian(void);            void output();
   int        julian_;                  private:
   int        year_;                       int        toJulian(int,int,int);
   static int dayTable_[2][13];            char*      fromJulian(void);
#endif                                     int        julian_;
                                           int        year_;
};                                         static int dayTable_[2][13];
                                        };
#ifdef OK
void Date::output() {                   Date::Date( int y, int m, int d ) {
   char buf[20];                           if ( ! strcmp( impType_, "Ok" ))
   int year = year_ - (year_/100*100);        rep_ = new DateOk( y, m, d );
   sprintf( buf, "%02d%02d%02d",           else
      year, month_, day_ );                   rep_ = new DateAA( y, m, d );
   cout << buf << "  "; }               }
#endif                                  Date::~Date()       { delete rep_; }
                                        void Date::output() { rep_->output(); }
#ifdef AA
void Date::output() {                   #include "bridge2.inc"
   cout << fromJulian() << "  "; }
#endif                                  void main( void )
                                        {
#include "bridge1.inc"                     Date  d1( 1996, 2, 29 );
                                           Date  d2( 1996, 2, 30 );
void main( void )                          Date::setImp( "AA" );
{                                          Date  d3( 1996, 2, 29 );
   Date  d1( 1996, 2, 29 );                Date  d4( 1996, 2, 30 );
   Date  d2( 1996, 2, 30 );                d1.output();  d2.output();
   d1.output();                            cout << endl;
   d2.output();                            d3.output();  d4.output();
   cout << endl;                           cout << endl;
}                                       }

// 960229  960230                       // 960229  960230
// 960229  960301                       // 960229  960301



// Purpose.  Bridge design pattern demo
// 
// Discussion.  The motivation is to decouple the Time interface from the
// Time implementation, while still allowing the abstraction and the
// realization to each be modelled with their own inheritance hierarchy.
// The implementation classes below are straight-forward.  The interface
// classes are a little more subtle.  Routinely, a Bridge pattern
// interface hierarchy "hasa" implementation class.  Here the interface
// base class "hasa" a pointer to the implementation base class, and each
// class in the interface hierarchy is responsible for populating the base
// class pointer with the correct concrete implementation class.  Then all
// requests from the client are simply delegated by the interface class to
// the encapsulated implementation class.

#include <iostream.h>
#include <iomanip.h>
#include <string.h>

class TimeImp {
public:
   TimeImp( int hr, int min ) {
      hr_ = hr;  min_ = min; }
   virtual void tell() {
      cout << "time is " << setw(2) << setfill(48) << hr_ << min_ << endl; }
protected:
   int hr_, min_;
};

class CivilianTimeImp : public TimeImp {
public:
   CivilianTimeImp( int hr, int min, int pm ) : TimeImp( hr, min ) {
      if (pm)
         strcpy( whichM_, " PM" );
      else
         strcpy( whichM_, " AM" ); }
   /* virtual */ void tell() {
      cout << "time is " << hr_ << ":" << min_ << whichM_ << endl; }
protected:
   char  whichM_[4];
};

class ZuluTimeImp : public TimeImp {
public:
   ZuluTimeImp( int hr, int min, int zone ) : TimeImp( hr, min ) {
      if (zone == 5)
         strcpy( zone_, " Eastern Standard Time" );
      else if (zone == 6)
         strcpy( zone_, " Central Standard Time" ); }
   /* virtual */ void tell() {
      cout << "time is " << setw(2) << setfill(48) << hr_ << min_ 
         << zone_ << endl; }
protected:
   char  zone_[30];
};

class Time {
public:
   Time() { }
   Time( int hr, int min ) {
      imp_ = new TimeImp( hr, min ); }
   virtual void tell() {
      imp_->tell(); }
protected:
   TimeImp*  imp_;
};

class CivilianTime : public Time {
public:
   CivilianTime( int hr, int min, int pm ) {
      imp_ = new CivilianTimeImp( hr, min, pm ); }
};

class ZuluTime : public Time {
public:
   ZuluTime( int hr, int min, int zone ) {
      imp_ = new ZuluTimeImp( hr, min, zone ); }
};


void main() {
   Time*  times[3];
   times[0] = new Time( 14, 30 );
   times[1] = new CivilianTime( 2, 30, 1 );
   times[2] = new ZuluTime( 14, 30, 6 );
   for (int i=0; i < 3; i++)
      times[i]->tell();
}

// time is 1430
// time is 2:30 PM
// time is 1430 Central Standard Time