Understanding components through object-oriented design

// Duck is an abstract class with a pure virtual method "Quack".
class Duck {
  public:
    virtual void Quack() = 0;
};

// Actually implement Duck.
class MallardDuck : public Duck {
  public:
    void Quack() override { /* ... */ }
}

// All classes in Dart define an interface.
// Omitting the definition of Quack means it can be overridden in a child.
abstract class Duck {
  Quack();
}

MallardDuck implements Duck {
  @override
  Quack() { /* ... */ }
}

// Rust uses "traits" rather than interfaces.
// A trait may be explicitly implemented for any type.
trait Duck {
  fn quack(&self);
}

// The type MallardDuck implements the "Duck" trait.
struct MallardDuck {
}

impl Duck for MallardDuck {
  fn quack(&self) { /* ... */ }
}

// Explicitly define a public Duck interface.
public interface Duck {
  public void Quack();
}

// Create a class that implements the interface.
public class MallardDuck implements Duck {
  @Override
  public void Quack() { /* ... */ }
}

class DiceRoller : public Roller {
  public:
    DiceRoller(uint64_t number_of_sides) : number_of_sides(number_of_sides) {}
    uint64_t Roll() override;

  private:
    const uint64_t number_of_sides;
};

class DiceRoller implements dice.Roller {
    final int numberOfSides;
    DiceRoller({required this.numberOfSides});

    @override
    int Roll() { /* ... */ }
}

pub struct DiceRoller {
    number_of_sides: u64,
}

impl DiceRoller {
  pub fn new(number_of_sides: u64) -> Self {
    Self{ number_of_sides }
  }
}

impl Roller for DiceRoller {
  pub fn roll(&self) -> u64 { /* ... */ }
}

class DiceRoller implements Roller {
    private long numberOfSides;

    public DiceRoller(long numberOfSides) {
      this.numberOfSides = numberOfSides;
    }

    @Override
    public long Roll() { /* ... */ }
}

// User is an abstract class representing a user of the session.
// It declares the "GetName" method all users must implement.
class User {
  public:
    virtual std::string GetName()  = 0;
};

// App is class representing the interface to apps.
class App {
  /* ... */
};

class Session {
  public:
    Session() : user(/* initialize user */) {}

    void AddApp(App app) {
      apps.push_back(std::move(app));
    }

  private:
    std::unique_ptr<User> user;

    // Note that in C++ the collection needs to be typed, while in component
    // terms all components share a base type.
    std::vector<App> apps;
};

interface User {
  String GetName();
}

class Session {
    final User user;
    final List<Object> apps = [];
    Session() :  user = /* initialize user */;

    // Similar to how all components share a "base type", Dart's Object
    // type can be dynamically cast to a desired interface.
    //
    // Casting will fail if the Object does not implement the type
    // requested, similar to how connecting to a non-exposed capability
    // fails for a component.
    void AddApp(Object app) {
      apps.add(app);
    }
}

pub trait User {
    fn get_name() -> String;
}

pub trait App {
  /* ... */
}

pub struct Session {
  user: User,

  // Note that in Rust the collection needs to be typed, while in component
  // terms all components share a base type.
  apps: Vec<Box<dyn App>>;
}

impl Session {
  pub fn new() -> Self {
    Self{ user: /* initialize user */, apps: Vec::new() }
  }

  pub fn add_app(&mut self, app: Box<dyn App>) {
    self.apps.push(app);
  }
}

interface User {
  String GetName();
}

class Session {
    private User user;
    private List<Object> apps = new ArrayList<Object>();

    public Session() {
      user = /* initialize user */;
    }

    // Similar to how all components share a "base type", Java's Object
    // type can be dynamically cast to a desired interface.
    //
    // Casting will fail if the Object does not implement the type
    // requested, similar to how connecting to a non-exposed capability
    // fails for a component.
    public void AddApp(Object app) {
      apps.add(app);
    }
}

// Create a plain old data type for Item.
struct Item {
  uint64_t id;
  std::string name;
  uint32_t price_in_cents;
  uint32_t quantity_in_stock;
};

// Enumerate the return values of cart operations.
enum CartResult {
  OK = 0,
  PAYMENT_FAILURE = 1,
  NOT_ENOUGH_IN_STOCK = 2,
};

