Algorithm-ConsistentHash-Ketama

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
sub _version ($) {
        my $s = shift || 0;
        my $d =()= $s =~ /(\.)/g;
        if ( $d >= 2 ) {
                # Normalise multipart versions
                $s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg;
        }
        $s =~ s/^(\d+)\.?//;
        my $l = $1 || 0;
        my @v = map {
                $_ . '0' x (3 - length $_)
        } $s =~ /(\d{1,3})\D?/g;
        $l = $l . '.' . join '', @v if @v;
        return $l + 0;
}
 
sub _cmp ($$) {
        _version($_[1]) <=> _version($_[2]);
}
 
# Cloned from Params::Util::_CLASS

inc/Module/Install/Makefile.pm  view on Meta::CPAN

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
        for my $subdir (@_) {
                push @$subdirs, $subdir;
        }
}
 
sub clean_files {
        my $self  = shift;
        my $clean = $self->makemaker_args->{clean} ||= {};
          %$clean = (
                %$clean,
                FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_),
        );
}
 
sub realclean_files {
        my $self      = shift;
        my $realclean = $self->makemaker_args->{realclean} ||= {};
          %$realclean = (
                %$realclean,
                FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_),
        );
}
 
sub libs {
        my $self = shift;
        my $libs = ref $_[0] ? shift : [ shift ];
        $self->makemaker_args( LIBS => $libs );
}
 
sub inc {

xs/KetamaMD5.c  view on Meta::CPAN

323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
    const md5_byte_t *p = data;
    int left = nbytes;
    int offset = (pms->count[0] >> 3) & 63;
    md5_word_t nbits = (md5_word_t)(nbytes << 3);
 
    if (nbytes <= 0)
        return;
 
    /* Update the message length. */
    pms->count[1] += nbytes >> 29;
    pms->count[0] += nbits;
    if (pms->count[0] < nbits)
        pms->count[1]++;
 
    /* Process an initial partial block. */
    if (offset) {
        int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
 
        memcpy(pms->buf + offset, p, copy);

xs/KetamaMD5.c  view on Meta::CPAN

362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
{
    static const md5_byte_t pad[64] = {
        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    md5_byte_t data[8];
    int i;
 
    /* Save the length before padding. */
    for (i = 0; i < 8; ++i)
        data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
    md5_append(pms, data, 8);
    for (i = 0; i < 16; ++i)
        digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}

xs/KetamaMD5.h  view on Meta::CPAN

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
 * run on either big- or little-endian CPUs, but will run slightly less
 * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
 */
 
typedef unsigned char md5_byte_t; /* 8-bit byte */
typedef unsigned int md5_word_t; /* 32-bit word */
 
/* Define the state of the MD5 Algorithm. */
typedef struct md5_state_s {
    md5_word_t count[2];        /* message length in bits, lsw first */
    md5_word_t abcd[4];         /* digest buffer */
    md5_byte_t buf[64];         /* accumulate block */
} md5_state_t;
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* Initialize the algorithm. */