NNUTTER / Sort-strverscmp-0.010 / lib / Sort / strverscmp.pm 

            

              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
—
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

              
use strict;
use warnings;
package StringIterator;
use Carp qw(croak);
sub new {
    my $class = shift;
    my $string = shift;
    unless ($string) {
        croak 'invalid string';
    }
    my $o = {};
    $o->{pos} = 0;
    $o->{string} = $string;
    $o->{len} = length($string);
    return bless $o, $class;
}
sub pos {
    my $self = shift;
    return $self->{pos};
}
sub string {
    my $self = shift;
    return $self->{string};
}
sub len {
    my $self = shift;
    return $self->{len};
}
sub head {
    my $self = shift;
    if ($self->pos >= $self->len) {
        return;
    } else {
        return substr($self->string, $self->pos, 1);
    }
}
sub tail {
    my $self = shift;
    return substr($self->string, $self->pos + 1);
}
sub tail_len {
    my $self = shift;
    return ($self->len - $self->pos);
}
sub advance {
    my $self = shift;
    $self->{pos}++;
}
sub next {
    my $self = shift;
    my $head = $self->head();
    $self->advance();
    return $head;
}
package Sort::strverscmp;
use Exporter 'import';
our @EXPORT = qw(strverscmp);
our @EXPORT_OK = qw(strverssort);
use feature ':5.10';
sub isdigit {
    my $c = shift;
    return (defined($c) && $c =~ /^\d+$/);
}
sub fcmp {
    my ($l, $r) = @_;
    my ($lz, $ln, $rz, $rn);
    ($lz, $ln) = decompose_fractional($l);
    ($rz, $rn) = decompose_fractional($r);
    if (length($lz) == length($rz)) {
        return $ln <=> $rn;
    } else {
        return (length($lz) > length($rz) ? -1 : 1);
    }
}
sub decompose_fractional {
    my ($zeroes, $number) = shift =~ /^(0*)(\d+)$/;
    return ($zeroes, $number);
}
# strnum_cmp from bam_sort.c
sub strverscmp {
    my ($a, $b) = @_;
    my $ai = StringIterator->new($a);
    my $bi = StringIterator->new($b);
    do {
        if (isdigit($ai->head) && isdigit($bi->head)) {
            my $an = (($ai->head . $ai->tail) =~ /^(\d*)/)[0];
            my $bn = (($bi->head . $bi->tail) =~ /^(\d*)/)[0];
            if ($an =~ /^0\d/ || $bn =~ /^0\d/) {
                return fcmp($an, $bn);
            } else {
                if ($an <=> $bn) {
                    return ($an <=> $bn);
                }
            }
        } else {
            if ($ai->head cmp $bi->head) {
                return ($ai->head cmp $bi->head);
            }
        }
        $ai->advance();
        $bi->advance();
    } while (defined($ai->head) && defined($bi->head));
    return $ai->head ? 1 : $bi->head ? -1 : 0;
}
sub strverssort {
    return sort { strverscmp($a, $b) } @_;
}
1;
__END__
=head1 NAME
Sort::strverscmp -- Compare strings while treating digits characters numerically.
=head1 SYNOPSIS
  my @list = qw(a A beta9 alpha9 alpha10 alpha010 1.0.5 1.05);
  my @them = strverssort(@list);
  print join(' ', @them), "\n";
Prints:
  1.05 1.0.5 A a alpha010 alpha9 alpha10 beta9
=head1 DESCRIPTION
Pure Perl implementation of GNU strverscmp.
=head1 AUTHOR
Nathaniel Nutter C<nnutter@cpan.org>
=head1 COPYRIGHT AND DISCLAIMER
Copyright 2013, The Genome Institute at Washington University C<nnutter@cpan.org>, all rights
reserved.  This program is free software; you can redistribute it
and/or modify it under the same terms as Perl itself.
This program is distributed in the hope that it will be useful, but
without any warranty; without even the implied warranty of
merchantability or fitness for a particular purpose.