// Purpose. Extension Object design pattern.
//
// Summary. Discusses how to use aggregation (instead of mixin multiple
// inheritance) to add "interfaces" (or methods) to a class at run-time.
// This approach overcomes some limitations in the Visitor and Decorator
// patterns - but - it requires the use of RTTI, and, it makes client code
// more complex.
//
// Whereas Decorator requires that the core class's interface remain fixed
// as successive "wrappers" are applied, Extension Object allows the class's
// interface to grow incrementally and dynamically.
//
// The focus of the Extension Object pattern is to engineer a class to
// support additional methods, or services. Clients that want to leverage
// an interface extension, query the object first to see if it supports
// the extension before attempting to use it.
//
// The pattern can tempt the designer to rely on this technique to
// rationalize reactive coding rather than commit oneself to proactive
// design. The paper offered no discussion of access to private and
// protected members of Image by Extension objects.

#include <iostream>
#include <string>
using std::cout;
using std::string;

class Extension {
public:
virtual ~Extension() { }
void registerOwner( class Image* o ) { owner = o; }
protected:
Image* owner;
};

class MosaicExtension : public Extension { public:
void doMosaic();
};

class HeatExtension : public Extension { public:
void doThermalSpectrum();
};


class Image {
string name;
public:
Image( string n ) : name(n) { }
string getName() { return name; }
void display() { cout << "display: " << name << '\n'; }
virtual Extension* getExtension( const type_info& ) { return 0; }
};


void MosaicExtension::doMosaic() {
cout << " doMosaic: " << owner->getName() << '\n'; }
void HeatExtension::doThermalSpectrum() {
cout << " doThermalSpectrum: " << owner->getName() << '\n'; }


class Lsat : public Image {
Extension* exten;
public:
Lsat( string n, Extension* ex ) : Image( n ) {
exten = ex;
exten->registerOwner( this );
}
~Lsat() { delete exten; }
/*virtual*/ Extension* getExtension( const type_info& ti ) {
if (typeid(MosaicExtension) == ti) return exten;
return Image::getExtension( ti );
}
};

class IR : public Image {
Extension* exten;
public:
IR( string n, Extension* ex ) : Image( n ) {
exten = ex;
exten->registerOwner( this );
}
~IR() { delete exten; }
/*virtual*/ Extension* getExtension( const type_info& ti ) {
if (typeid(HeatExtension) == ti) return exten;
return Image::getExtension( ti );
}
};


void main( void ) {
Image* images[4] = {
new Lsat( "Western hemisphere", new MosaicExtension() ),
new IR( "Desert Storm", new MosaicExtension() ),
new Lsat( "Amazon rain forest", new HeatExtension() ),
new IR( "Gulf of Oman", new HeatExtension() ) };
Extension* ext;
MosaicExtension* mosaicExt;
HeatExtension* heatExt;

for (int i=0; i < 4; i++) {
images[i]->display();
if (ext = images[i]->getExtension( typeid(MosaicExtension) )) {
if (mosaicExt = dynamic_cast<MosaicExtension*>( ext ))
mosaicExt->doMosaic();
} else if (ext = images[i]->getExtension( typeid(HeatExtension) )) {
if (heatExt = dynamic_cast<HeatExtension*>( ext ))
heatExt->doThermalSpectrum();
} }
for (i=0; i < 4; i++) delete images[i];
}

// display: Western hemisphere
// doMosaic: Western hemisphere
// display: Desert Storm
// display: Amazon rain forest
// display: Gulf of Oman
// doThermalSpectrum: Gulf of Oman