[ERA-CVS] src/org/jdaemon/util/functional AbstractBinaryFunction.java, NONE, 1.1 AbstractBinaryOperator.java, NONE, 1.1 AbstractUnaryFunction.java, NONE, 1.1 AbstractUnaryOperator.java, NONE, 1.1 Arithmetic.java, NONE, 1.1 ArithmeticOperations.java, NONE, 1.1 Parameter.java, NONE, 1.1 BinaryFunction.java, 1.1, 1.2 CountFunction.java, 1.1, 1.2 MaxFunction.java, 1.1, 1.2 MinFunction.java, 1.1, 1.2 Operations.java, 1.4, 1.5 UnaryFunction.java, 1.1, 1.2

[<je...@23...>]

Update of /cvsroot/era/src/org/jdaemon/util/functional
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv12195/functional

Modified Files:
	BinaryFunction.java CountFunction.java MaxFunction.java 
	MinFunction.java Operations.java UnaryFunction.java 
Added Files:
	AbstractBinaryFunction.java AbstractBinaryOperator.java 
	AbstractUnaryFunction.java AbstractUnaryOperator.java 
	Arithmetic.java ArithmeticOperations.java Parameter.java 
Log Message:
Modifications for ERA v2 - this time it's Generic...



--- NEW FILE: AbstractBinaryFunction.java ---
package org.jdaemon.util.functional;

import org.jdaemon.util.expression.*;

public abstract class AbstractBinaryFunction<A, B, R> implements BinaryFunction<A,B,R> {

    public abstract R operate(A a, B b);
    
    public void write(ExpressionWriter out) throws OutputError {
        out.beginExpression(Expression.Type.FUNC);
        out.writeValue(getClass());
        out.writeParameter("a");
        out.writeParameter("b");
        out.endExpression(Expression.Type.FUNC);
    }
}

--- NEW FILE: AbstractBinaryOperator.java ---
package org.jdaemon.util.functional;

import org.jdaemon.util.expression.Expression;
import org.jdaemon.util.expression.ExpressionWriter;
import org.jdaemon.util.expression.OutputError;

abstract class AbstractBinaryOperator<A, B, R> implements BinaryFunction<A, B, R> {

    private Expression.Type type;

    public abstract R operate(A a, B b);

    public void write(ExpressionWriter out) throws OutputError {
        out.beginExpression(type);
        out.writeParameter("a");
        out.writeParameter("b");
        out.endExpression(type);
    }

    public AbstractBinaryOperator(Expression.Type type) {
        super();
        this.type = type;
    }
}

--- NEW FILE: AbstractUnaryFunction.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.util.functional;
import org.jdaemon.util.expression.*;

/**
 *
 * @author jonathan
 */
public abstract class AbstractUnaryFunction<A,R> implements UnaryFunction<A,R> {
    
    public abstract R operate(A value);
    
    public void write(ExpressionWriter writer) throws OutputError {
        writer.beginExpression(Expression.Type.FUNC);
        writer.writeValue(getClass());
        writer.writeParameter("value");
        writer.endExpression(Expression.Type.FUNC);
    }

}

--- NEW FILE: AbstractUnaryOperator.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.util.functional;

import org.jdaemon.util.expression.Expression;
import org.jdaemon.util.expression.ExpressionWriter;
import org.jdaemon.util.expression.OutputError;

abstract class AbstractUnaryOperator<A, R> implements UnaryFunction<A, R> {

    private Expression.Type type;

    public abstract R operate(A a);

    public void write(ExpressionWriter out) throws OutputError {
        out.beginExpression(type);
        out.writeParameter("a");
        out.endExpression(type);
    }

    public AbstractUnaryOperator(Expression.Type type) {
        super();
        this.type = type;
    }
}

--- NEW FILE: Arithmetic.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.util.functional;

/**
 *
 * @author jonathan
 */
public interface Arithmetic<T> {
    
    T add(T a, T b);
    T mul(T a, T b);
    T div(T a, T b);
    T sub(T a, T b);
    T zero();
    T one();
    
