Builder 模式

 Builder 模式用于构建一个复杂对象。

它将一个复杂的对象的构建同它的实现相分离，使得同样的构建过程可以创建不同的表示。

 

// 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>
#include <stdio.h>
#include <string>
using namespace std;

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, "   File(%s): %s", f, v );
        strcat( _desc, _temp); }
    void setQueue  ( char* q, char* v )  ...{
        sprintf( _temp, "   Queue(%s): %s", q, v );
        strcat( _desc, _temp); }
    void setPathway( char* p, char* v )  ...{
        sprintf( _temp, "   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"} };

int 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;
    return 0;
}

// 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