add some missing example files written years ago but not committed to git

Author: mbrowne

samples/dci/typescript/Dijkstra/CalculateShortestPath.ts

@@ -0,0 +1,122 @@
+import DCI = require('../../DCI');
+import HashMap = require('../../typescript/Dijkstra/HashMap');
+
+export = CalculateShortestPath;
+
+/**
+ * Calculate the shortest path between two points using the Dijkstra algorithm.
+ * This javascript version was based on an earlier (non-TypeScript)  implementation by Egon Elbre.
+ */
+var CalculateShortestPath = DCI.Context.extend(function() {
+	
+	this.bindRoles = function(initial, destination, graph) {
+		Initial <- initial;
+		Graph <- graph;
+		Tentative <- new HashMap();
+		Unvisited <- new HashMap();
+		Path <- new HashMap(); // best path (to --> from)
+		
+		this.destination = destination;
+	}
+	
+	//Run the use case
+	this.run = function() {	
+		Graph.nodes.each(function(node) {
+			Unvisited.put(node);
+			Tentative.put(node, Infinity);
+		});
+		Tentative.put(Initial, 0);
+		
+		Current = Initial;
+		Current.markVisited();
+
+		while (!Unvisited.isEmpty()) {
+		  Current.relaxDistances();
+		  Current.markVisited();
+
+		  if (!Unvisited.has(this.destination)) break;
+
+		  Current = Unvisited.findNearest();
+		  if (Current === undefined) break;
+		}		
+		return Path.to(this.destination);
+	}
+	
+	role Initial {}
+	
+	role Neighbor {
+		visited() {		
+			return !Unvisited.has(this);
+		}
+	}
+	
+	role Current {
+		markVisited() {
+			Unvisited.remove(this);
+		}
+		
+		getNeighbors() {
+			return Graph.neighbors(this);
+		}
+		
+		relaxDistances() {
+			self.getNeighbors().each(function(node) {
+				Neighbor <- node;
+				if (Neighbor.visited()) return;
+
+				var alternate = Tentative.get(self) + self.distanceTo(Neighbor);
+				if (alternate < Tentative.get(Neighbor)) {
+				  Tentative.put(Neighbor, alternate);
+				  Path.put(Neighbor, self);
+				}
+			});
+		}
+		
+		distanceTo(other) {
+			return Graph.distance(this, other);
+		}
+	}
+	
+	role Graph {
+		distance(from, to) {
+			if(from === to) return 0;
+			return self.nodes.get(from).get(to) || Infinity;
+		}
+	  
+		neighbors(node) {
+			return self.nodes.get(node);
+		}
+	}
+	
+	role Tentative {}
+	
+	role Unvisited {
+		findNearest() {		
+			var nearest = undefined,
+				distance = Infinity;
+			self.each(function(node) {
+				var dist = Tentative.get(node);
+				if(dist < distance) {
+					nearest = node;
+					distance = dist;
+				}
+			})
+			return nearest;
+		}
+	}
+	
+	role Path {
+		to(to) {
+			var path = [to],
+				cur = to;
+			while (cur != Initial) {
+				cur = self.get(cur);
+				path.unshift(cur);
+				if (cur === undefined) {
+					return undefined;
+				}
+			}
+			return path;
+		}
+	}
+});

samples/dci/typescript/Dijkstra/Graph.ts

@@ -0,0 +1,26 @@
+import HashMap = require('../../typescript/Dijkstra/HashMap');
+export = Graph;
+
+function Graph(edges) {
+  this.nodes = new HashMap();
+
+  for (var i = 0; i < edges.length; i++) {
+	  var edge = edges[i],
+		from = edge[0],
+		to = edge[1],
+		dist = edge[2];
+
+	  forceMap(this.nodes, to);
+	  var cur = forceMap(this.nodes, from);
+	  cur.put(to, dist);
+  }
+}
+
+function forceMap(nodes, node) {
+	var map = nodes.get(node);
+	if (map === undefined) {
+	  map = new HashMap();
+	  nodes.put(node, map);
+	}
+	return map;
+}