class Cart {
  public:
    // Cart is owned by a store, and it requires the pointer back to
    // its owner to implement Checkout.
    Cart(Store* store);

    // Adding items and coupon codes cannot fail.
    void AddItem(uint64_t item_id, uint32_t quantity);
    void AddCouponCode(std::string code);

    // Perform the checkout operation by acting upon store_ in some way.
    CartResult Checkout();

  private:
    // Create an inner class representing the pair of item id and quantity.
    struct ItemQuantity {
      uint64_t item_id;
      uint32_t quantity;
    };

    // The parent store, not owned.
    Store* store_;
    std::vector<ItemQuantity> item_requests_;
    std::vector<std::string> coupon_codes_;
};

// Enumerate return values of store operations.
enum StoreResult {
  OK = 0,
  ITEM_NOT_FOUND = 1,
};

class Store {
  public:
    // Add new items to the store.
    void AddItem(Item item);

    // Set properties of items based on id.
    StoreResult SetPrice(uint64_t item_id, uint32_t new_price);
    StoreResult AddStock(uint64_t item_id, int32_t additional_quantity);

    // Create a new Cart for this store, referencing the Store that owns the Cart.
    // Carts are owned by a store, and must be deleted before the Store is.
    Cart* CreateCart() {
      carts_.emplace_back(Cart(this));
      return &cards_.back();
    }
  private:
    std::vector<Item> items_;
    std::vector<Cart> carts_;
};

// Create a class containing the data for items.
class Item {
  final int id;
  final String name;
  int priceInCents;
  int quantityInStock;

  Item({
    required this.id,
    required this.name,
    required this.priceInCents,
    this.quantityInStock = 0
  });
}

// Since Dart doesn't have tuples, create a pair type for id and quantity.
class ItemQuantity {
  final int itemId;
  int quantity;

  ItemQuantity({required this.itemId, required this.quantity});
}

// Represent the various results for cart operations.
enum CartResult {
  ok,
  paymentFailure,
  notEnoughInStock,
}

class Cart {
  final Store store;

  final List<ItemQuantity> _items = [];
  final List<String> _couponCodes = [];

  // A Cart needs to refer back to its Store to implement Checkout.
  Cart({required this.store});

  void AddItem(int itemId, int quantity) {
    _items.add(ItemQuantity(itemId: itemId, quantity: quantity);
  }

  void AddCouponCode(String code) {
    _couponCodes.add(code);
  }

  CartResult Checkout() { /* ... */ }
}

// Represent the results for store operations.
enum StoreResult {
  ok,
  itemNotFound,
}

class Store {
  final List<Item> _items = [];
  final List<Cart> _carts = [];

  void AddItem(Item item) { _items.add(item); }

  StoreResult SetPrice(int item_id, int new_price) { /* ... */ }
  StoreResult AddStock(int item_id, int additional_quantity) { /* ... */ }

  // Create a cart that refers back to this owning store.
  Cart CreateCart() {
    var ret = Cart(this);
    _carts.add(ret);
    return ret;
  }
}

// Create a data struct for Item information.
pub struct Item {
  pub id: u64,
  pub name: String,
  pub price_in_cents: u32,
  pub quantity_in_stock: u32,
}

pub struct Cart {
  // Carts need to act on their parent Store, but we want to avoid cyclic references.
  // Use a Weak pointer so that the Store can be deleted independent of its Carts.
  // Mutex is used for interior mutability.
  store: Weak<Mutex<Store>>,
  items: Vec<(u64, u32)>,
  coupon_codes: Vec<String>,
}

impl Cart {
  pub fn new(store: Weak<Mutex<Store>>) -> Self {
    Self {
      store,
      items: vec![],
      coupon_codes: vec![],
    }
  }

  pub fn add_item(&mut self, item_id: u64, quantity: u32) {
    self.items.push((item_id, quantity));
  }

  pub fn add_coupon_code(&mut self, code: String) {
    self.coupon_codes.push(code);
  }

  // Checkout consumes the Cart builder and returns the result.
  pub fn checkout(self) -> Result<(), Error> { /* ... */ }
}

pub struct Store {
  items: Vec<Item>,

