---
name: "Dancer::Route::Cache"
section: "3pm"
platform: "linux"
package: "libdancer-perl"
version: "1.3521+dfsg-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Dancer::Route::Cache"
---

# Dancer::Route::Cache(3pm)

route caching mechanism for Dancer

## NAME

Dancer::Route::Cache - route caching mechanism for Dancer

## VERSION

version 1.3521

## SYNOPSIS

```
    my $cache = Dancer::Route::Cache->new(
        path_limit => 300, # optional, defaults to 600 (routes to cache)
        size_limit => 5M,  # optional, defaults to 10M (10MB)
    );
    # storing a path
    # /new/item/ is the path, $route is a compiled route
    $cache->store_path( 'get', '/new/item/', $route );
    my $cached_route = $cache->route_from_path('/new/item/');
```

## DESCRIPTION

When Dancer first starts, it has to compile a regexp list of all the routes. Then, on each request it goes over the compiled routes list and tries to compare the requested path to a route.

A major drawback is that Dancer has to go over the matching on every request, which (especially on CGI-based applications) can be very time consuming.

The caching mechanism allows one to cache some requests to specific routes (but **NOT** specific results) and run those routes on a specific path. This allows us to speed up Dancer quite a lot.

## METHODS/SUBROUTINES

### new(@args)

Creates a new route cache object.

```
    my $cache = Dancer::Route::Cache->new(
        path_limit => 100,   # only 100 paths will be cached
        size_limit => '30M', # max size for cache is 30MB
    );
```

Please check the `"ATTRIBUTES"` section below to learn about the arguments for `"new()"`.

### route\_from\_path($path)

Fetches the route from the path in the cache.

### store\_path( $method, $path =\> $route )

Stores the route in the cache according to the path and `$method`.

For developers: the reason we're using an object for this and not directly using the registry hash is because we need to enforce the limits.

### parse\_size($size)

Parses the size wanted to bytes. It can handle Kilobytes, Megabytes or Gigabytes.

**NOTICE:** handles bytes, not bits!

```
    my $bytes = $cache->parse_size('30M');
    # doesn't need an existing object
    $bytes = Dancer::Route::Cache->parse_size('300G'); # works this way too
```

### route\_cache\_size

Returns a rough calculation the size of the cache. This is used to enforce the size limit.

### route\_cache\_paths

Returns all the paths in the cache. This is used to enforce the path limit. Please be careful if you use "mount" in Plack::Builder and some applications - routes are linked with applications and same path may be in some applications but with different handlers!

## ATTRIBUTES

### size\_limit($limit)

Allows one to set a size limit of the cache.

Returns the limit (post-set).

```
    $cache->size_limit('10K');      # sets limit
    my $limit = $cache->size_limit; # gets limit
```

### path\_limit($limit)

A path limit. That is, the amount of paths that whose routes will be cached.

Returns the limit (post-set).

```
    $cache->path_limit('100');      # sets limit
    my $limit = $cache->path_limit; # gets limit
```

## AUTHOR

Dancer Core Developers

## COPYRIGHT AND LICENSE

This software is copyright (c) 2010 by Alexis Sukrieh.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.