chain of responsibility added

Author: maciej-nowak

chain-responsibility/README.md

@@ -0,0 +1,2 @@
+# chain-responsibility
+This is repository of http://androidcode.pl blog. It shows uses of Chain of responsibility pattern in Android. It is a part of Design Patterns - Chain of responsibility post in the blog. 

chain-responsibility/example/Main.java

@@ -0,0 +1,52 @@
+public class Main {
+
+    public static void main() {
+        //create default nominals scheme
+        Nominal nominal100 = new ConcreteNominal(100);
+        Nominal nominal50 = new ConcreteNominal(50);
+        Nominal nominal20 = new ConcreteNominal(20);
+        Nominal nominal10 = new ConcreteNominal(10)
+        Nominal nominal5 = new ConcreteNominal(5);
+        Nominal nominal2 = new ConcreteNominal(2);
+        Nominal nominal1 = new ConcreteNominal(1);
+
+        //cashier gets client's transaction
+        Exchange transaction1 = new Exchange(1500, Currency.PLN, Currency.USD);
+
+        //cashier defines default nominals scheme
+        nominal100.setSuccessor(nominal50);
+        nominal50.setSuccessor(nominal20);
+        nominal20.setSuccessor(nominal10);
+        nominal10.setSuccessor(nominal5);
+        nominal5.setSuccessor(nominal2);
+        nominal2.setSuccessor(nominal1);
+
+        //simulate transaction
+        Exchange result1 = nominal100.calculate(transaction1);
+        if(result.getLeftAmount() == 0) {
+            //success - can withdraw
+        }
+        else {
+            //fail - can not withdraw this transaction based on current nominals scheme
+        }
+        //show nominals to withdraw
+        result.getOperations();
+        //for course 3.67 the result is:
+        //4x100, 1x5, 1x2, 1x1
+
+        //cashier gets new transaction
+        Exchange transaction2 = new Exchange(5000, Currency.USD, Currency.GBP);
+        //nominals GBP are the same like USD so no need to update the chain
+
+        //in deposit there is a lot of nominal 1
+        //so cashier wants to spent nominal 1 before nominal 5 and 2
+        nominal10.setSuccessor(nominal1);
+        nominal1.setSuccessor(nominal2);
+        nominal2.setSuccessor(nominal5);
+
+        //simulate transaction like above
+        nominal100.calculate(transaction2);
+        //for course 0.761 and 100x20, 50x30, 10x20 nominals available in deposit to withdraw the result is:
+        //20x100, 30x50, 10x20, 10x10, 5x1 
+    }
+}

chain-responsibility/example/dummy/Currency.java

@@ -0,0 +1,14 @@
+public enum Currency {
+
+    PLN(1),
+    USD(2),
+    GBP(3),
+    EUR(4);
+    //more currencies
+
+    private int currency;
+
+    public Currency(int currency) {
+        this.currency = currency;
+    }
+}

chain-responsibility/example/dummy/Exchange.java

@@ -0,0 +1,34 @@
+public class Exchange {
+
+	private int amount;
+	private int leftAmount;
+	private double cours;
+	private String operations;
+	private Currency start;
+	private Currency target;
+
+	public Exchange(int amount, Currency start, Currency target) {
+		this.amount = amount;
+		this.start = start;
+		this.target = target;
+		//get cours from outside between currencies start and target
+		leftAmount = amount * course;
+		operations = "";
+	}
+
+	public int getLeftAmount() {
+		return leftAmount;
+	}
+
+	public void setLeftAmount(int left) {
+		this.leftAmount = left;
+	}
+
+	public void addOperation(String operation) {
+		operations += operation + "\n";
+	}
+
+	public String getOperations() {
+		return operations;
+	}
+}

chain-responsibility/example/handlers/ConcreteNominal.java

@@ -0,0 +1,31 @@
+public class ConcreteNominal extends Nominal {
+
+    private final int NOMINAL;
+
+    public Nominal(int nominal) {
+    	this.NOMINAL = nominal;
+    }
+
+    @Override
+    protected void withdraw(Exchange transaction) {
+        if(transaction.getLeftAmount() >= NOMINAL) {
+        	int count = transaction.getLeftAmount() / NOMINAL;
+        	int rest = transaction.getLeftAmount() % NOMINAL;
+        	transaction.setLeftAmount(rest);
+        	transaction.addOperation(count + " x Nominal " + NOMINAL);
+        }
+    }
+
+    @Override
+    protected boolean canWithdraw(Exchange transaction) {
+        if(transaction.getLeftAmount() >= NOMINAL && isDepositEnough(transaction))
+            return true;
+        else
+            return false;
+    }
+
+    private boolean isDepositEnough(Exchange transaction) {
+    	//check is concrete nominal enough in deposit 
+    	return true; //mocked
+    }
+}

