code: private <T> CompletionStage<T> regex(final Http.RequestHeader requestHeader,
                                           final DeadboltHandler deadboltHandler,
                                           final Optional<String> content,
                                           final String[] values,
                                           final int valueIndex,
                                           final ConstraintMode mode,
                                           final boolean invert,
                                           final Function<Http.RequestHeader, CompletionStage<T>> pass,
                                           final TriFunction<Http.RequestHeader, DeadboltHandler, Optional<String>, CompletionStage<T>> fail,
                                           final ConstraintPoint constraintPoint)
      {
          return CompletableFuture.completedFuture(patternCache.apply(values[valueIndex]))
                                  .thenCombine(getSubject(requestHeader,
                                                               deadboltHandler),
                                               (patternValue, subject) ->
                                                       F.Tuple(subject._1.isPresent() ? analyzer.checkRegexPattern(subject._1,
                                                                                                        Optional.ofNullable(patternValue))
                                                                           : invert, subject._2)) // this is a little clumsy - it means no subject + invert is still denied
  
                                  .thenCompose(hasPassed -> (invert ? !hasPassed._1 : hasPassed._1) ? (successCallAgain(mode, values, valueIndex) ? regex(hasPassed._2,
                                                                                                                                                    deadboltHandler,
                                                                                                                                                    content,
                                                                                                                                                    values,
                                                                                                                                                    valueIndex + 1,
                                                                                                                                                    mode,
                                                                                                                                                    invert,
                                                                                                                                                    pass,
                                                                                                                                                    fail,
                                                                                                                                                    constraintPoint)
                                                                                                                                            : pass(hasPassed._2,
                                                                                                                                                   deadboltHandler,
                                                                                                                                                   pass,
                                                                                                                                                   constraintPoint,
                                                                                                                                                   "pattern - regex"))
                                                                                              : (failCallAgain(mode, values, valueIndex) ? regex(hasPassed._2,
                                                                                                                                                 deadboltHandler,
                                                                                                                                                 content,
                                                                                                                                                 values,
                                                                                                                                                 valueIndex + 1,
                                                                                                                                                 mode,
                                                                                                                                                 invert,
                                                                                                                                                 pass,
                                                                                                                                                 fail,
                                                                                                                                                 constraintPoint)
                                                                                                                                         : fail.apply(hasPassed._2,
                                                                                                                                                      deadboltHandler,
                                                                                                                                                      content)));
      }
docs: Checks access to the resource based on the regex
  
  @param requestHeader             the HTTP request header
  @param deadboltHandler the Deadbolt handler
  @param invert          if true, invert the application of the constraint
  @return the necessary result