Decorator.cpp

#include <iostream>
#include <memory>

/**
 * The base Component interface defines operations that can be altered by
 * decorators.
 */
class Component {
 public:
 Component()
 {
  std::cout << "Construct Component" << std::endl;
 }
  virtual ~Component()
  {
  std::cout << "Destruct Component" << std::endl;
 }
  virtual std::string Operation() const = 0;
};
/**
 * Concrete Components provide default implementations of the operations. There
 * might be several variations of these classes.
 */
class ConcreteComponent : public Component {
 public:
 ConcreteComponent()
 {
  std::cout << "Construct ConcreteComponent" << std::endl;
 }
  ~ConcreteComponent()
  {
  std::cout << "Destruct ConcreteComponent" << std::endl;
 }

  std::string Operation() const override {
    return "ConcreteComponent";
  }
};
/**
 * The base Decorator class follows the same interface as the other components.
 * The primary purpose of this class is to define the wrapping interface for all
 * concrete decorators. The default implementation of the wrapping code might
 * include a field for storing a wrapped component and the means to initialize
 * it.
 */
class Decorator : public Component {
  /**
   * @var Component
   */
 protected:
  Component* component_;

 public:
  Decorator(Component* component) : component_(component) {
  std::cout << "Construct Decorator" << std::endl;

  }
  /**
   * The Decorator delegates all work to the wrapped component.
   */
  std::string Operation() const override {
    return this->component_->Operation();
  }
};
/**
 * Concrete Decorators call the wrapped object and alter its result in some way.
 */
class ConcreteDecoratorA : public Decorator {
  /**
   * Decorators may call parent implementation of the operation, instead of
   * calling the wrapped object directly. This approach simplifies extension of
   * decorator classes.
   */
 public:
  ConcreteDecoratorA(Component* component) : Decorator(component) {
  }
  std::string Operation() const override {
    return "ConcreteDecoratorA(" + Decorator::Operation() + ")";
  }
};
/**
 * Decorators can execute their behavior either before or after the call to a
 * wrapped object.
 */
class ConcreteDecoratorB : public Decorator {
 public:
  ConcreteDecoratorB(Component* component) : Decorator(component) {
  }

  std::string Operation() const override {
    return "ConcreteDecoratorB(" + Decorator::Operation() + ")";
  }
};
/**
 * The client code works with all objects using the Component interface. This
 * way it can stay independent of the concrete classes of components it works
 * with.
 */
void ClientCode(Component* component) {
  // ...
  std::cout << "RESULT: " << component->Operation();
  // ...
}

int main() {
  /**
   * This way the client code can support both simple components...
   */
  //Component* simple = new ConcreteComponent;
  std::unique_ptr<Component> simple = std::make_unique<ConcreteComponent>();
  std::cout << "Client: I've got a simple component:\n";
  ClientCode(simple.get());
  std::cout << "\n\n";
  /**
   * ...as well as decorated ones.
   *
   * Note how decorators can wrap not only simple components but the other
   * decorators as well.
   */
  //Component* decorator1 = new ConcreteDecoratorA(simple.get());
  std::unique_ptr<Component> decorator1 = std::make_unique<ConcreteDecoratorA>(simple.get());
  //Component* decorator2 = new ConcreteDecoratorB(decorator1.get());
  ClientCode(decorator1.get());
  std::unique_ptr<Component> decorator2 = std::make_unique<ConcreteDecoratorB>(decorator1.get());
  std::cout << "Client: Now I've got a decorated component:\n";
  ClientCode(decorator2.get());
  std::cout << "\n";

  //delete simple;
  //delete decorator1;
  //delete decorator2;

  return 0;
}