chain-responsibility/example/handlers/Nominal.java

@@ -0,0 +1,23 @@
+public abstract class Nominal {
+
+    protected Nominal successor;
+    //some fields
+
+    protected abstract void withdraw(Exchange transaction);
+    protected abstract boolean canWithdraw(Exchange transaction);
+
+    public void setSuccessor(Nominal successor) {
+        this.successor = successor;
+    }
+
+    public Exchange calculate(Exchange transaction) {
+        if(canWithdraw(transaction))
+            withdraw(transaction);
+        if(transaction.getLeftAmount() > 0 && successor != null)
+            return successor.calculate(transaction);
+        else
+            return transaction;
+    }
+
+    //some other methods
+}

chain-responsibility/pattern/Main.java

@@ -0,0 +1,18 @@
+public class Main {
+
+	public static void main() {
+		//create chain of responsibility depends
+		Handler main = new ConcreteHandler1();
+		Handler handler2 = new ConcreteHandler2();
+		Handler handler3 = new ConcreteHandler3();
+		main.setSuccessor(handler2);
+		handler2.setSuccessor(handler3);
+
+		//carry out request to chain
+		Request request1 = new Request("Content", Type.TYPE2);
+		main.handle(request1); //handler2 will act
+
+		Request request2 = new Request("Content", Type.TYPE4);
+		main.handle(request2); //no handler acts
+	}
+}

chain-responsibility/pattern/dummy/Request.java

@@ -0,0 +1,37 @@
+public class Request {
+
+	private String content;
+	private Type type;
+	//other fields
+
+	public Request(String content, Type type) {
+		this.content = content;
+		this.type = type;
+	}
+
+	public String getContent() {
+		return content;
+	}
+
+	public Type getType() {
+		return type;
+	}
+
+	//other methods
+
+	public enum Type {
+
+		TYPE1(1),
+		TYPE2(2),
+		TYPE3(3),
+		TYPE4(4),
+		TYPE5(5);
+		//other types
+
+		private int type;
+
+		public Type(int type) {
+			this.type = type;
+		}
+	}
+}

chain-responsibility/pattern/handlers/ConcreteHandler1.java

@@ -0,0 +1,15 @@
+public class ConcreteHandler1 extends Handler {
+
+    @Override
+    protected void action(Request request) {
+        //do specific action for ConcreteHandler1
+    }
+
+    @Override
+    protected boolean canExecute(Request request) {
+        if(request.getType() == Type.TYPE1)
+            return true;
+        else
+            return false;
+    }
+}

chain-responsibility/pattern/handlers/ConcreteHandler2.java

@@ -0,0 +1,15 @@
+public class ConcreteHandler2 extends Handler {
+
+    @Override
+    protected void action(Request request) {
+        //do specific action for ConcreteHandler2
+    }
+
+    @Override
+    protected boolean canExecute(Request request) {
+        if(request.getType() == Type.TYPE2)
+            return true;
+        else
+            return false;
+    }
+}

chain-responsibility/pattern/handlers/ConcreteHandler3.java

@@ -0,0 +1,15 @@
+public class ConcreteHandler3 extends Handler {
+
+    @Override
+    protected void action(Request request) {
+        //do specific action for ConcreteHandler3
+    }
+
+    @Override
+    protected boolean canExecute(Request request) {
+        if(request.getType() == Type.TYPE3)
+            return true;
+        else
+            return false;
+    }
+}

chain-responsibility/pattern/handlers/Handler.java

@@ -0,0 +1,21 @@
+public abstract class Handler {
+
+    protected Handler successor;
+    //some fields
+
+    protected abstract void action(Request request);
+    protected abstract boolean canExecute(Request request);
+
+    public void setSuccessor(Handler successor) {
+        this.successor = successor;
+    }
+
+    public void handle(Request request) {
+        if(canExecute(request))
+            action(request);
+        else if(successor != null)
+            successor.handle(request);
+    }
+
+    //some other methods
+}