第30章 混编模式（3）

#pragma once
//**************************************辅助类********************
//产品事件类型
enum ProductEventType
{
    NEW_PRODUCT = 1,
    DEL_PRODUCT = 2,
    EDIT_PRODUCT = 3,
    CLONE_PRODUCT = 4
};

//事件处理类型
enum EventHandlerType
{
    NEW = 1,
    DEL = 2,
    EDIT =3,
    CLONE = 4
};

typedef void Object;
//事件对象类(主要用来记录触发事件的源对象)
class EventObject
{
    Object* source; //记录事件源对象
public:
    EventObject(Object* source)
    {
        this->source = source;
    }

    Object* EventSource()
    {
        return source;
    }
};

#include "Product.h"
#include "Observable.h"
//********************Product Impl*********************
Product::Product(ProductManager& manager, string name)
{
    this->canChanged = false;

    this->manager = &manager;
    //允许建立产品
    if(manager.isCreateProduct())
    {
        canChanged = true;
        this->name = name;
    }
}

Product& Product::getInstance(ProductManager& manager, string name)
{
    Product* ret = NULL;
    if(manager.isCreateProduct())
    {
        ret = new Product(manager, name);
    }

    return *ret;
}

string Product::getName(){return name;}

void Product::setName(string value)
{
    if(canChanged)
        name = value;
}

Product& Product::clone()
{
    Product* ret = new Product(*manager, name);

    return *ret;
}

//********************ProductManager Impl*********************
Product* ProductManager::createProduct(string name)
{
    //首先修改权限，允许创建
    isPermittedCreate = true;
    Product& p = Product::getInstance(*this, name);
    //产生一个创建事件
    ProductEvent event(&p, ProductEventType::NEW_PRODUCT);
    return &p;
}
//获得是否可以创建一个产品
bool ProductManager::isCreateProduct()
{
    return isPermittedCreate;
}
//修改一个产品
void ProductManager::editProduct(Product& p,string name)
{
    //修改后的名字
    p.setName(name);
    //产生一个修改事件
    ProductEvent event(&p, ProductEventType::EDIT_PRODUCT);
}

//废弃一个产品
void ProductManager::abandonProduct(Product& p)
{
   //产生一个删除事件
    ProductEvent event(&p, ProductEventType::DEL_PRODUCT);
    delete &p;
}
//克隆一个产品
Product& ProductManager::clone(Product& p)
{
    //产生一个克隆事件
    ProductEvent event(&p, ProductEventType::CLONE_PRODUCT);
    return p.clone();
}

#include "Observable.h"

//被观察者
void Observable::addObserver(Observer* observer)
{
    obs.push_back(observer);
    //notifyObservers(this);
}

EventObject& Observable::getEventObject(){return eo;}

void Observable::notifyObservers(Observable* o)
{
    list<Observer*>::iterator iter = obs.begin();
    while(iter != obs.end())
    {
        (*iter)->update(o, &eo);
        ++iter;
    }
}

//产品事件
void  ProductEvent::init(Product* p, ProductEventType t)
{
    this->source = p;
    this->type = t;
    //事件触发
    notifyEventDispatch();
}
//通知事件处理中心
void ProductEvent::notifyEventDispatch()
{
    addObserver(EventDispatch::getInstance());
    Observable::notifyObservers(this);
}

//传入事件的源头，默认为新建类型
ProductEvent::ProductEvent(Product* p):Observable()
{
    init(p, ProductEventType::NEW_PRODUCT);
}

ProductEvent::ProductEvent(Product* p, ProductEventType type):Observable()
{
    init(p, type);
}

//获得事件的始作俑者
Product* ProductEvent::getSource()
{
    return source;
}

//获得事件类型
ProductEventType ProductEvent::getEventType()
{
    return type;
}

#include "Observer.h"
#include "Product.h"
#include "Observable.h"
#include "Handler.h"
//事件通知对象
EventDispatch* EventDispatch::getInstance()
{
    return dispatch;
}

EventDispatch* EventDispatch::getEventDispatch()
{
    return dispatch;
}

//事件触发
void EventDispatch::update(Observable* o, EventObject* e)
{
    //事件的源头
    //Product& p = (Product&)(*(Product*)(e->EventSource()));
    //事件
    ProductEvent& event = (ProductEvent&)(*o);

    //处理者处理，这里是中介者模式的核心，可以是很复杂的业务逻辑
    vector<EventHandler*>::iterator iter =  handlers.begin();
    while(iter != handlers.end())
    {
        //处理能力是否匹配
        vector<EventHandlerType>& eht= (*iter)->getHandlerType();
        vector<EventHandlerType>::iterator it = eht.begin();
        while(it != eht.end())
        {
            if ((int)(*it) == (int)event.getEventType())
                (*iter)->exec(&event);
            ++it;
        }
        ++iter;
    }
}

//注册事件处理者
void EventDispatch::registerHandler(EventHandler* eventHandler)
{
    handlers.push_back(eventHandler);
}
EventDispatch* EventDispatch::dispatch = new EventDispatch();

#include <iostream>
#include "Handler.h"
#include "Product.h"
using namespace std;

//每个事件处理者都要声明自己处理哪一类别的消息
EventHandler::EventHandler(EventHandlerType type)
{
    handlerType.push_back(type);
}
void EventHandler::addHandlerType(EventHandlerType type)
{
    handlerType.push_back(type);
}

//得到自己的处理能力
vector<EventHandlerType>& EventHandler::getHandlerType()
{
    return handlerType;
}

//删除事件的处理者
void DelEventHandler::exec(ProductEvent* event)
{
    //事件的源头
    Product* p = event->getSource();
    //事件类型
    ProductEventType type = event->getEventType();
    cout <<"删除事件的处理:销毁" << p->getName() <<"，事件类型:" << type <<endl;
}

CreateEventHandler::CreateEventHandler():EventHandler(EventHandlerType::NEW)
{
    handlerType.push_back(EventHandlerType::CLONE);
};

//创建事件的处理者
void CreateEventHandler::exec(ProductEvent* event)
{
    //事件的源头
    Product* p = event->getSource();
    //事件类型
    ProductEventType type = event->getEventType();
    if(type == ProductEventType::NEW_PRODUCT)
    {
        cout <<"新建事件的处理:新建" << p->getName() <<"，事件类型:" << type <<endl;
    }
    else
    {
        cout <<"克隆事件的处理:克隆" << p->getName() <<"，事件类型:" << type <<endl;
    }
}

//修改事件的处理者
void EditEventHandler::exec(ProductEvent* event)
{
    //事件的源头
    Product* p = event->getSource();
    //事件类型
    ProductEventType type = event->getEventType();
    cout <<"修改事件的处理:修改" << p->getName() <<"，事件类型:" << type <<endl;
}