Design pattern

class Processor {
 public:
  virtual void ThreadWork() = 0;
};
class HiveProcessor : public Processor {
 public:
  void ThreadWork() override { cout << "ConsumeHive" << endl; }
};
class KafkaProcessor : public Processor {
 public:
  void ThreadWork() override { cout << "ConsumeKafka" << endl; }
};
class CompoundProcessor: public Processor {
 public:
  void AddProcessor(unique_ptr<Processor> p) {
    processors_.emplace_back(std::move(p));
  }
  void ThreadWork() override {
    for (auto& p : processors_) {
      p->ThreadWork();
    }
  }
  list<unique_ptr<Processor>> processors_;
};

int main() {
  CompoundProcessor cp;
  cp.AddProcessor(make_unique<HiveProcessor>());
  cp.AddProcessor(make_unique<KafkaProcessor>());
  Processor *p = &cp;
  p->ThreadWork();
}

class Bar {
 public:
  virtual void UseBar() = 0;
  virtual ~Bar() = default;
};
class BarImpl : public Bar {
 public:
  // 现有的实现，在不影响其结构的情况下添加新的功能
  void UseBar() override { cout << "UseBar" << endl; }
};

class BarDecorator : public Bar {
 public:
  BarDecorator(unique_ptr<Bar> bar) : bar_(std::move(bar)) {}
protected:
  unique_ptr<Bar> bar_;  // 将原始对象嵌套在装饰类中
};
class BarDecoratorFilter : public BarDecorator {
 public:
  BarDecoratorFilter(unique_ptr<Bar> bar) : BarDecorator(std::move(bar)) {}
  // 装饰类在运行时“装饰”该对象，添加新的行为
  void UseBar() override {
    Dofilter();
    bar_->UseBar();
  }
 private:
  void Dofilter() { cout << "DoFilter" << endl; }
};
int main() {
  auto bar_ptr = make_unique<BarImpl>();
  unique_ptr<Bar> bar = make_unique<BarDecoratorFilter>(std::move(bar_ptr));
  bar->UseBar();
}

class StrategyA {
public:
  void Execute() { cout << "execute type 1" << endl; }
};
class StrategyB {
public:
  void Execute() { cout << "execute type 2" << endl; }
};
class Foo {
public:
  void ExecuteByType(int type) {
    if (type == 1) {
      StrategyA sta;
      sta.Execute();
    } else if (type == 2) {
      StrategyB stb;
      stb.Execute();
    } // 违反开闭原则
  }
};

int main() {
  Foo f;
  f.ExecuteByType(1);
  f.ExecuteByType(2);
}

class Strategy {
public:
  virtual void Execute() = 0;
};
class StrategyA : public Strategy {
public:
  void Execute() override { cout << "execute type 1" << endl; }
};
class StrategyB : public Strategy {
public:
  void Execute() override { cout << "execute type 2" << endl; }
};
class StrategyFactory {
public:
  static unique_ptr<Strategy> createStrategy(int type) {
    if (type == 1) {
      return make_unique<StrategyA>();
    } else if (type == 2) {
      return make_unique<StrategyB>();
    } else {
      return nullptr;
    } // 违反开闭原则
  }
};

class Foo {
public:
  void ExecuteByType(int type) { StrategyFactory::createStrategy(type)->Execute(); }
};
int main() {
  Foo f;
  f.ExecuteByType(1);
  f.ExecuteByType(2);
}

class Strategy;
class StrategyFactory {
public:
  static unique_ptr<Strategy> createStrategy(int type) {
    return strategies[type]();
  }
  static void registerStrategy(int type, function<unique_ptr<Strategy>()> create_fn) {
    strategies[type] = create_fn;
  }
private:
  static unordered_map<int, function<unique_ptr<Strategy>()>> strategies;
};
unordered_map<int, function<unique_ptr<Strategy>()>> StrategyFactory::strategies;

class Strategy {
public:
  virtual void Execute() = 0;
};
class StrategyA : public Strategy {
public:
  static void registerStrategy() {
    StrategyFactory::registerStrategy(1, []() -> unique_ptr<Strategy> {
      return make_unique<StrategyA>();
    });
  }
  void Execute() override { cout << "execute type 1" << endl; }
};
class StrategyB : public Strategy {
public:
  static void registerStrategy() {
    StrategyFactory::registerStrategy(2, []() -> unique_ptr<Strategy> {
      return make_unique<StrategyB>();
    });
  }
  void Execute() override { cout << "execute type 2" << endl; }
};

class Foo {
public:
  explicit Foo() {
    StrategyA::registerStrategy();
    StrategyB::registerStrategy();
  }
  void ExecuteByType(int type) { StrategyFactory::createStrategy(type)->Execute(); }
};

int main() {
  Foo f;
  f.ExecuteByType(1);
  f.ExecuteByType(2);
}

// Lazy
class Single{
public:
    static Single* getInstance(){
        static Single ins;
        return &ins;
    }
    Single(const Single&) = delete;
    Single(Single&&) = delete;
    Single& operator=(const Single&) = delete;
private:
    Single() = default;
    virtual ~Single() = default;
};

// Eager
class Single{
public:
    static Single* getInstance(){
        return ins;
    }
    Single(const Single&) = delete;
    Single(Single&&) = delete;
    Single operator=(const Single&) = delete;
private:
    Single() = default;
    virtual ~Single() = default;
    static Single *ins;
};
Single* Single::ins = new(nothrow) Single;

class Subject;
//观察者 （内部实例化了被观察者的对象）
class Observer {
public:
  Observer(string name, Subject *sub) {
    this->name = name;
    this->sub = sub;
	}
	virtual void update() = 0;
protected:
  string name;
	Subject *sub;
};

class StockObserver : public Observer {
public:
  StockObserver(string name, Subject *sub) : Observer(name, sub){}
  void update() {
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "⽼板来了!") {
      cout << "我⻢上关闭股票，装做很认真⼯作的样⼦！" << endl;
    }
  }
};
class NBAObserver : public Observer {
public:
  NBAObserver(string name, Subject *sub) : Observer(name, sub){}
  void update() {
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "⽼板来了!") {
      cout << "我⻢上关闭 NBA，装做很认真⼯作的样⼦！" << endl;
    }
  }
};

// 被观察者 （存放了所有观察者对象，在状态变化时给观察者发通知）
class Subject {
protected:
	std::list<Observer*> observers;
public:
  string action; //被观察者对象的状态
  virtual void attach(Observer *) = 0;
  virtual void detach(Observer *) = 0;
  virtual void notify() = 0;
};

class Secretary : public Subject {
  void attach(Observer *observer) {
    observers.push_back(observer);
  }
  void detach(Observer *observer) {
    auto iter = observers.begin();
    while (iter != observers.end()) {
      if ((*iter) == observer) {
        observers.erase(iter);
        return;
      }
      ++iter;
    }
  }
  void notify() {
    list<Observer *>::iterator iter = observers.begin();
    while (iter != observers.end()) {
      (*iter)->update();
      ++iter;
    }
  }
};

int main(){
  Subject *BOSS = new Secretary();
  Observer *a = new NBAObserver("a", BOSS);
  Observer *b = new StockObserver("b", BOSS);
  BOSS->attach(a);
  BOSS->attach(b);
  BOSS->action = "去吃饭了";
  BOSS->notify();
  cout << endl;
  BOSS->action = "⽼板来了";
  BOSS->notify();
}