Condition Composition - rulii Documentation

Conditions in rulii support logical composition using and(), or(), not(), and xor(). This lets you build complex boolean expressions from simple conditions without writing nested logic.

Available Operators

and()

Both conditions must be true

or()

At least one condition must be true

not()

Negates the condition

xor()

Exactly one must be true, not both

Basic Composition

import static org.rulii.model.condition.Conditions.condition;

Condition isAdult = condition((Integer age) -> age >= 18);
Condition isActive = condition((String status) -> "active".equals(status));

// AND: both must be true
Condition eligible = isAdult.and(isActive);

// OR: at least one must be true
Condition canView = isAdult.or(isActive);

// NOT: negate a condition
Condition isMinor = isAdult.not();

// XOR: exactly one must be true
Condition exclusive = isAdult.xor(isActive);

Using in Rules

Condition isAdult = condition((Integer age) -> age >= 18);
Condition hasConsent = condition((Boolean consent) -> consent);

// Compose: must be adult AND have consent
Rule rule = Rule.builder()
    .name("EligibilityCheck")
    .given(isAdult.and(hasConsent))
    .then(action(() -> System.out.println("Approved")))
    .otherwise(action(() -> System.out.println("Denied")))
    .build();

rule.run(age -> 25, consent -> true);   // Approved
rule.run(age -> 25, consent -> false);  // Denied
rule.run(age -> 15, consent -> true);   // Denied

Chaining Multiple Operators

Condition isAdult = condition((Integer age) -> age >= 18);
Condition isVIP = condition((Boolean vip) -> vip);
Condition hasTicket = condition((Boolean ticket) -> ticket);

// Complex: (adult AND hasTicket) OR isVIP
Condition canEnter = isAdult.and(hasTicket).or(isVIP);

CompositeCondition

The result of and(), or(), and xor() is a CompositeCondition that you can inspect:

CompositeCondition composed = isAdult.and(isActive);

composed.getSymbol();        // "&&"
composed.getLeftOperand();   // isAdult
composed.getRightOperand();  // isActive

Built-in Constants

// A condition that always returns true
Condition alwaysTrue = Conditions.TRUE();

// Useful as a default or placeholder
Rule rule = Rule.builder()
    .name("AlwaysRun")
    .given(Conditions.TRUE())
    .then(action(() -> { /* always executes */ }))
    .build();