    public static final Arithmetic<Integer> INTEGER = new Arithmetic<Integer>() {
        public final Integer add(Integer a, Integer b) {
            return new Integer(a.intValue() + b.intValue());
        }
        public final Integer sub(Integer a, Integer b) {
            return new Integer(a.intValue() - b.intValue());
        }
        public final Integer mul(Integer a, Integer b) {
            return new Integer(a.intValue() * b.intValue());
        }
        public final Integer div(Integer a, Integer b) {
            return new Integer(a.intValue() / b.intValue());
        }
        public final Integer zero() {
            return new Integer(0);
        }
        public final Integer one() {
            return new Integer(1);
        }
    };

    
    public static final Arithmetic<Float> FLOAT = new Arithmetic<Float>() {
        public final Float add(Float a, Float b) {
            return new Float(a.floatValue() + b.floatValue());
        }
        public final Float sub(Float a, Float b) {
            return new Float(a.floatValue() - b.floatValue());
        }
        public final Float mul(Float a, Float b) {
            return new Float(a.floatValue() * b.floatValue());
        }
        public final Float div(Float a, Float b) {
            return new Float(a.floatValue() / b.floatValue());
        }
        public final Float zero() {
            return new Float(0.0);
        }
        public final Float one() {
            return new Float(1.0);
        }
    };
    
    public static final Arithmetic<Double> DOUBLE = new Arithmetic<Double>() {
        public final Double add(Double a, Double b) {
            return new Double(a.doubleValue() + b.doubleValue());
        }
        public final Double sub(Double a, Double b) {
            return new Double(a.doubleValue() - b.doubleValue());
        }
        public final Double mul(Double a, Double b) {
            return new Double(a.doubleValue() * b.doubleValue());
        }
        public final Double div(Double a, Double b) {
            return new Double(a.doubleValue() / b.doubleValue());
        }
        public final Double zero() {
            return new Double(0.0D);
        }
        public final Double one() {
            return new Double(1.0D);
        }
    };

    public static final Arithmetic<Long> LONG = new Arithmetic<Long>() {
        public final Long add(Long a, Long b) {
            return new Long(a.longValue() + b.longValue());
        }
        public final Long sub(Long a, Long b) {
            return new Long(a.longValue() - b.longValue());
        }
        public final Long mul(Long a, Long b) {
            return new Long(a.longValue() * b.longValue());
        }
        public final Long div(Long a, Long b) {
            return new Long(a.longValue() / b.longValue());
        }
        public final Long zero() {
            return new Long(0L);
        }
        public final Long one() {
            return new Long(1L);
        }
    };    
}

--- NEW FILE: ArithmeticOperations.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.util.functional;

import org.jdaemon.util.expression.Expression;

/**
 *
 * @author jonathan
 */
public class ArithmeticOperations<T> {
    
    public final Arithmetic<T> arithmetic;
    public final Parameter<T> parameter;
    
    public BinaryFunction<T,T,T> Add(Parameter<T> a, Parameter<T> b) {
        return new AbstractBinaryOperator<T,T,T>(Expression.Type.ADD) {
            public T operate(T a, T b) {            
                return arithmetic.add(a,b);
            }
        };
    }
    
    public UnaryFunction<T,T> Add(T a, Parameter<T> b) {
        return Operations.BindFirst(Add(parameter, b), a);
    }    
    
    public UnaryFunction<T,T> Add(Parameter<T> a, T b) {
        return Operations.BindSecond(Add(a, parameter), b);
    }
    
    public <U> BinaryFunction<U,T,T> Add(UnaryFunction<U,T> a, Parameter<T> b) {
        return Operations.ChainFirst(a,Add(parameter,b));
    }

    public <U> BinaryFunction<T,U,T> Add(Parameter<T> a, UnaryFunction<U,T> b) {
        return Operations.ChainSecond(b,Add(a, parameter));
    }
    
    public  BinaryFunction<T,T,T> Sub(Parameter<T> a, Parameter<T> b) {
        return new AbstractBinaryOperator<T,T,T>(Expression.Type.SUB) {
            public T operate(T a, T b) {            
                return arithmetic.sub(a,b);
            }
        };
    }
    
