ciscoheat / haxedci Goto Github PK

@role var PLAYER {
  var x : Int;
  var y : Int;

  function moveTo(x, y) {
    SELF.x = x;
    SELF.y = y;
  }

package;

class Main {
    static public function main() {
        var acc1 = new AccountContext([]);

        acc1.deposit(10);
        acc1.deposit(15.5);
        acc1.withdraw(7);

        var acc2 = new AccountContext([]);

        var moneyTransfer = new MoneyTransferContext(acc1, acc2);
        moneyTransfer.transfer(8.5);

        trace(acc1.getBalance());
        trace(acc2.getBalance());

        var accountMock = {
            deposit: function(amount: Float) {
                trace("Mocking");
            }
        };

        var moneyTransfer2 = new MoneyTransferContext(acc1, accountMock);
        moneyTransfer2.transfer(5);
    }
}

//
// AccountingEntry.hx

class AccountingEntry {
    public function new() {}

    public var amount(default, default) : Float;
    public var message(default, default) : String;
}

//
// AccountContext.hx

class AccountContext {
    var bookKeeper: BookKeeper;

    public function new(entries) {
        this.bookKeeper = entries;
    }

    public function getBalance() : Float {
        return bookKeeper.getBalance();
    }

    public function deposit(amount : Float) {
        trace("Depositing");
        bookKeeper.addEntry("Depositing", amount);
    }

    public function withdraw(amount : Float) {
        bookKeeper.addEntry("Withdrawing", -amount);
    }
}

abstract BookKeeper(Array<AccountingEntry>) from Array<AccountingEntry> {

    public function getBalance() : Float {
        return Lambda.fold(this, function(a, b) { return a.amount + b; }, 0.0);
    }

    public function addEntry(message : String, amount : Float) {
        var entry = new AccountingEntry();
        entry.amount = amount;
        entry.message = message;

        this.push(entry);
    }
}

//
// MoneyTransferContext.hx

class MoneyTransferContext {
    var sourceAccount : SourceAccount;
    var destinationAccount : DestinationAccount;

    public function new(source : SourceAccountActor, destination : DestinationAccountActor) {
        this.sourceAccount = source;
        this.destinationAccount = destination;
    }

    public function transfer(amount : Float) {
        sourceAccount.transferTo(destinationAccount, amount);
    }
}

typedef SourceAccountActor = {
    function getBalance() : Float;
    function withdraw(amount: Float) : Void;
}

typedef DestinationAccountActor = {
    function deposit(amount: Float) : Void;
}

abstract SourceAccount(SourceAccountActor) from SourceAccountActor {
    public function transferTo(destinationAccount : DestinationAccount, amount : Float) {
        if (this.getBalance() < amount) {
            throw "Insufficient funds";
        }

        this.withdraw(amount);
        destinationAccount.deposit(amount);
    }
}

@:forward(deposit)
abstract DestinationAccount(DestinationAccountActor) from DestinationAccountActor
{ }

class MyContext implements dci.Context {
    // ... partial code...
    @role var source : {
        function decreaseBalance(a : Int) : Void;

        function addSource() : Void {
            source.| // withdraw is not displayed here, because it's below addSource.
        }

        function withdraw() {
            self.decreaseBalance(Std.int(amount / 2));
            destination.deposit();
        }
    }
}