Data::Page::Set - Print page indexes

  use Data::Page;
  use Data::Page::Set;

  my @data      = 0 .. 300;
  my $page      = Data::Page->new( scalar @data, 5, shift );
  my $pageset   = Data::Page::Set->new( $page, 6, {} );

  print $pageset->show;

#!/usr/bin/perl

package Data::Page::Set;

use strict;
use warnings;
use vars qw($VERSION);

$VERSION = '0.04';

my $code = {
    show_first          => sub { qq(<a href="?page=$_[0]">&lt;&lt;First</a>) },
    show_no_first       => sub { qq() },
    show_prev           => sub { qq(<a href="?page=$_[0]">&lt;Previous</a>) },
    show_no_prev        => sub { qq() },
    show_next           => sub { qq(<a href="?page=$_[0]">&gt;Next</a>) },
    show_no_next        => sub { qq() },
    show_last           => sub { qq(<a href="?page=$_[0]">&gt;&gt;Last</a>) },
    show_no_last        => sub { qq() },
    show_page           => sub { qq(<a href="?page=$_[0]">$_[0]</a>) },
    show_current_page   => sub { qq($_[0]) },
    joiner              => sub { qq(&nbsp;\n) },
    grepper             => sub { length $_[0] },
};

sub new {
    my $class = shift;
    my $pager = shift;
    my $setsize = shift || 10;
    my $show  = shift;

    for my $key ( keys %$code ) {
        $show->{$key} = $code->{$key}
            unless exists $show->{$key}
               and ref $show->{$key} eq 'CODE';
    }

    my $self = bless {
        pager   => $pager,
        show    => $show,
        setsize => $setsize,
    }, $class;

    return $self;
}

sub show {
    my $self    = shift;
    my $show    = shift || $self->{show};
    my $pager   = $self->{pager};

    return  join $show->{joiner}->(),
            grep( { $show->{grepper}->($_) } (
        $self->page_in_set($pager->first_page)
            ? $show->{show_no_first}->($pager->first_page, $pager)
            : $show->{show_first}->($pager->first_page, $pager),
        $pager->current_page == $pager->first_page
            ? $show->{show_no_prev}-> ($pager->previous_page, $pager)
            : $show->{show_prev}->($pager->previous_page, $pager),
        (map
            {
                $_ == $pager->current_page
                    ? $show->{show_current_page}->( $_, $pager )
                    : $show->{show_page}->( $_, $pager )
            } $self->pages_in_set()
        ),
        $pager->current_page == $pager->last_page
            ? $show->{show_no_next}->($pager->next_page, $pager)
            : $show->{show_next}->($pager->next_page, $pager),
        $self->page_in_set($pager->last_page)
            ? $show->{show_no_last}->($pager->last_page, $pager)
            : $show->{show_last}->($pager->last_page, $pager),
    ));
}

sub pages_in_set {
    my $self = shift;

    my $cur     = $self->{pager}->current_page;
    my $len     = $self->{setsize};
    my $first   = $self->{pager}->first_page;
    my $last    = $self->{pager}->last_page;

    my $pre;
    my $post        = sub { $len  - $pre - 1    };
    my $size        = sub { $last - $first      };
    my $first_show  = sub { $cur  - $pre        };
    my $last_show   = sub { $cur  + $post->()   };

    return $first .. $last if $len > $size->();

    $pre = $len % 2 ? int $len / 2 : int( ($len - 1) / 2 );

    $pre = $last_show->()  > $last  ? -$last  + $cur + $len - 1
         : $first_show->() < $first ? -$first + $cur
         : $pre;

    return $first_show->() .. $last_show->();
}

sub page_in_set {
    my $self = shift;
    my $page = shift;

    return scalar grep
        { $_ == $page }
        $self->pages_in_set;
}

sub page_before_view {
    my $self = shift;
    my @in_view = $self->pages_in_set;

    return $in_view[0] - 1;
}

sub page_after_view {
    my $self = shift;
    my @in_view = $self->pages_in_set;

    return $in_view[-1] + 1;
}

1