    public  UnaryFunction<T,T> Sub(T a, Parameter<T> b) {
        return Operations.BindFirst(Sub(parameter, b), a);
    }    
    
    public  UnaryFunction<T,T> Sub(Parameter<T> a, T b) {
        return Operations.BindSecond(Sub(a, parameter), b);
    }
    
    public  <U> BinaryFunction<U,T,T> Sub(UnaryFunction<U,T> a, Parameter<T> b) {
        return Operations.ChainFirst(a,Sub(parameter,b));
    }

    public  <U> BinaryFunction<T,U,T> Sub(Parameter<T> a, UnaryFunction<U,T> b) {
        return Operations.ChainSecond(b,Sub(a, parameter));
    }    
    
    public  BinaryFunction<T,T,T> Mul(Parameter<T> a, Parameter<T> b) {
        return new AbstractBinaryOperator<T,T,T>(Expression.Type.MUL) {
            public T operate(T a, T b) {            
                return arithmetic.mul(a,b);
            }
        };
    }
    
    public  UnaryFunction<T,T> Mul(T a, Parameter<T> b) {
        return Operations.BindFirst(Mul(parameter, b), a);
    }    
    
    public  UnaryFunction<T,T> Mul(Parameter<T> a, T b) {
        return Operations.BindSecond(Mul(a, parameter), b);
    }
    
    public  <U> BinaryFunction<U,T,T> Mul(UnaryFunction<U,T> a, Parameter<T> b) {
        return Operations.ChainFirst(a,Mul(parameter,b));
    }

    public  <U> BinaryFunction<T,U,T> Mul(Parameter<T> a, UnaryFunction<U,T> b) {
        return Operations.ChainSecond(b,Mul(a, parameter));
    }    

     public  BinaryFunction<T,T,T> Div(Parameter<T> a, Parameter<T> b) {
        return new AbstractBinaryOperator<T,T,T>(Expression.Type.DIV) {
            public T operate(T a, T b) {            
                return arithmetic.div(a,b);
            }
        };
    }
    
    public  UnaryFunction<T,T> Div(T a, Parameter<T> b) {
        return Operations.BindFirst(Div(parameter, b), a);
    }    
    
    public  UnaryFunction<T,T> Div(Parameter<T> a, T b) {
        return Operations.BindSecond(Div(a, parameter), b);
    }
    
    public  <U> BinaryFunction<U,T,T> Div(UnaryFunction<U,T> a, Parameter<T> b) {
        return Operations.ChainFirst(a,Div(parameter,b));
    }

    public  <U> BinaryFunction<T,U,T> Div(Parameter<T> a, UnaryFunction<U,T> b) {
        return Operations.ChainSecond(b,Div(a, parameter));
    }    
    
    public ArithmeticOperations(Arithmetic<T> arithmetic, Parameter<T> parameter) {
        this.arithmetic = arithmetic;
        this.parameter = parameter;
    }

}

--- NEW FILE: Parameter.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.util.functional;

/** Marker class
 *
 * @author jonathan
 */
public class Parameter<T> {
    public static final Parameter<Integer> INTEGER = new Parameter<Integer>();
    public static final Parameter<Float> FLOAT = new Parameter<Float>();
    public static final Parameter<Double> DOUBLE = new Parameter<Double>();
    public static final Parameter<Long> LONG = new Parameter<Long>();
    public static final Parameter<String> STRING = new Parameter<String>();
    public static final Parameter<Boolean> BOOLEAN = new Parameter<Boolean>();
}

Index: BinaryFunction.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/BinaryFunction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** BinaryFunction.java	29 Jul 2008 22:41:09 -0000	1.1
--- BinaryFunction.java	6 Oct 2008 10:18:38 -0000	1.2
***************
*** 1,5 ****
  package org.jdaemon.util.functional;
  
