/**

public interface Filter extends Aware {

/**

Handler apply(Handler next);

/**

default Filter then(Filter next) {

return new ThenFilter(this, next);

}

/**

default Handler then(Handler next) {

return new ThenHandler(this, next);

}

}

private record ThenFilter(Filter filter, Filter next) implements Filter {

@Override

public Handler apply(Handler handler) {

return new ThenHandler(filter, next.apply(handler));

}

}

private record ThenHandler(Filter filter, Handler next) implements Handler {

@Override

public Object apply(Context ctx) throws Exception {

return filter.apply(next).apply(ctx);

}

@Override

public void setRoute(Route route) {

filter.setRoute(route);

next.setRoute(route);

}

}

/** Marker interface for reactive responses. */

public interface Reactive extends Filter {}

/**

public interface Before extends Filter {

default @Override Handler apply(Handler next) {

return ctx -> {

apply(ctx);

return next.apply(ctx);

};

}

/**

void apply(Context ctx) throws Exception;

/**

default Before then(Before next) {

return ctx -> {

apply(ctx);

if (!ctx.isResponseStarted()) {

next.apply(ctx);

}

};

}

/**

default Handler then(Handler next) {

return ctx -> {

apply(ctx);

if (!ctx.isResponseStarted()) {

return next.apply(ctx);

}

return ctx;

};

}

}

/**

public interface After {

/**

default After then(After next) {

return (ctx, result, failure) -> {

next.apply(ctx, result, failure);

apply(ctx, result, failure);

};

}

/**

void apply(Context ctx, @Nullable Object result, @Nullable Throwable failure) throws Exception;

}

/**

public interface Complete {

/**

void apply(Context ctx) throws Exception;

}

/**

public interface Aware {

/**

default void setRoute(Route route) {}

}

/**

public interface Handler extends Aware {

/**

Object apply(Context ctx) throws Exception;

/**

default Handler then(After next) {

return ctx -> {

Throwable cause = null;

Object value = null;

try {

value = apply(ctx);

} catch (Throwable x) {

cause = x;

// Early mark context as errored response code:

ctx.setResponseCode(ctx.getRouter().errorCode(cause));

}

Object result;

try {

if (ctx.isResponseStarted()) {

result = Context.readOnly(ctx);

next.apply((Context) result, value, cause);

} else {

result = value;

next.apply(ctx, value, cause);

}

} catch (Throwable x) {

result = null;

if (cause == null) {

cause = x;

} else {

cause.addSuppressed(x);

}

}

if (cause == null) {

return result;

} else {

if (ctx.isResponseStarted()) {

return ctx;

} else {

throw SneakyThrows.propagate(cause);

}

}

};

}

}

/**

public record Location(String filename, int line) {}

private static final Location NO_LOCATION = new Location("<<Unknown>>", -1);

/** Handler for {@link StatusCode#NOT_FOUND} responses. */

public static final Handler NOT_FOUND =

ctx -> ctx.sendError(new NotFoundException(ctx.getRequestPath()));

/** Handler for {@link StatusCode#METHOD_NOT_ALLOWED} responses. */

public static final Handler METHOD_NOT_ALLOWED =

ctx -> {

ctx.setResetHeadersOnError(false);

// Allow header was generated by routing algorithm

if (ctx.getMethod().equals(Router.OPTIONS)) {

return ctx.send(StatusCode.OK);

} else {

List<String> allow =

Optional.ofNullable(ctx.getResponseHeader("Allow"))

.map(it -> Arrays.asList(it.split(",")))

.orElseGet(Collections::emptyList);

return ctx.sendError(new MethodNotAllowedException(ctx.getMethod(), allow));

}

};

/** Handler for body error decoder responses. */

public static final Handler FORM_DECODER_HANDLER =

ctx -> {

var tooManyFields = (Throwable) ctx.getAttributes().remove("__too_many_fields");

BadRequestException cause;

if (tooManyFields != null) {

cause = new BadRequestException("Too many form fields", tooManyFields);

} else {

cause = new BadRequestException("Failed to decode HTTP body");

}

return ctx.sendError(cause);

};

/** Handler for {@link StatusCode#REQUEST_ENTITY_TOO_LARGE} responses. */

