Adapter.cpp

#include <iostream>
#include <algorithm>
#include <memory>

/**
 * The Target defines the domain-specific interface used by the client code.
 */
class Target {
 public:
  virtual ~Target(){
    std::cout << "Target destroyed" << std::endl;
  };

  virtual std::string Request() const {
    return "Target: The default target's behavior.";
  }
};

/**
 * The Adaptee contains some useful behavior, but its interface is incompatible
 * with the existing client code. The Adaptee needs some adaptation before the
 * client code can use it.
 */
class Adaptee {
 public:
  ~Adaptee()
  {
    std::cout << "Adaptee destroyed" << std::endl;
  };

  std::string SpecificRequest() const {
    return ".eetpadA eht fo roivaheb laicepS";
  }
};

/**
 * The Adapter makes the Adaptee's interface compatible with the Target's
 * interface.
 */
class Adapter : public Target {
 private:
  const std::unique_ptr<Adaptee>& adaptee_;

 public:
  Adapter(const std::unique_ptr<Adaptee>& adaptee) : adaptee_(adaptee) {}
  std::string Request() const override {
    std::string to_reverse = this->adaptee_->SpecificRequest();
    std::reverse(to_reverse.begin(), to_reverse.end());
    return "Adapter: (TRANSLATED) " + to_reverse;
  }

  ~Adapter()
  {
    std::cout << "Adapter destroyed" << std::endl;
  };
};

/**
 * The client code supports all classes that follow the Target interface.
 */
void ClientCode(const std::unique_ptr<Target>& target) {
  std::cout << target->Request();
}

int main() {
  std::cout << "Client: I can work just fine with the Target objects:\n";
  //Target *target = new Target;
  std::unique_ptr<Target> target = std::make_unique<Target>();
  ClientCode(target);
  std::cout << "\n\n";
  //Adaptee *adaptee = new Adaptee;
  std::unique_ptr<Adaptee> adaptee = std::make_unique<Adaptee>();
  std::cout << "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";
  std::cout << "Adaptee: " << adaptee->SpecificRequest();
  std::cout << "\n\n";
  std::cout << "Client: But I can work with it via the Adapter:\n";
  //Adapter *adapter = new Adapter(adaptee);
  std::unique_ptr<Target> adapter = std::make_unique<Adapter>(adaptee);
  ClientCode(adapter);
  std::cout << "\n";

  //delete target;
  //delete adaptee;
  //delete adapter;

  return 0;
}