! public interface BinaryFunction<A, B, R> {
  
      R operate(A a, B b);
--- 1,7 ----
  package org.jdaemon.util.functional;
  
! import org.jdaemon.util.expression.Expression;
! 
! public interface BinaryFunction<A, B, R> extends Expression {
  
      R operate(A a, B b);

Index: CountFunction.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/CountFunction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** CountFunction.java	29 Jul 2008 22:41:11 -0000	1.1
--- CountFunction.java	6 Oct 2008 10:18:38 -0000	1.2
***************
*** 1,3 ****
--- 1,4 ----
  package org.jdaemon.util.functional;
+ import org.jdaemon.util.expression.*;
  
  public class CountFunction<T> implements BinaryFunction<Long, T, Long> {
***************
*** 8,10 ****
--- 9,19 ----
          return a + 1L;
      }
+     
+     public void write(ExpressionWriter writer) throws OutputError {
+         writer.beginExpression(Expression.Type.FUNC);
+         writer.writeValue("inc_if_not_null");
+         writer.writeParameter("check_null");
+         writer.writeParameter("to_increment");
+         writer.endExpression(Expression.Type.FUNC);
+     }
  }

Index: MaxFunction.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/MaxFunction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** MaxFunction.java	29 Jul 2008 22:41:11 -0000	1.1
--- MaxFunction.java	6 Oct 2008 10:18:38 -0000	1.2
***************
*** 1,4 ****
  package org.jdaemon.util.functional;
! 
  import java.util.Comparator;
  
--- 1,4 ----
  package org.jdaemon.util.functional;
! import org.jdaemon.util.expression.*;
  import java.util.Comparator;
  
***************
*** 28,30 ****
--- 28,38 ----
          return comparator.compare(a, b) > 0 ? a : b;
      }
+     
+     public void write(ExpressionWriter writer) throws OutputError {
+         writer.beginExpression(Expression.Type.FUNC);
+         writer.writeValue("max");
+         writer.writeParameter("a");
+         writer.writeParameter("b");
+         writer.endExpression(Expression.Type.FUNC);
+     }        
  }

Index: MinFunction.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/MinFunction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** MinFunction.java	29 Jul 2008 22:41:10 -0000	1.1
--- MinFunction.java	6 Oct 2008 10:18:38 -0000	1.2
***************
*** 1,3 ****
--- 1,4 ----
  package org.jdaemon.util.functional;
+ import org.jdaemon.util.expression.*;
  
  import java.util.Comparator;
***************
*** 28,30 ****
--- 29,39 ----
          return comparator.compare(a, b) < 0 ? a : b;
      }
+     
+     public void write(ExpressionWriter writer) throws OutputError {
+         writer.beginExpression(Expression.Type.FUNC);
+         writer.writeValue("min");
+         writer.writeParameter("a");
+         writer.writeParameter("b");
+         writer.endExpression(Expression.Type.FUNC);
+     }
  }

Index: Operations.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/Operations.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** Operations.java	30 Jul 2008 23:41:20 -0000	1.4
--- Operations.java	6 Oct 2008 10:18:38 -0000	1.5
***************
*** 5,13 ****
  
  package org.jdaemon.util.functional;
  
  import java.util.Collection;
- 
  import java.util.List;