public static final Handler REQUEST_ENTITY_TOO_LARGE =

ctx ->

ctx.setResponseCode(StatusCode.REQUEST_ENTITY_TOO_LARGE)

.sendError(new StatusCodeException(StatusCode.REQUEST_ENTITY_TOO_LARGE));

/** Handler for {@link StatusCode#NOT_ACCEPTABLE} responses. */

public static final Route.Before ACCEPT =

ctx -> {

List<MediaType> produceTypes = ctx.getRoute().getProduces();

MediaType contentType = ctx.accept(produceTypes);

if (contentType == null) {

throw new NotAcceptableException(ctx.header(Context.ACCEPT).valueOrNull());

}

ctx.setDefaultResponseType(contentType);

};

/** Handler for {@link StatusCode#UNSUPPORTED_MEDIA_TYPE} responses. */

public static final Route.Before SUPPORT_MEDIA_TYPE =

ctx -> {

if (!ctx.isPreflight()) {

MediaType contentType = ctx.getRequestType();

if (contentType == null) {

throw new UnsupportedMediaType(null);

}

if (ctx.getRoute().getConsumes().stream().noneMatch(contentType::matches)) {

throw new UnsupportedMediaType(contentType.getValue());

}

}

};

/**

public record MvcMethod(

Class<?> declaringClass, String name, Class<?> returnType, Class<?>... parameterTypes) {

/**

public Method toMethod() {

try {

return declaringClass.getDeclaredMethod(name, parameterTypes);

} catch (NoSuchMethodException e) {

throw SneakyThrows.propagate(e);

}

}

/**

public MethodHandle toMethodHandle(MethodHandles.Lookup lookup) {

try {

return lookup.unreflect(toMethod());

} catch (IllegalAccessException e) {

throw SneakyThrows.propagate(e);

}

}

/**

public MethodHandle toMethodHandle() {

return toMethodHandle(MethodHandles.publicLookup());

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (!(o instanceof MvcMethod that)) return false;

return declaringClass.equals(that.declaringClass)

&& name.equals(that.name)

&& returnType.equals(that.returnType)

&& Arrays.equals(parameterTypes, that.parameterTypes);

}

@Override

public int hashCode() {

int result = Objects.hash(declaringClass, name, returnType);

result = 31 * result + Arrays.hashCode(parameterTypes);

return result;

}

@Override

public String toString() {

return "MvcMethod["

+ "declaringClass="

+ declaringClass

+ ", name="

+ name

+ ", returnType="

+ returnType

+ ", parameterTypes="

+ Arrays.toString(parameterTypes)

+ ']';

}

}

/** Favicon handler as a silent 404 error. */

public static final Handler FAVICON = ctx -> ctx.send(StatusCode.NOT_FOUND);

private static final List EMPTY_LIST = Collections.emptyList();

private static final Map EMPTY_MAP = Collections.emptyMap();

private Map<String, MessageDecoder> decoders = EMPTY_MAP;

private final String pattern;

private final String method;

private List<String> pathKeys = EMPTY_LIST;

private Filter filter;

private Handler handler;

private After after;

private Handler pipeline;

private MessageEncoder encoder;

private List<MediaType> produces = EMPTY_LIST;

private List<MediaType> consumes = EMPTY_LIST;

private Map<String, Object> attributes = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);

private java.util.Set<String> supportedMethod;

private String executorKey;

private List<String> tags = EMPTY_LIST;

private String summary;

private String description;

private Boolean nonBlocking;

private MvcMethod mvcMethod;

private boolean httpHead;

private final Location location;