  // Note that we do not need to maintain ownership over Carts, since
  // they can exist independent of the Store they are from. Checkout will
  // presumably fail if the Store was deleted before it is called.
}

impl Store {
  pub fn new() -> Arc<Mutex<Self>> {
    Arc::new(Mutex::new(Self {
      items: vec![],
      carts: vec![],
    }));
  }

  pub fn add_item(&mut self, item: Item) { items.push(item); }
  pub fn set_price(&mut self, item_id: u64, new_price: u32) -> Result<(), Error> { /* ... */ }
  pub fn add_stock(&mut self, item_id: u64, additional_quantity: i32) -> Result<(), Error> { /* ... */ }

  pub fn create_cart(self_: Arc<Mutex<Self>>) -> Cart {
    Cart::new(self_.downgrade())
  }
}

// Create a class containing the data for items.
public class Item {
  public int id;
  public String name;
  public int priceInCents;
  public int quantityInStock;
}

// Since Java doesn't have tuples, create a pair type for id and quantity.
class ItemQuantity {
  public int item_id;
  public int quantity;

  public ItemQuantity(int item_id, int quantity) {
    this.item_id = item_id;
    this.quantity = quantity;
  }
}

// Represent the various results for cart operations.
public enum CartResult {
  OK,
  PAYMENT_FAILURE,
  NOT_ENOUGH_IN_STOCK,
}

// Represent the results for store operations.
enum StoreResult {
  ok,
  itemNotFound,
}

class Store {
  private final List<Item> items = new ArrayList<Item>();
  private final List<Cart> carts = new ArrayList<Cart>();

  public void AddItem(Item item) { items.add(item); }

  public StoreResult SetPrice(int item_id, int new_price) { /* ... */ }
  public StoreResult AddStock(int item_id, int additional_quantity) { /* ... */ }

  public Cart CreateCart() {
    Cart ret = new Cart();
    carts.add(ret);
    return ret;
  }

  // Inner classes in Java can refer to their containing class.
  // This is needed to Checkout can act upon Store.this.
  public class Cart {
    private final List<ItemQuantity> items = new ArrayList<ItemQuantity>();
    private final List<String> couponCodes = new ArrayList<String>();

    void AddItem(int item_id, int quantity) {
      _items.add(ItemQuantity(item_id, quantity));
    }

    void AddCouponCode(String code) {
      _couponCodes.add(code);
    }

    CartResult Checkout() { /* ... */ }
  }
}

class Purchaser final {
  public:
    // Purchaser takes as input the credit card charger to use.
    Purchaser(CreditCardCharger* credit_card_charger) :
      credit_card_charger_(credit_card_charger) {}
    PurchaseError Purchase(std::string item_name, std::string credit_card) {
      /* ... */
      // Use the injected credit card charger when needed.
      credit_card_charger_->Charge(std::move(credit_card), /* amount */);
      /* ... */
    }
  private:
    CreditCardCharger* credit_card_charger_;
};

// Abstract base class for concrete credit card chargers.
class CreditCardCharger {
  public:
    virtual bool Charge(std::string credit_card, int amount) = 0;
};

class RealCreditCardCharger : public CreditCardCharger {
  public:
    bool Charge(std::string credit_card, int amount) override {
      /* actually charge credit cards somehow */
    }
};

class MockCreditCardCharger : public CreditCardCharger {
  public:
    // Mock implementation of CreditCardCharger::Charge that returns
    // a configurable error value and records the arguments of its
    // previous call.
    bool Charge(std::string credit_card, int amount) override {
      calls_++;
      last_credit_card_ = std::move(credit_card);
      last_amount_ = amount;
      return return_value_;
    }

    // Set the value that will be returned when calling Charge
    void SetReturnValue(bool return_value) { return_value_ = return_value; }

    // Get the parameters of the last call to Charge.
    const std::string& GetLastCreditCard() const { return last_credit_card_; }
    int GetLastAmount() const { return last_amount_; }
    size_t GetCallCount() const { return calls_; }