samples/dci/typescript/Dijkstra/HashMap.js

@@ -0,0 +1,40 @@
+import CalculateShortestPath = require('./CalculateShortestPath');
+import Graph = require('./Graph');
+
+var a = {id:'a'},
+	b = {id:'b'},
+	c = {id:'c'},
+	d = {id:'d'},
+	e = {id:'e'},
+	f = {id:'f'},
+	g = {id:'g'},
+	h = {id:'h'},
+	i = {id:'i'};
+
+var edges = [
+	[a,b,2],
+	[a,d,1],
+	[b,c,3],
+	[b,e,2],
+	[c,f,1],
+	[d,e,1],
+	[d,g,2],
+	[e,f,1],
+	[f,i,4],
+	[g,h,1],
+	[h,i,2]
+];
+
+var graph = new Graph(edges);
+var ctx = new CalculateShortestPath(a, i, graph);
+
+//Run the use case
+var path = ctx.run();
+
+var proper = [];
+
+path.forEach(function(node) {
+	proper.push(node.id);
+});
+
+console.log(proper.join(" -> "));

samples/dci/typescript/Dijkstra/index.ts

@@ -0,0 +1,42 @@
+import DCI = require('../../DCI');
+
+export = Account;
+
+var Account = DCI.Context.extend(function(ledgers) {
+	if (!ledgers) ledgers = [];
+	Ledgers <- ledgers;
+	
+	this.increaseBalance = function(amount) {
+		Ledgers.addEntry('depositing', amount);
+	};
+	
+	this.decreaseBalance = function(amount) {
+		Ledgers.addEntry('withdrawing', 0 - amount);		
+	};
+	
+	this.getBalance = function() {
+		return Ledgers.getBalance();
+	}
+	
+	role Ledgers {
+		addEntry(message, amount) {
+			Ledgers.push(new LedgerEntry(message, amount));
+		}
+		
+		getBalance() {
+			var sum = 0;
+			Ledgers.forEach(function(ledgerEntry) {
+				sum += ledgerEntry.amount;
+			});
+			return sum;
+		}
+	}
+});
+
+function LedgerEntry(message, amount) {
+	this.message = message;
+	this.amount = amount;
+}
+
+//export the LedgerEntry constructor
+Account.LedgerEntry = LedgerEntry;

samples/dci/typescript/TransferMoney/Account.ts

@@ -1,18 +1,24 @@
 import DCI = require('../../DCI');
 
-export class TransferMoney extends DCI.Context
+//IN PROGRESS
+//if needed in the meantime we can use a class that extends DCI.Context instead
+export context TransferMoney
 {
 	/**
 	 * @param {Account} sourceAcct
 	 * @param {Account} destinationAcct
 	 * @param {number} amount
 	 */
-	bindRoles(sourceAcct, destinationAcct, amount) {
+	bindRoles(sourceAcct: Account, destinationAcct: Account, amount: int) {
 		SourceAccount <- sourceAcct;
 		DestinationAccount <- destinationAcct;
 		Amount <- amount;
 	}
 
+	run() {
+		SourceAccount.transferOut();
+	}
+	
 	role SourceAccount {	
 
 		//transfer money out of this account and into the destination account

samples/dci/typescript/TransferMoney/TransferMoney.ts

@@ -0,0 +1,14 @@
+import Account = require('./Account');
+import TransferMoney = require('./TransferMoney');
+
+var sourceAccount = new Account();
+sourceAccount.increaseBalance(20);
+
+var destinationAccount = new Account();
+destinationAccount.increaseBalance(10);
+
+//run the use case
+TransferMoney(sourceAccount, destinationAccount, 10);
+
+console.log(sourceAccount.getBalance());
+console.log(destinationAccount.getBalance());