/**

public Route(String method, String pattern, Handler handler) {

this.method = method.toUpperCase();

this.pattern = pattern;

this.handler = handler;

this.location =

StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE)

.walk(

frame ->

frame

.dropWhile(

f ->

Stream.of(

Route.class.getName(),

RouterImpl.class.getName(),

Router.class.getName(),

Jooby.class.getName(),

"io.jooby.kt.Kooby",

"io.jooby.kt.CoroutineRouter")

.anyMatch(it -> it.equals(f.getDeclaringClass().getName())))

.findFirst()

.map(it -> new Location(it.getFileName(), it.getLineNumber()))

.orElse(NO_LOCATION));

}

/**

public Location getLocation() {

return location;

}

/**

public String getPattern() {

return pattern;

}

/**

public String getMethod() {

return method;

}

/**

public List<String> getPathKeys() {

return pathKeys;

}

/**

public Route setPathKeys(List<String> pathKeys) {

this.pathKeys = pathKeys;

return this;

}

/**

public Handler getHandler() {

return handler;

}

/**

public Handler getPipeline() {

if (pipeline == null) {

pipeline = computePipeline();

}

return pipeline;

}

/**

public String reverse(Map<String, Object> keys) {

return Router.reverse(getPattern(), keys);

}

/**

public String reverse(Object... values) {

return Router.reverse(getPattern(), values);

}

/**

public @Nullable After getAfter() {

return after;

}

/**

public Route setAfter(After after) {

this.after = after;

return this;

}

/**

public @Nullable Filter getFilter() {

return filter;

}

/**

public Route setFilter(@Nullable Filter filter) {

this.filter = filter;

return this;

}

/**

public Route setPipeline(Route.Handler pipeline) {

this.pipeline = pipeline;

return this;

}

/**

public MessageEncoder getEncoder() {

return encoder;

}

/**

public Route setEncoder(MessageEncoder encoder) {

this.encoder = encoder;

return this;

}

/**

public boolean isNonBlocking() {

return nonBlocking == Boolean.TRUE;

}

/**

public boolean isNonBlockingSet() {

return nonBlocking != null;

}

/**

public Route setNonBlocking(boolean nonBlocking) {

this.nonBlocking = nonBlocking;

return this;

}

/**

public List<MediaType> getProduces() {

return produces;

}

/**

public Route produces(MediaType... produces) {

return setProduces(Arrays.asList(produces));

}

/**

public Route setProduces(Collection<MediaType> produces) {

if (!produces.isEmpty()) {

if (this.produces == EMPTY_LIST) {

this.produces = new ArrayList<>();

}

this.produces.addAll(produces);

}

return this;

}

/**

public List<MediaType> getConsumes() {

return consumes;

}

/**

public Route consumes(MediaType... consumes) {

return setConsumes(Arrays.asList(consumes));

}

/**

public Route setConsumes(Collection<MediaType> consumes) {

if (!consumes.isEmpty()) {

if (this.consumes == EMPTY_LIST) {

this.consumes = new ArrayList<>();

}

this.consumes.addAll(consumes);

}

return this;

}

/**

public Map<String, Object> getAttributes() {

return attributes;

}

/**

public @Nullable <T> T getAttribute(String name) {

//noinspection unchecked

return (T) attributes.get(name);

}

/**

public Route setAttributes(Map<String, Object> attributes) {

this.attributes.putAll(attributes);

return this;

}

/**

public Route setAttribute(String name, Object value) {

if (this.attributes == EMPTY_MAP) {

this.attributes = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);

}

this.attributes.put(name, value);

return this;

}

/**

public MessageDecoder decoder(MediaType contentType) {

return decoders.getOrDefault(contentType.getValue(), MessageDecoder.UNSUPPORTED_MEDIA_TYPE);

}

/**

public Map<String, MessageDecoder> getDecoders() {

return decoders;

}

/**

public Route setDecoders(Map<String, MessageDecoder> decoders) {

this.decoders = decoders;

return this;

}

/**

public boolean isHttpOptions() {

return isHttpMethod(Router.OPTIONS);

}

/**

public boolean isHttpTrace() {

return isHttpMethod(Router.TRACE);

}

/**

public boolean isHttpHead() {

return httpHead;

}

/**

public Route setHttpOptions(boolean enabled) {

addHttpMethod(enabled, Router.OPTIONS);

return this;

}

/**

public Route setHttpTrace(boolean enabled) {

addHttpMethod(enabled, Router.TRACE);

return this;

}

/**

public Route setHttpHead(boolean enabled) {

addHttpMethod(enabled, Router.HEAD);

this.httpHead = enabled;

return this;

}

/**

public @Nullable String getExecutorKey() {

return executorKey;

}

/**

public Route setExecutorKey(@Nullable String executorKey) {

this.executorKey = executorKey;

return this;

}

/**