  private:
    bool return_value_ = true;
    size_t calls_ = 0;
    std::string last_credit_card_;
    int last_amount_ = 0;
};

// Production code
int main() {
  auto charger = std::make_unique<RealCreditCardCharger>();
  Purchaser purchaser(charger.get());
  // use purchaser in the program flow

  /* ... */
}

// Test code (assuming GoogleTest)
TEST(Purchaser, Success) {
  // Test that a purchase can succeed.
  // We expect that when a purchase is completed for an item costing
  // $100 that the CreditCardCharger is called with amount = 100.
  auto charger = std::make_unique<MockCreditCardCharger>();
  Purchaser purchaser(charger.get());
  EXPECT_EQ(PurchaseResult::OK, purchaser.Purchase("Item costing $100", "1234567890"));
  EXPECT_EQ(1, charger->GetCallCount());
  EXPECT_EQ("1234567890", charger->GetLastCreditCard());
  EXPECT_EQ(100, charger->GetLastAmount());
}

TEST(Purchaser, ItemNotFound) {
  // Test that we do not actually try to charge a credit card if the item is not found.
  auto charger = std::make_unique<MockCreditCardCharger>();
  Purchaser purchaser(charger.get());
  EXPECT_EQ(PurchaseResult::ITEM_NOT_FOUND, purchaser.Purchase("Not found item", "1234567890"));
  EXPECT_EQ(0, charger->GetCallCount());
}

TEST(Purchaser, CardChargeFailure) {
  // Test that a purchase can fail.
  auto charger = std::make_unique<MockCreditCardCharger>();
  Purchaser purchaser(charger.get());
  charger->SetReturnValue(false);
  EXPECT_EQ(PurchaseResult::CREDIT_CARD_FAILURE,
            purchaser.Purchase("Item costing $100", "1234567890"));
  EXPECT_EQ(1, charger->GetCallCount());
  EXPECT_EQ("1234567890", charger->GetLastCreditCard());
  EXPECT_EQ(100, charger->GetLastAmount());
}

class Purchaser {
  final CreditCardCharger creditCardCharger;

  // Purchaser takes as input the credit card charger to use.
  Purchaser({required this.creditCardCharger});
  PurchaseError Purchase(String itemName, String creditCard) {
    /* ... */
    // Use the injected credit card charger when needed.
    creditCardCharger.Charge(creditCard, /* amount */);
    /* ... */
  }
};

// Abstract base class for concrete credit card chargers.
abstract class CreditCardCharger {
  bool Charge(String creditCard, int amount);
};

class RealCreditCardCharger implements CreditCardCharger {
  @override
  bool Charge(String creditCard, int amount) {
    /* actually charge credit cards somehow */
  }
};

class MockCreditCardCharger implements CreditCardCharger {
  bool _returnValue = true;
  int _calls = 0;
  String _lastCreditCard = '';
  int _lastAmount = 0;

  // Mock implementation of CreditCardCharger::Charge that returns
  // a configurable error value and records the arguments of its
  // previous call.
  @override
  bool Charge(String creditCard, int amount) {
    _calls++;
    _lastCreditCard = creditCard;
    _lastAmount = amount;
    return _returnValue;
  }

  // Set the value that will be returned when calling Charge
  void set returnValue(int v) {
    _returnValue = v;
  }

  // Get the parameters of the last call to Charge.
  int get calls => _calls;
  String get lastCreditCard => _lastCreditCard;
  int get lastAmount => _lastAmount;
};

// Production code
void main() {
  final charger = RealCreditCardCharger();
  Purchaser purchaser(creditCardCharger: charger);
  // use purchaser in the program flow

  /* ... */
}

// Test code (assuming package:test)
import 'package:test/test.dart';

void main() {
  group('Purchaser', () {
    test('succeeds', () {
      // Test that a purchase can succeed.
      // We expect that when a purchase is completed for an item costing
      // $100 that the CreditCardCharger is called with amount = 100.
      final charger = MockCreditCardCharger();
      final purchaser = Purchaser(creditCardCharger: charger);

      expect(purchaser.Purchase("Item costing $100", "1234567890"), PurchaseResult.ok);
      expect(charger.calls, 1);
      expect(charger.lastCreditCard, "1234567890");
      expect(charger.amount, 100);
    });

    test('fails when item is not found', () {
      // Test that we do not actually try to charge a credit card if the item is not found.
      final charger = MockCreditCardCharger();
      final purchaser = Purchaser(creditCardCharger: charger);

      expect(purchaser.Purchase("Not found item", "1234567890"), PurchaseResult.itemNotFound);
      expect(charger.calls, 0);
    });

    test('fails when card cannot be charged', () {
      // Test that a purchase can fail.
      final charger = MockCreditCardCharger();
      final purchaser = Purchaser(creditCardCharger: charger);

      charger.returnValue = false;
      expect(purchaser.Purchase("Item costing $100", "1234567890"), PurchaseResult.creditCardFailure);
      expect(charger.calls, 1);
      expect(charger.lastCreditCard, "1234567890");
      expect(charger.amount, 100);
    });
  });
}

pub struct Purchaser {
  credit_card_charger: Box<dyn CreditCardCharger>,
}

impl Purchaser {
  // Purchaser takes as input the credit card charger to use.
  pub fn new(credit_card_charger: Box<dyn CreditCardCharger>) -> Self {
    Self { credit_card_charger }
  }

