Example 11-1: A Switch to Control Which Driver to Use

TOC

• ApControl

Example 11-2: Using Polymorphism to Solve the Problem

Example 11-3: Implementation of ResFactory

TOC

• ApControl
• ResFactory
• HighResFact
• LowResFact
• DisplayDriver
• HRDD
• LRDD
• PrintDriver
• HRPD
• LRPD

Example 11-1: A Switch to Control Which Driver to Use

• ApControl

ApControl

#pragma once

#typedef enum { LOW, HIGH } Resolution;

class ApControl
{
public:
	ApControl(void);
	void doDraw();
	void doPrint();
public:
	~ApControl(void);
private:
	Resolution myResolution;
};

#include "ApControl.h"

ApControl::ApControl(void)
{
	// Set myResolution based on configuration
}

ApControl::~ApControl(void)
{
}

void ApControl::void doDraw()
{
    switch (myResolution) 
	{
        case LOW:
            // use lrdd
			break;
        case HIGH:
            // use hrdd
			break;
      }
}

void ApControl::doPrint()
{
    switch (myResolution) 
	{
        case LOW:
            // use lrpd
            break;
        case HIGH:
            // use hrpd
            break;
      }
}

Example 11-2: Using Polymorphism to Solve the Problem

Example 11-3: Implementation of ResFactory

• ApControl
• ResFactory
• HighResFact
• LowResFact
• DisplayDriver
• HRDD
• LRDD
• PrintDriver
• HRPD
• LRPD

ApControl

#pragma once
#include "DisplayDriver.h"
#include "PrintDriver.h"
#include "ResFactory.h"

class ApControl
{
public:
	ApControl(void);
	void doPrint(void);
	void doDraw(void);
public:
	~ApControl(void);
private:
	ResFactory *myResFactory;
	DisplayDriver *myDisplayDriver;
	PrintDriver *myPrintDriver;
};

#include "ApControl.h"

ApControl::ApControl(void)
{
	ResFactory *myResFactory= ResFactory::getFactory();
	myDisplayDriver= myResFactory->getDispDrvr();
	myPrintDriver= myResFactory->getPrtDrvr();
}

ApControl::~ApControl(void)
{
}

void ApControl::doDraw(void)
{
//	. . .
	myDisplayDriver->draw();
}

void ApControl::doPrint(void)
{
//	. . .
	myPrintDriver->print();
}

ResFactory

#pragma once
#include "DisplayDriver.h"
#include "PrintDriver.h"

class ResFactory
{
public:
	ResFactory(void);
	virtual DisplayDriver* getDispDrvr(void)=0;
	virtual PrintDriver* getPrtDrvr(void)=0;
	static ResFactory* getFactory(void);
public:
	~ResFactory(void);
};

#include "ResFactory.h"
#include "HighResFactory.h"
#include "LowResFactory.h"

ResFactory::ResFactory(void)
{
}

ResFactory::~ResFactory(void)
{
}

ResFactory* ResFactory::getFactory (void)
{
	// Logic to decide which resolution to use
	// If are to use High Resolution
	return new HighResFactory;
	// if are to use Low Resolution
	return new LowResFactory;
}

HighResFact

#pragma once
#include "resfactory.h"
#include "HRDD.h"
#include "HRPD.h"

class HighResFact : public ResFactory
{
public:
	HighResFact(void);
	DisplayDriver* getDispDrvr(void);
	PrintDriver* getPrtDrvr(void);
public:
	~HighResFact(void);
};

#include "HighResFact.h"

HighResFact::HighResFact(void)
{
}

HighResFact::~HighResFact(void)
{
}
DisplayDriver* HighResFact::getDispDrvr(void)
{
	return new HRDD;
}

PrintDriver* HighResFact::getPrtDrvr(void)
{
	return new HRPD;
}

LowResFact

#pragma once
#include "resfactory.h"
#include "LRDD.h"
#include "LRPD.h"

class LowResFact : 	public ResFactory
{
public:
	LowResFact(void);
	DisplayDriver* getDispDrvr(void);
	PrintDriver* getPrtDrvr(void);
public:
	~LowResFact(void);
};

#include "LowResFact.h"

LowResFact::LowResFact(void)
{
}

LowResFact::~LowResFact(void)
{
}

DisplayDriver* LowResFact::getDispDrvr(void)
{
	return new LRDD;
}

PrintDriver* LowResFact::getPrtDrvr(void)
{
	return new LRPD;
}

DisplayDriver

#pragma once

class DisplayDriver
{
public:
	DisplayDriver(void);
	virtual void draw(void)=0;
public:
	~DisplayDriver(void);
};

#include "DisplayDriver.h"

DisplayDriver::DisplayDriver(void)
{
}

DisplayDriver::~DisplayDriver(void)
{
}

HRDD

#pragma once
#include "displaydriver.h"

class HRDD : public DisplayDriver
{
public:
	HRDD(void);
	void draw(void);
public:
	~HRDD(void);
};

#include "HRDD.h"

HRDD::HRDD(void)
{
}

HRDD::~HRDD(void)
{
}

void HRDD::draw(void) 
{
	// do high resolution draw
}

LRDD

#pragma once
#include "displaydriver.h"

class LRDD :
	public DisplayDriver
{
public:
	LRDD(void);
	void draw(void);
public:
	~LRDD(void);
};

#include "LRDD.h"

LRDD::LRDD(void)
{
}

LRDD::~LRDD(void)
{
}

void LRDD::draw(void)
{
	// do low resolution draw
}

PrintDriver

#pragma once

class PrintDriver
{
public:
	PrintDriver(void);
	virtual void print(void)=0;
public:
	~PrintDriver(void);
};

#include "PrintDriver.h"

PrintDriver::PrintDriver(void)
{
}

PrintDriver::~PrintDriver(void)
{
}

HRPD

#pragma once
#include "printdriver.h"

class HRPD : public PrintDriver
{
public:
	HRPD(void);
	void print(void);
public:
	~HRPD(void);
};

#include "HRPD.h"

HRPD::HRPD(void)
{
}

HRPD::~HRPD(void)
{
}

void HRPD::print()
{
	// Do high resolution print
}

LRPD

#pragma once
#include "printdriver.h"

class LRPD :
	public PrintDriver
{
public:
	LRPD(void);
	void print();
public:
	~LRPD(void);
};

#include "LRPD.h"

LRPD::LRPD(void)
{
}

LRPD::~LRPD(void)
{
}

void LRPD::print()
{
	// do low resolution print
}