ExampleOfComposableExpressions.java

import java.util.Arrays;
import java.util.List;

class ExampleOfComposableExpressions {

  public static void main(String[] args) {
    // Equivalent to
    // expr := ( (idle <= 10) || (usage > 80) ) && (available =~ /^y(es)?/)
    Expression expr =
        new LogicalExpression(
            LogicalExpression.Operator.AND,
            new LogicalExpression(
                LogicalExpression.Operator.OR,
                new ComparisonExpression(
                    new VariableExpression("idle"),
                    ComparisonExpression.Operator.LTE,
                    new LiteralExpression(10)
                ),
                new ComparisonExpression(
                    new VariableExpression("usage"),
                    ComparisonExpression.Operator.GT,
                    new LiteralExpression(80.2)
                )
            ),
            new ComparisonExpression(
                new VariableExpression("available"),
                ComparisonExpression.Operator.REGEX,
                new RegexExpression("^y(es)?")
            )
        );
  }
}

abstract class Expression {

}

/**
 * A specialized expression that resolves only to boolean values and can be
 * referenced in cases where only a boolean value is reasonable, 
 * such as {@link LogicalExpression}.
 */
abstract class BooleanExpression extends Expression {

}

class LiteralExpression extends Expression {

  public LiteralExpression(Object value) {
    this.value = value;
  }

  Object value;
}

class RegexExpression extends Expression {

  public RegexExpression(String pattern) {
    this.pattern = pattern;
  }

  String pattern;
}

class VariableExpression extends Expression {

  public VariableExpression(String name) {
    this.name = name;
  }

  String name;
}

class ComparisonExpression extends BooleanExpression {

  ComparisonExpression(Expression lhs, Operator op, Expression rhs) {
    this.lhs = lhs;
    this.op = op;
    this.rhs = rhs;
  }

  enum Operator {
    LT, LTE, EQ, GT, GTE, REGEX
  }

  Operator op;
  Expression lhs;
  Expression rhs;
}

class LogicalExpression extends BooleanExpression {

  public LogicalExpression(Operator op, BooleanExpression... expressions) {
    this.op = op;
    this.expressions = Arrays.asList(expressions);
  }

  enum Operator {
    AND, OR
  }

  Operator op;
  List<BooleanExpression> expressions;
}