  pub fn purchase(&mut self, item_name: String, credit_card: String) {
    /* ... */
    // Use the injected credit card charger when needed.
    self.credit_card_charger.charge(creditCard, /* amount */);
    /* ... */
  }

  // For testing only, allow a Purchaser to be destroyed and converted
  // back to it CreditCardCharger.
  //
  // Alternatively, we could take a non-owning reference to the dependency.
  #[cfg(test)]
  pub fn to_charger(mut self) -> Box<dyn CreditCardCharger> {
    self.credit_card_charger
  }
}

// Trait implemented by concrete credit card chargers.
trait CreditCardCharger {
  fn charge(credit_card: String, amount: i32) -> bool;
}

struct RealCreditCardCharger {}

impl CreditCardCharger for RealCreditCardCharger {
  fn charge(&mut self, credit_card: String, amount: i32) -> bool {
    /* actually charge credit cards somehow */
  }
};

// Mock implementation of CreditCardCharger that returns
// a configurable error value and records the arguments of its
// previous call.
pub struct MockCreditCardCharger {
  return_value: bool,
  calls: usize,
  last_credit_card: Option<String>,
  last_amount: Option<i32>,
}

impl MockCreditCardCharger {
  pub fn new() -> Self {
    Self {
      return_value: true,
      calls: 0,
      last_credit_card: None,
      last_amount: None,
    }
  }

  // Set the value that will be returned when calling charge
  pub fn set_return_value(&mut self, return_value: bool) {
    self.return_value = return_value;
  }

  // Get the parameters of the last call to charge.

  pub fn get_last_credit_card<'a>(&'a self) -> Option<&'a str> {
    self.last_credit_card.as_deref()
  }

  pub fn get_last_amount(&self) -> Option<i32> {
    self.last_amount.clone()
  }

  pub fn get_calls(&self) -> usize {
    self.calls
  }
}

impl CreditCardCharger for MockCreditCardCharger {
  fn charge(&mut self, credit_card: String, amount: i32) -> bool {
    self.calls += 1;
    self.last_credit_card = Some(credit_card);
    self.last_amount = Some(amount);
    self.return_value
  }
}

// Production code
fn main() {
  let mut purchaser = Purchaser::new(Box::new(RealCreditCardCharger::new()));
  // use purchaser in the program flow
  /* ... */
}

// Test code (assuming Rust tests)

#[cfg(test)]
mod tests {
  #[test]
  fn success() {
    // Test that a purchase can succeed.
    // We expect that when a purchase is completed for an item costing
    // $100 that the CreditCardCharger is called with amount = 100.
    let mut purchaser = Purchaser::new(Box::new(MockCreditCardCharger::new()));
    assert_eq!(purchaser.purchase("Item costing $100", "1234567890"), PurchaseResult::OK);
    let charger = purchaser.to_charger();
    assert_eq!(charger.get_calls(), 1);
    assert_eq!(charger.get_last_credit_card(), Some("1234567890"));
    assert_eq!(charger.get_last_amount, Some(100i32));
  }

