https://github.com/adversing/decisions4j
Decisions4J is a Java library for creating decision trees. It provides a simple API for making decisions based on custom rules and conditions. Ideal for lightweight, simple decision-making applications.
https://github.com/adversing/decisions4j
decision-making decision-tree java-8
Last synced: about 1 year ago
JSON representation
Decisions4J is a Java library for creating decision trees. It provides a simple API for making decisions based on custom rules and conditions. Ideal for lightweight, simple decision-making applications.
- Host: GitHub
- URL: https://github.com/adversing/decisions4j
- Owner: Adversing
- Created: 2023-02-15T23:57:16.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2024-02-02T23:26:02.000Z (over 2 years ago)
- Last Synced: 2025-02-12T16:32:22.475Z (over 1 year ago)
- Topics: decision-making, decision-tree, java-8
- Language: Java
- Homepage:
- Size: 9.77 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Decisions4J
`Decisions4J` is a Java API that allows you to define a set of rules to apply to an object and execute the appropriate action based on the first matching rule. It's useful when you need to make a decision based on a complex set of conditions.
---
## Usage
To use `Decisions4J`, create a new instance of it by passing an object of the type that you want to evaluate as its argument:
```java
DecisionsTree tree = new DecisionsTree<>("test"); // in this case we're evaluating a String
```
### Adding rules
Once you have a `Decisions4J` instance, you can add rules to it. A rule consists of a condition and an action. The condition is a `Predicate` that evaluates to true if the rule should be applied, and the action is a `Consumer` that specifies what should be done if the rule is applied.
To add a rule to the `DecisionsTree`, call the `caseCondition()` method with the condition and the action as arguments. Here's an example:
```java
tree.caseCondition(s -> s.equals("test"), s -> System.out.println("test"));
```
In this example, we're adding a rule that says "if the string is 'test', then print 'test'".
### Adding a default rule
If none of the rules match, you can specify a default action to be executed by calling the `defaultCase()` method:
```java
tree.defaultCase(s -> System.out.println("default"));
```
In this example, we're specifying that if none of the other rules match, the action should be to print "default".
### Applying the rules
Once you've added all the rules, you can apply them to the object by calling the `decide()` method:
```java
tree.decide();
```
This will evaluate the object and execute the first matching rule.
---
## Example
Here's an example of using `Decisions4J` to evaluate a `Person` object:
```java
// Create a new DecisionsTree with a Person object
Person person = new Person("Alice", 30);
DecisionsTree tree = new DecisionsTree<>(person);
// Add a rule
tree.caseCondition(p -> p.getAge() > 18, p -> System.out.println(p.getName() + " is an adult"));
// Add a default rule
tree.defaultCase(p -> System.out.println(person.getName() + " is a minor"));
// Apply the rules
tree.decide();
```
In this example, we're creating a new `DecisionsTree` instance with a `Person` object. We're adding a rule that says "if the person's age is greater than 18, then print 'Alice is an adult'" (where "Alice" is the person's name). We're also adding a default rule that says "print 'Alice is a minor' if none of the other rules match". Finally, we're applying the rules to the person object by calling `decide()`.
You may also use this syntax:
```java
// Create a Person object
Person person = new Person("Alice", 30);
// Create a DecisionsTree object
DecisionsTree tree = new DecisionsTree<>(person)
.caseCondition(p -> p.getAge() > 18, p -> System.out.println(p.getName() + " is an adult"))
.defaultCase(p -> System.out.println(person.getName() + " is a minor"));
// Apply the rules
tree.decide();
```
---
## Error handling
`Decisions4J` provides some basic error handling. If you don't add any rules to the `DecisionsTree`, calling `decide()` will result in an `IllegalStateException`. Similarly, if you don't call `decide()` after adding rules, you'll get an `IllegalStateException` as well. If you call `defaultCase()` with a null action, you'll get a `NullPointerException`.
---
###### check out the javascript version [here](https://github.com/Adversing/decisions.js/) and the python version [here](https://github.com/Adversing/decisions.py/) :)