// Purpose. Builder class Builder { public:
// virtual void addFront( char ) = 0;
// The monolithic design supports a virtual void addBack( char ) = 0;
// single representation. The Builder virtual Array& getResult() = 0;
// design allows a different rep per };
// Builder derived class, and the com-
// mon input and parsing have been de- class BuilderOne : public Builder {
// fined in the Director class. The D public:
// constructs, the B returns result. void addFront( char ch ) {
one.lst.push_back( ch ); }
class Array { void addBack( char ch ) {
public: one.lst.push_back( ch ); }
void addFront( char ch ) { Array& getResult() {
lst.push_front( ch ); } return one; }
void addBack( char ch ) { private:
lst.push_back( ch ); } OneEnded one;
void traverse() { };
for (i=0; i < lst.size(); i++)
cout << lst[i] << ' '; class BuilderTwo : public Builder {
cout << endl; } public:
private: void addFront( char ch ) {
deque<char> lst; int i; two.lst.push_front( ch ); }
}; void addBack( char ch ) {
two.lst.push_back( ch ); }
string in[] = { "fa", "bb", "fc", Array& getResult() {
"bd", "fe", "bf", "fg", "bh" }; return two; }
private:
void main( void ) { TwoEnded two;
Array list; };
for (int i=0; i < 8; i++)
if (in[i][0] == 'f') string in[] = { "fa", "bb", "fc",
list.addFront( in[i][1] ); "bd", "fe", "bf", "fg", "bh" };
else if (in[i][0] == 'b')
list.addBack( in[i][1] ); class Director {
list.traverse(); } public:
Director( Builder* b ) {
// g e c a b d f h setBuilder( b ); }
void setBuilder( Builder* b ) {
///////////////////\\\\\\\\\\\\\\\\\\\ bldr = b; }
void construct() {
class Array { public: for (int i=0; i < 8; i++)
virtual void traverse() = 0; if (in[i][0] == 'f')
}; bldr->addFront(in[i][1]);
else if (in[i][0] == 'b')
class OneEnded : public Array { bldr->addBack(in[i][1]);
public: }
friend class BuilderOne; private:
void traverse() { Builder* bldr;
for (i=0; i < lst.size(); i++) };
cout << lst[i] << ' ';
cout << endl; } void main( void ) {
private: BuilderOne one;
vector<char> lst; int i; BuilderTwo two;
}; Director dir( &one );

class TwoEnded : public Array { dir.construct();
public: one.getResult().traverse();
friend class BuilderTwo; dir.setBuilder( &two );
void traverse() { dir.construct();
for (i=0; i < lst.size(); i++) two.getResult().traverse();
cout << lst[i] << ' '; }
cout << endl; }
private: // a b c d e f g h
deque<char> lst; int i; // g e c a b d f h
};



// Purpose. Builder design pattern demo.
//
// Discussion. The forte of Builder is constructing a complex object step
// by step. An abstract base class declares the standard construction
// process, and concrete derived classes define the appropriate
// implementation for each step of the process. In this example,
// "distributed work packages" have been abstracted to be persistent and
// platform independent. This means that the platform-specific mechanism
// for implementing files, queues, and concurrency pathways is defined in
// each platform's concrete derived class. A single "reader" object (i.e.
// parser) retrieves the archived specification for a DistrWorkPackage and
// proceeds to delegate each build step to the builder object that was
// registered by the client. Upon completion, the client retrieves the
// end result from the builder.

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

enum PersistenceType { File, Queue, Pathway };

struct PersistenceAttribute {
PersistenceType type;
char value[30];
};

class DistrWorkPackage {
public:
DistrWorkPackage( char* type ) {
sprintf( _desc, "Distributed Work Package for: %s", type); }
void setFile ( char* f, char* v ) {
sprintf( _temp, "\n File(%s): %s", f, v );
strcat( _desc, _temp); }
void setQueue ( char* q, char* v ) {
sprintf( _temp, "\n Queue(%s): %s", q, v );
strcat( _desc, _temp); }
void setPathway( char* p, char* v ) {
sprintf( _temp, "\n Pathway(%s): %s", p, v );
strcat(_desc,_temp); }
const char* getState() { return _desc; }
private:
char _desc[200], _temp[80];
};

class Builder {
public:
virtual void configureFile( char* ) = 0;
virtual void configureQueue( char* ) = 0;
virtual void configurePathway( char* ) = 0;
DistrWorkPackage* getResult() { return _result; }
protected:
DistrWorkPackage* _result;
};

class UnixBuilder : public Builder {
public:
UnixBuilder() { _result = new DistrWorkPackage( "Unix" ); }
void configureFile( char* name ) {
_result->setFile( "flatFile", name ); }
void configureQueue( char* queue ) {
_result->setQueue( "FIFO", queue ); }
void configurePathway( char* type ) {
_result->setPathway( "thread", type ); }
};

class VmsBuilder : public Builder {
public:
VmsBuilder() { _result = new DistrWorkPackage( "Vms" ); }
void configureFile( char* name ) {
_result->setFile( "ISAM", name ); }
void configureQueue( char* queue ) {
_result->setQueue( "priority", queue ); }
void configurePathway( char* type ) {
_result->setPathway( "LWP", type ); }
};


class Reader {
public:
void setBuilder( Builder* b ) { _builder = b; }
void construct( PersistenceAttribute[], int );
private:
Builder* _builder;
};

void Reader::construct( PersistenceAttribute list[], int num ) {
for (int i=0; i < num; i++)
if (list[i].type == File)
_builder->configureFile( list[i].value );
else if (list[i].type == Queue)
_builder->configureQueue( list[i].value );
else if (list[i].type == Pathway)
_builder->configurePathway( list[i].value ); }


const int NUM_ENTRIES = 6;
PersistenceAttribute input[NUM_ENTRIES] = { {File, "state.dat"},
{File,"config.sys"}, {Queue, "compute"}, {Queue, "log"},
{Pathway, "authentication"}, {Pathway, "error processing"} };

void main() {
UnixBuilder unixBuilder;
VmsBuilder vmsBuilder;
Reader reader;

reader.setBuilder( &unixBuilder );
reader.construct( input, NUM_ENTRIES );
cout << unixBuilder.getResult()->getState() << endl;

reader.setBuilder( &vmsBuilder );
reader.construct( input, NUM_ENTRIES );
cout << vmsBuilder.getResult()->getState() << endl;
}

// Distributed Work Package for: Unix
// File(flatFile): state.dat
// File(flatFile): config.sys
// Queue(FIFO): compute
// Queue(FIFO): log
// Pathway(thread): authentication
// Pathway(thread): error processing
// Distributed Work Package for: Vms
// File(ISAM): state.dat
// File(ISAM): config.sys
// Queue(priority): compute
// Queue(priority): log
// Pathway(LWP): authentication
// Pathway(LWP): error processing