File Coverage

blib/lib/MAD/Scrambler.pm

Criterion	Covered	Total	%
statement	40	40	100.0
branch			n/a
condition			n/a
subroutine	8	8	100.0
pod	4	4	100.0
total	52	52	100.0

package MAD::Scrambler;
$MAD::Scrambler::VERSION = '0.000005';
## no critic (Bangs::ProhibitBitwiseOperators)

use Moo;
extends 'Exporter';

our @EXPORT_OK = qw{
  nibble_split
  nibble_join
};

use List::Util qw{ shuffle };

use Const::Fast;

const our $MAX_BIT_MASK => 2**32;

const my $MIN_BIT     => 0;
const my $MAX_BIT     => 7;
const my $NIBBLE_SIZE => 4;
const my $NIBBLE_MASK => 0x0000000f;

has 'scrambler' => (
    is      => 'ro',
    lazy    => 1,
    default => sub { [ shuffle $MIN_BIT .. $MAX_BIT ] },
);

has 'unscrambler' => (
    is      => 'ro',
    lazy    => 1,
    builder => sub {
        my ($self) = @_;

        my @scrambler   = @{ $self->scrambler };
        my @unscrambler = ();

        for ( $MIN_BIT .. $MAX_BIT ) {
            $unscrambler[ $scrambler[$_] ] = $_;
        }

        return \@unscrambler;
    },
);

has 'bit_mask' => (
    is      => 'ro',
    default => sub { int rand $MAX_BIT_MASK },
);

sub encode {
    my ( $self, $number ) = @_;

    my @slice     = @{ $self->scrambler };
    my @nibbles   = nibble_split($number);
    my $scrambled = nibble_join( @nibbles[@slice] );
    my $encoded   = $scrambled ^ $self->bit_mask;

    return $encoded;
}

sub decode {
    my ( $self, $encoded ) = @_;

    my @slice   = @{ $self->unscrambler };
    my $number  = $encoded ^ $self->bit_mask;
    my @nibbles = nibble_split($number);
    my $decoded = nibble_join( @nibbles[@slice] );

    return $decoded;
}

sub nibble_split {
    my ($number) = @_;

    my @nibbles;
    for ( $MIN_BIT .. $MAX_BIT ) {
        $nibbles[$_] = ( $number >> ( $_ * $NIBBLE_SIZE ) ) & $NIBBLE_MASK;
    }

    return @nibbles;
}

sub nibble_join {
    my (@nibbles) = @_;

    my $number = 0;
    for ( $MIN_BIT .. $MAX_BIT ) {
        $number = $number | ( $nibbles[$_] << ( $_ * $NIBBLE_SIZE ) );
    }

    return $number;
}

1;

# ABSTRACT: Scramble nibbles of a 32-bit integer

__END__