论面向组合子程序设计方法 之 微步毂纹生

rule1 = ...;
rule2 = ...;
rule3 = ...;
exclusive(rule1, rule2, rule3);;

rule1 = ...;
rule2 = ...;
rule3 = ...;
exclusive(rule1, rule2, rule3);;

package jfun.rule.generator;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.functor.UnaryFunction;
import org.apache.commons.functor.UnaryPredicate;
/** 
 * representing the Excluse ations,execute every action According to the order which joins until the condition 
 * return true based on the result of previouse executed action.
 * @author   firebody
 * @since    2006-1-8-12:49:33
 */
public class Exclusive implements UnaryFunction {
	private UnaryPredicate condition;
	public Exclusive(UnaryPredicate predicate); {
		super();;
		this.condition = predicate;
	}
	private List actions = new ArrayList();;
	/**
	 * 
	 * @param action
	 * @return
	 */
	public Exclusive addExclusiveAction(UnaryFunction action);{
		this.actions.add(action);;
		return this;
	}

	public Object evaluate(Object obj); {
		for(int i=0;i<actions.size();;i++);{
			UnaryFunction action = (UnaryFunction);actions.get(i);;
			Object result = action.evaluate(obj);;
			if(condition.test(result););
				return result;
		}
		return null;
	}

}

package jfun.rule.predicate;

import java.util.Iterator;
import java.util.Map;

import jfun.domain.Discount;
import jfun.rule.Util;

import org.apache.commons.functor.UnaryPredicate;
/** 
 * @author   firebody
 * @since    2006-1-8-13:02:58
 */
public class IsDiscounted implements UnaryPredicate {

	public IsDiscounted(); {
		super();;
		
	}
	private boolean hasDiscounts(Map discountTable);{
		for(Iterator iter = discountTable.values();.iterator();;iter.hasNext();;);{
			Discount discount = (Discount); iter.next();;
			if(discount.getDiscountPrice();>0);
				return true;
		}
		return false;
	}
	public boolean test(Object arg0); {
		Util.assertIsTypedArg(arg0,Map.class);;
		return hasDiscounts((Map);arg0);;
	}
	public static final IsDiscounted instance = new IsDiscounted();;

}

	//ajoo: exclusive discounts
	public static final UnaryFunction exclusiveDiscounts();{
		UnaryFunction A = discountType_A();;
		UnaryFunction B= discountType_B();;
		UnaryFunction C = discountType_C();;
		//(A+B);
		UnaryFunction composit1 = new CompositUnaryFunction(A);.add(AddDiscounts.INSTANCE,B);;
		//exclusive((A+B);,C); ,if (A+B); matched,then return it's result,else run the c action
		Exclusive exclusive = new Exclusive(IsDiscounted.instance);;
		exclusive.addExclusiveAction(composit1);.addExclusiveAction(C);;
		return exclusive;
		
	}

package jfun.rule.ajoo;

import jfun.rule.discountType.DiscountExp;
import jfun.rule.function.SetDiscount;
import jfun.rule.predicate.IsAllCommodity;

import org.apache.commons.functor.BinaryPredicate;
import org.apache.commons.functor.UnaryFunction;
import org.apache.commons.functor.UnaryPredicate;
import org.apache.commons.functor.adapter.RightBoundPredicate;
import org.apache.commons.functor.core.IsEqual;
import org.apache.commons.functor.core.composite.Composite;
import org.apache.commons.functor.core.composite.ConditionalUnaryFunction;
import org.apache.commons.functor.core.composite.UnaryAnd;

/** 
 * @author   firebody
 * @since    2006-1-8-17:13:38
 */
public class Rules {
	public Rules(); {
		super();;
		
	}
	public static final UnaryFunction rule3();{
		
		 return new ConditionalUnaryFunction(rule3_condition();,
				 DiscountExp.setDiscountCalculator(new SetDiscount(0.1););.addCondToDiscountedObjects(IsAllCommodity.instance);,DiscountExp.NODISCOUNT);;
	}
	public static final UnaryPredicate rule3_condition();{
		UnaryAnd conditions = new UnaryAnd();;
		//sex is femail
		UnaryPredicate cond1=constructUnaryPredicate(GetCustomerSex.instance,IsEqual.instance();,"femail");;
		//purchase date is 3/8
		UnaryFunction getDate = Composite.function(GetDate.instance,GetPurchaseDate.instance);;
		UnaryFunction getMonth = Composite.function(GetMonth.instance,GetPurchaseDate.instance);;
		return conditions.and(cond1);.
							and(constructUnaryPredicate(getMonth,IsEqual.instance();,new Integer(3);););.
								and(constructUnaryPredicate(getDate,IsEqual.instance();,new Integer(8);););;
	}
	/**
	 * shortcuit method to construct predicate.test(leftFunction.evaluate(obj);,rightConstant);
	 * @param leftFunction
	 * @param predivate
	 * @param constant
	 * @return
	 */
	static UnaryPredicate constructUnaryPredicate(UnaryFunction leftFunction,BinaryPredicate predicate,Object rightConstant);{
		return Composite.predicate(RightBoundPredicate.bind(predicate,rightConstant);,leftFunction);;
	}

}

public class Rule1 implements UnaryFunction,UnaryPredivate{
              public Object evaluate(Object arg);{
                    //.. your logic 
                    return result;
              }
              public Boolean test(Object arg);{
                      Object result = evaluate(arg);;
                      //your logic here
                         return true or false;
               }

}