/**
 * 创建型模式 建造者模式
 * Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。
 * Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。  
 * 对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象
 * 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法
 *
 */

#include <iostream>
#include <string>


// 表示被构造的复杂对象
class House
{
public:
    void setFloor(std::string floor)
    {
        this->m_floor = floor;
    }
    void setWall(std::string wall)
    {
        this->m_wall = wall;
    }
    void setDoor(std::string door)
    {
        this->m_door = door;
    }
    std::string getFloor()
    {
        return m_floor;
    }
    std::string getWall()
    {
        return m_wall;
    }
    std::string getDoor()
    {
        return m_door;
    }

private:
    std::string m_floor;
    std::string m_wall;
    std::string m_door;
};

// 设计师 为创建产品各个部分，统一抽象接口。
class Builder
{
public:
    virtual void makeFloor() = 0;
    virtual void makeWall() = 0;
    virtual void makeDoor() = 0;
    virtual House * getHouse() = 0;
    ~Builder() {};
};

// 公寓施工队
class FlatBuild: public Builder
{
public:
    FlatBuild()
    {
        pHouse = new House;
    }
    ~FlatBuild()
    {
        delete pHouse;
        pHouse = nullptr;
    }
    virtual void makeFloor() override
    {
        pHouse->setFloor("Flat Floor");
    }
    virtual void makeWall() override
    {
        pHouse->setWall("Flat Wall");
    }
    virtual void makeDoor() override
    {
        pHouse->setDoor("Flat Door");
    }
    virtual House * getHouse() override
    {
        return pHouse;
    }
private:
    House *pHouse;
};

// 别墅施工队
class VillBuild: public Builder
{
public:
    VillBuild()
    {
        pHouse = new House;
    }
    ~VillBuild()
    {
        delete pHouse;
    }
    virtual void makeFloor() override
    {
        pHouse->setFloor("Vill Floor");
    }
    virtual void makeWall() override
    {
        pHouse->setWall("Vill Wall");
    }
    virtual void makeDoor() override
    {
        pHouse->setDoor("Vill Door");
    }
    virtual House * getHouse() override
    {
        return pHouse;
    }
private:
    House *pHouse;
};

// 指挥者按照设计师的要求进行指挥
// 依赖关系，依赖设计师
class Director
{
public:
    void doConstruct(Builder * builder)
    {
        builder->makeFloor();
        builder->makeWall();
        builder->makeDoor();
    }
};

void mytest()
{
    // 客户直接造房子
    House * pHouse = new House();

    pHouse->setFloor("diy floor");
    pHouse->setWall("diy wall");
    pHouse->setDoor("diy door");
    std::cout << pHouse->getFloor().c_str() << std::endl;
    std::cout << pHouse->getWall().c_str() << std::endl;
    std::cout << pHouse->getDoor().c_str() << std::endl;
    delete pHouse;
    pHouse = nullptr;

    // 指挥者按照设计师的要求进行指挥
    Director * director = new Director();
    Builder * builder = nullptr;

    builder = new FlatBuild();
    director->doConstruct(builder); // 指挥者指挥工程队施工
    pHouse = builder->getHouse();
    std::cout << pHouse->getFloor().c_str() << std::endl;
    std::cout << pHouse->getWall().c_str() << std::endl;
    std::cout << pHouse->getDoor().c_str() << std::endl;
    delete builder;
    builder = nullptr;
    pHouse = nullptr;

    builder = new VillBuild();
    director->doConstruct(builder); // 指挥者指挥工程队施工
    pHouse = builder->getHouse();
    std::cout << pHouse->getFloor().c_str() << std::endl;
    std::cout << pHouse->getWall().c_str() << std::endl;
    std::cout << pHouse->getDoor().c_str() << std::endl;
    delete builder;
    builder = nullptr;
    pHouse = nullptr;

    delete director;
    director = nullptr;

    return;
}


int main()
{
    mytest();

    system("pause");
    return 0;
}