! import java.util.ArrayList;
  
  /** Library of operations which can be performed on UnaryFunction and BinaryFunction objects.
--- 5,13 ----
  
  package org.jdaemon.util.functional;
+ import org.jdaemon.util.expression.*;
  
  import java.util.Collection;
  import java.util.List;
! 
  
  /** Library of operations which can be performed on UnaryFunction and BinaryFunction objects.
***************
*** 16,20 ****
   */
  public class Operations {
!             
      /** Chain two unary functions together so that the second operates on the result of the first.
       * 
--- 16,316 ----
   */
  public class Operations {
! 
!     /** Object containing integer arithmetic operators. 
!      */
!     public static final ArithmeticOperations<Integer> INTEGER = new ArithmeticOperations<Integer>(Arithmetic.INTEGER, Parameter.INTEGER);
! 
!     /** Object containing floating-point arithmetic operators. 
!      */
!     public static final ArithmeticOperations<Float> FLOAT = new ArithmeticOperations<Float>(Arithmetic.FLOAT, Parameter.FLOAT);
!  
!     /** Object containing double-precision floating-point arithmetic operators. 
!      */
!     public static final ArithmeticOperations<Double> DOUBLE = new ArithmeticOperations<Double>(Arithmetic.DOUBLE, Parameter.DOUBLE);
!  
!     /** Object containing long integer arithmetic operators. 
!      */
!     public static final ArithmeticOperations<Long> LONG = new ArithmeticOperations<Long>(Arithmetic.LONG, Parameter.LONG);
!  
!     /** Template function providing access to a Greater Than comparison operator.
!      * 
!      * @param a dummy parameter specifying type of parameters (value not used - only type in important)
!      * @param b dummy parameter specifying type of parameters (value not used - only type in important)
!      * @return A BinaryFunction object whose operate method implements the greater than test.
!      */ 
!     public static <T extends Comparable<T>> BinaryFunction<T,T,Boolean> GT(Parameter<T> a, Parameter<T> b) {
!         return new AbstractBinaryOperator<T,T,Boolean>(Expression.Type.GT) {
!             public Boolean operate(T a, T b) {            
!                 return a.compareTo(b) > 0;
!             }
!         };
!     }
!      
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> GT(T a, Parameter<T> b) {
!         return BindFirst(GT(new Parameter<T>(), b), a);
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> GT(Parameter<T> a, T b) {
!         return BindSecond(GT(a, new Parameter<T>()), b);
!     }
!         
!     public static <T extends Comparable<T>, U> BinaryFunction<U,T,Boolean> GT(UnaryFunction<U,T> a, Parameter<T> b) {
!         return ChainFirst(a, GT(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> BinaryFunction<T,U,Boolean> GT(Parameter<T> a, UnaryFunction<U,T> b) {
!         return ChainSecond(b, GT(a, new Parameter<T>()));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> GT(UnaryFunction<U,T> a, T b) {
!         return Chain(a, GT(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> GT(T a, UnaryFunction<U,T> b) {
!         return Chain(b, GT(a, new Parameter<T>()));
!     }
!     
!     public static <T extends Comparable<T>, U, V> BinaryFunction<U,V,Boolean> GT(UnaryFunction<U,T> a, UnaryFunction<V,T> b) {
!         return ChainSecond(b, GT(a, new Parameter<T>()));
!     }
! 
!     /** Template function providing access to a Less Than comparison operator.
!      * 
!      * @param a dummy parameter specifying type of parameters (value not used - only type in important)
!      * @param b dummy parameter specifying type of parameters (value not used - only type in important)
!      * @return A BinaryFunction object whose operate method implements the less than test.
!      */ 
!     public static <T extends Comparable<T>> BinaryFunction<T,T,Boolean> LT(Parameter<T> a, Parameter<T> b) {
!         return new AbstractBinaryOperator<T,T,Boolean>(Expression.Type.LT) {
!             public Boolean operate(T a, T b) {            
!                 return a.compareTo(b) < 0;
!             }
!         };
!     }
!  
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> LT(T a, Parameter<T> b) {
!         return BindFirst(LT(new Parameter<T>(), b), a);
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> LT(Parameter<T> a, T b) {
!         return BindSecond(LT(a, new Parameter<T>()), b);
!     }
!         
!     public static <T extends Comparable<T>, U> BinaryFunction<U,T,Boolean> LT(UnaryFunction<U,T> a, Parameter<T> b) {
!         return ChainFirst(a, LT(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> BinaryFunction<T,U,Boolean> LT(Parameter<T> a, UnaryFunction<U,T> b) {
!         return ChainSecond(b, LT(a, new Parameter<T>()));
!     }   
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> LT(UnaryFunction<U,T> a, T b) {
!         return Chain(a, LT(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> LT(T a, UnaryFunction<U,T> b) {
!         return Chain(b, LT(a, new Parameter<T>()));
!     }
!     
!     public static <T extends Comparable<T>, U, V> BinaryFunction<U,V,Boolean> LT(UnaryFunction<U,T> a, UnaryFunction<V,T> b) {
!         return ChainSecond(b, LT(a, new Parameter<T>()));
!     }
!     
!     /** Template function providing access to a Equality comparison operator.
!      * 
!      * @param a dummy parameter specifying type of parameters (value not used - only type in important)
!      * @param b dummy parameter specifying type of parameters (value not used - only type in important)
!      * @return A BinaryFunction object whose operate method implements the equality test.
!      */ 
!     public static <T extends Comparable<T>> BinaryFunction<T,T,Boolean> EQ(Parameter<T> a, Parameter<T> b) {
!         return new AbstractBinaryOperator<T,T,Boolean>(Expression.Type.EQ) {
!             public Boolean operate(T a, T b) {            
!                 return a.compareTo(b) == 0;
!             }
!         };
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> EQ(T a, Parameter<T> b) {
!         return BindFirst(EQ(new Parameter<T>(), b), a);
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> EQ(Parameter<T> a, T b) {
!         return BindSecond(EQ(a, new Parameter<T>()), b);
!     }
!         
!     public static <T extends Comparable<T>, U> BinaryFunction<U,T,Boolean> EQ(UnaryFunction<U,T> a, Parameter<T> b) {
!         return ChainFirst(a, EQ(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> BinaryFunction<T,U,Boolean> EQ(Parameter<T> a, UnaryFunction<U,T> b) {
!         return ChainSecond(b, EQ(a, new Parameter<T>()));
!     }
!     
!      public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> EQ(UnaryFunction<U,T> a, T b) {
!         return Chain(a, EQ(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> EQ(T a, UnaryFunction<U,T> b) {
!         return Chain(b, EQ(a, new Parameter<T>()));
!     }
!    
!     public static <T extends Comparable<T>, U, V> BinaryFunction<U,V,Boolean> EQ(UnaryFunction<U,T> a, UnaryFunction<V,T> b) {
!         return ChainSecond(b, EQ(a, new Parameter<T>()));
!     }
!     
!     
!     /** Template function providing access to a Greater Than or Equal comparison operator.
!      * 
!      * @param a dummy parameter specifying type of parameters (value not used - only type in important)
!      * @param b dummy parameter specifying type of parameters (value not used - only type in important)
!      * @return A BinaryFunction object whose operate method implements the greater than or equal test.
!      */ 
!     public static <T extends Comparable<T>> BinaryFunction<T,T,Boolean> GTE(Parameter<T> a, Parameter<T> b) {
!         return new AbstractBinaryOperator<T,T,Boolean>(Expression.Type.GTE) {
!             public Boolean operate(T a, T b) {            
!                 return a.compareTo(b) >= 0;
!             }
!         };
!     }
!  
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> GTE(T a, Parameter<T> b) {
!         return BindFirst(GTE(new Parameter<T>(), b), a);
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> GTE(Parameter<T> a, T b) {
!         return BindSecond(GTE(a, new Parameter<T>()), b);
!     }
!         
!     public static <T extends Comparable<T>, U> BinaryFunction<U,T,Boolean> GTE(UnaryFunction<U,T> a, Parameter<T> b) {
!         return ChainFirst(a, GTE(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> BinaryFunction<T,U,Boolean> GTE(Parameter<T> a, UnaryFunction<U,T> b) {
!         return ChainSecond(b, GTE(a, new Parameter<T>()));
!     }   
! 
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> GTE(UnaryFunction<U,T> a, T b) {
!         return Chain(a, GTE(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> GTE(T a, UnaryFunction<U,T> b) {
!         return Chain(b, GTE(a, new Parameter<T>()));
!     }
! 
!     public static <T extends Comparable<T>, U, V> BinaryFunction<U,V,Boolean> GTE(UnaryFunction<U,T> a, UnaryFunction<V,T> b) {
!         return ChainSecond(b, GTE(a, new Parameter<T>()));
!     }
!     
!     /** Template function providing access to a Less Than or Equal comparison operator.
!      * 
!      * @param a dummy parameter specifying type of parameters (value not used - only type in important)
!      * @param b dummy parameter specifying type of parameters (value not used - only type in important)
!      * @return A BinaryFunction object whose operate method implements the less than or equal test.
!      */
!     public static <T extends Comparable<T>> BinaryFunction<T,T,Boolean> LTE(Parameter<T> a, Parameter<T> b) {
!         return new AbstractBinaryOperator<T,T,Boolean>(Expression.Type.LTE) {
!             public Boolean operate(T a, T b) {            
!                 return a.compareTo(b) <= 0;
!             }
!         };
!     }
!  
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> LTE(T a, Parameter<T> b) {
!         return BindFirst(LTE(new Parameter<T>(), b), a);
!     }
!     
!     public static <T extends Comparable<T>> UnaryFunction<T,Boolean> LTE(Parameter<T> a, T b) {
!         return BindSecond(LTE(a, new Parameter<T>()), b);
!     }
!         
!     public static <T extends Comparable<T>, U> BinaryFunction<U,T,Boolean> LTE(UnaryFunction<U,T> a, Parameter<T> b) {
!         return ChainFirst(a, LTE(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> BinaryFunction<T,U,Boolean> LTE(Parameter<T> a, UnaryFunction<U,T> b) {
!         return ChainSecond(b, LTE(a, new Parameter<T>()));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> LTE(UnaryFunction<U,T> a, T b) {
!         return Chain(a, LTE(new Parameter<T>(), b));
!     }
!     
!     public static <T extends Comparable<T>, U> UnaryFunction<U,Boolean> LTE(T a, UnaryFunction<U,T> b) {
!         return Chain(b, LTE(a, new Parameter<T>()));
!     }
!     
!     public static <T extends Comparable<T>, U, V> BinaryFunction<U,V,Boolean> LTE(UnaryFunction<U,T> a, UnaryFunction<V,T> b) {
!         return ChainSecond(b, LTE(a, new Parameter<T>()));
!     }
! 
!     public static BinaryFunction<Boolean, Boolean, Boolean> AND(Parameter<Boolean> a, Parameter<Boolean> b) {
!         return new AbstractBinaryOperator<Boolean,Boolean,Boolean>(Expression.Type.AND) {
!             public Boolean operate(Boolean a, Boolean b) {            
!                 return a && b;
!             }
!         };        
!     }
!     
!     public static UnaryFunction<Boolean,Boolean> AND(Boolean a, Parameter<Boolean> b) {
!         return Operations.BindFirst(AND(Parameter.BOOLEAN, b), a);
!     }    
!     
!     public static UnaryFunction<Boolean,Boolean> AND(Parameter<Boolean> a, Boolean b) {
!         return Operations.BindSecond(AND(a, Parameter.BOOLEAN), b);
!     }
!     
!     public static <U> BinaryFunction<U,Boolean,Boolean> AND(UnaryFunction<U,Boolean> a, Parameter<Boolean> b) {
!         return Operations.ChainFirst(a,AND(Parameter.BOOLEAN,b));
!     }
! 
!     public static <U> BinaryFunction<Boolean,U,Boolean> AND(Parameter<Boolean> a, UnaryFunction<U,Boolean> b) {
!         return Operations.ChainSecond(b,AND(a, Parameter.BOOLEAN));
!     }    
! 
!     public static <T,U> BinaryFunction<T,U,Boolean> AND(UnaryFunction<T, Boolean> a, UnaryFunction<U,Boolean> b) {
!         return Operations.ChainSecond(b,AND(a, Parameter.BOOLEAN));
!     }    
! 
!     public static BinaryFunction<Boolean, Boolean, Boolean> OR(Parameter<Boolean> a, Parameter<Boolean> b) {
!         return new AbstractBinaryOperator<Boolean,Boolean,Boolean>(Expression.Type.OR) {
!             public Boolean operate(Boolean a, Boolean b) {            
!                 return a || b;
!             }
!         };        
!     }
! 
!     public static UnaryFunction<Boolean,Boolean> OR(Boolean a, Parameter<Boolean> b) {
!         return Operations.BindFirst(OR(Parameter.BOOLEAN, b), a);
!     }    
!     
!     public static UnaryFunction<Boolean,Boolean> OR(Parameter<Boolean> a, Boolean b) {
!         return Operations.BindSecond(OR(a, Parameter.BOOLEAN), b);
!     }
!     
!     public static <U> BinaryFunction<U,Boolean,Boolean> OR(UnaryFunction<U,Boolean> a, Parameter<Boolean> b) {
!         return Operations.ChainFirst(a,OR(Parameter.BOOLEAN,b));
!     }
! 
!     public static <U> BinaryFunction<Boolean,U,Boolean> OR(Parameter<Boolean> a, UnaryFunction<U,Boolean> b) {
!         return Operations.ChainSecond(b,OR(a, Parameter.BOOLEAN));
!     }        
!     
!     public static <T,U> BinaryFunction<T,U,Boolean> OR(UnaryFunction<T, Boolean> a, UnaryFunction<U,Boolean> b) {
!         return Operations.ChainSecond(b,AND(a, Parameter.BOOLEAN));
!     }    
! 
!     public static UnaryFunction<Boolean, Boolean> NOT(Parameter<Boolean> a) {
!         return new AbstractUnaryOperator<Boolean,Boolean>(Expression.Type.NOT) {
!             public Boolean operate(Boolean a) {            
!                 return !a;
!             }
!         };        
!     }
!      
!     public static <U> UnaryFunction<U,Boolean> NOT(UnaryFunction<U,Boolean> a) {
!         return Operations.Chain(a,NOT(Parameter.BOOLEAN));
!     }
!         
!     
      /** Chain two unary functions together so that the second operates on the result of the first.
       * 
***************
*** 28,31 ****
--- 324,331 ----
                  return f2.operate(f1.operate(a));
              }
+             
+             public void write(ExpressionWriter out) throws OutputError {
+                 f2.write(Expressions.bindParameter(out, f1));
+             }
          };
      }
***************
*** 42,45 ****
--- 342,348 ----
                  return f2.operate(f1.operate(a,b));
              }
+             public void write(ExpressionWriter out)  throws OutputError  {
+                 f2.write(Expressions.bindParameter(out, f1));
+             }
          };
      }
***************
*** 56,59 ****
--- 359,365 ----
                  return f2.operate(f1.operate(a), b);
              }
+             public void write(ExpressionWriter out) throws OutputError  {
+                 f2.write(Expressions.bindParameter(out, f1));
+             }
          };
      }
***************
*** 70,73 ****
--- 376,382 ----
                  return f2.operate(a,f1.operate(b));
              }
+             public void write(ExpressionWriter out)  throws OutputError {
+                 f2.write(Expressions.bindParameter(out, f1, 2));
+             }
          };
      }
***************
*** 84,87 ****
--- 393,399 ----
                  return f.operate(a, b);
              }
+             public void write(ExpressionWriter out)  throws OutputError {
+                 f.write(Expressions.bindParameter(out, a));
+             }
          };
      }
***************
*** 98,101 ****
--- 410,416 ----
                  return f.operate(a, b);
              }
+             public void write(ExpressionWriter out) throws OutputError {
+                 f.write(Expressions.bindParameter(out, b, 2));
+             }
          };
      }

Index: UnaryFunction.java
===================================================================
RCS file: /cvsroot/era/src/org/jdaemon/util/functional/UnaryFunction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** UnaryFunction.java	29 Jul 2008 22:41:08 -0000	1.1
--- UnaryFunction.java	6 Oct 2008 10:18:38 -0000	1.2
***************
*** 1,6 ****
  package org.jdaemon.util.functional;
  
! public interface UnaryFunction<A, R> {
  
!     R operate(A a);
  }
--- 1,8 ----
  package org.jdaemon.util.functional;
  
! import org.jdaemon.util.expression.Expression;
  
! public interface UnaryFunction<A,R> extends Expression {
! 
!     public R operate(A a);
  }