public abstract class SolverConstraint {
    protected Solver solver;
    protected IntVar[][][][] x;
    protected IntVar[][][][] g;
    protected List<Constraint> constraints;

    protected abstract void build();

    public void post() {
        if (constraints == null)
            throw new IllegalStateException("The constraints have not beein initialized yet.");

        solver.post(constraints.toArray(new Constraint[constraints.size()]));
    }
}

public abstract class TournamentConstraint extends SolverConstraint {
    protected Tournament tournament;

    public TournamentConstraint(Tournament t) {
        tournament = t;

        TournamentSolver tournamentSolver = t.getSolver();
        solver = tournamentSolver.getSolver();
        x = tournamentSolver.getMatchesModel();
        g = tournamentSolver.getMatchesBeginningsModel();
    }

}

public abstract class EventConstraint extends SolverConstraint {
    protected Event event;
    protected int eventIndex;

    public EventConstraint(Event e, Tournament t) {
        event = e;
        eventIndex = t.getEvents().indexOf(e);

        TournamentSolver tournamentSolver = t.getSolver();
        solver = tournamentSolver.getSolver();
        x = tournamentSolver.getMatchesModel();
        g = tournamentSolver.getMatchesBeginningsModel();
    }
}

public class ConstraintBuilder {
    private Tournament tournament;

    public ConstraintBuilder(Tournament t) {
        tournament = t;
    }

    public SolverConstraint matchesPerPlayerConstraint(Event e) {
        return new MatchesPerPlayerConstraint(e, tournament);
    }
}

// We will have one of this kind of class for each constraint (rule) we want to define over the model (game)
public class MatchesPerPlayerConstraint extends EventConstraint {

    public MatchesPerPlayerConstraint(Event e, Tournament t) {
        super(e, t);
        build();
    }

    protected void build() {
        constraints = new ArrayList<Constraint>();

        // Que cada jugador juegue nMatchesPerPlayer partidos
        int playerNumberOfTimeslots = event.getMatchesPerPlayer() * event.getMatchDuration();

        for (int p = 0; p < event.getPlayers().size(); p++) {
            constraints.add(IntConstraintFactory.sum(ArrayUtils.flatten(g[eventIndex][p]), VariableFactory.fixed(event.getMatchesPerPlayer() , solver)));
            constraints.add(IntConstraintFactory.sum(ArrayUtils.flatten(x[eventIndex][p]), VariableFactory.fixed(playerNumberOfTimeslots, solver)));
        }
    }
}