  #[test]
  fn item_not_found() {
    // Test that we do not actually try to charge a credit card if the item is not found.
    let mut purchaser = Purchaser::new(Box::new(MockCreditCardCharger::new()));
    assert_eq!(purchaser.purchase("Item costing $100", "1234567890"), PurchaseResult.ok);
    let charger = purchaser.to_charger();

    assert_eq!(purchaser.purchase("Not found item", "1234567890"), PurchaseResult::ITEM_NOT_FOUND);
    let charger = purchaser.to_charger();
    assert_eq!(charger.get_calls(), 0);
  }

  #[test]
  fn card_charge_fails() {
    // Test that a purchase can fail.

    let mut charger = Box::new(MockCreditCardCharger::new());
    charger.set_return_value(false);
    let mut purchaser = Purchaser::new(charger);
    assert_eq!(purchaser.purchase("Item costing $100", "1234567890"), PurchaseResult::CREDIT_CARD_FAILURE);
    let charger = purchaser.to_charger();

    assert_eq!(charger.get_calls(), 1);
    assert_eq!(charger.get_last_credit_card(), Some("1234567890"));
    assert_eq!(charger.get_last_amount, Some(100i32));
  }
}

class Purchaser {
  private CreditCardCharger creditCardCharger;

  // Purchaser takes as input the credit card charger to use.
  public Purchaser(CreditCardCharger creditCardCharger) {
    this.creditCardCharger = creditCardCharger;
  }

  public PurchaseError Purchase(String itemName, String creditCard) {
    /* ... */
    // Use the injected credit card charger when needed.
    creditCardCharger.Charge(creditCard, /* amount */);
    /* ... */
  }
};

// Interface for concrete credit card chargers.
interface CreditCardCharger {
  public boolean Charge(String creditCard, int amount);
};

class RealCreditCardCharger implements CreditCardCharger {
  @Override
  boolean Charge(String creditCard, int amount) {
    /* actually charge credit cards somehow */
  }
};

class MockCreditCardCharger implements CreditCardCharger {
  private boolean returnValue = true;
  private int calls = 0;
  private String lastCreditCard = '';
  private int lastAmount = 0;

  // Mock implementation of CreditCardCharger::Charge that returns
  // a configurable error value and records the arguments of its
  // previous call.
  @override
  public boolean Charge(String creditCard, int amount) {
    calls++;
    lastCreditCard = creditCard;
    lastAmount = amount;
    return returnValue;
  }

  // Set the value that will be returned when calling Charge
  public void setReturnValue(int v) {
    returnValue = v;
  }

  // Get the parameters of the last call to Charge.
  public int getCalls() { return calls; }
  public String getLastCreditCard() { return lastCreditCard; }
  public int getLastAmount() { return lastAmount; }
};

// Production code
void main() {
  CreditCardCharger charger = new RealCreditCardCharger();
  Purchaser purchaser = new Purchaser(charger);
  // use purchaser in the program flow

  /* ... */
}

// Test code (assuming JUnit)

public class PurchaserTest extends TestCase {
  protected MockCreditCardCharger charger;
  protected Purchaser purchaser;

  protected void setUp() {
    charger = new MockCreditCardCharger();
    purchaser = new Purchaser(charger);
  }

  public void testPurchaseSucceeds() {
    // Test that a purchase can succeed.
    // We expect that when a purchase is completed for an item costing
    // $100 that the CreditCardCharger is called with amount = 100.
    assertEquals(purchaser.Purchase("Item costing $100", "1234567890"), PurchaseResult.OK);
    assertEquals(charger.getCalls(), 1);
    assertEquals(charger.getLastCreditCard(), "1234567890");
    assertEquals(charger.getLastAmount(), 100);
  }

  public void testItemNotFoundError() {
    // Test that we do not actually try to charge a credit card if the item is not found.

    assertEquals(purchaser.Purchase("Not found item", "1234567890"), PurchaseResult.ITEM_NOT_FOUND);
    assertEquals(charger.getCalls(), 0);
  }

  public void testCardChargeFailure() {
    // Test that a purchase can fail.

    charger.returnValue = false;
    assertEquals(purchaser.Purchase("Item costing $100", "1234567890"), PurchaseResult.CREDIT_CARD_FAILURE);
    assertEquals(charger.getCalls(), 1);
    assertEquals(charger.getLastCreditCard(), "1234567890");
    assertEquals(charger.getLastAmount(), 100);
  }
}