Crypt::OOEnigma::Rotor - The Rotor object for use in Crypt::OOEnigma

  my $rotor = Crypt::OOEnigma::Rotor->new();

  # OR
  my $subHash ={ # the substitution code for the cipher for all A..Z
                 A => "Z",
                 B => "G",
                 # etc
               };
  my $freq = 2 ; # The number of letters enciphered per rotation
  my $start_position = 20 ; # modulo 26
  my $rotor = Crypt::OOEnigma::Rotor->new(cipher  => $subHash, 
                                          freq    => $freq
                                          start_position => $pos);




  # for internal use by Enigma machines:
  $rotor->init(); # returns the Rotor to its initial state
  my $op = $rotor->encode($some_letter); # encode a letter in the forward direction
  $op    = $rotor->revencode($some_letter); # encode a letter in the reverse direction
  $rotor->next(); # prepare for the next encoding, rotating as required
  $rotor->rotate(); # rotate to the next position

#!/usr/bin/perl -w
#
# Rotor.pm:
#
# Copyright (c) 2002 Ambriel Consulting
# sjb Sun Mar 17 20:43:56 GMT 2002
#

package Crypt::OOEnigma::Rotor ;
$VERSION="0.3";

use Storable ;
use Carp ;

# This rotor's substitution, identity by default
my @alpha = (A..Z);
my $subst = {};
foreach  my $val (@alpha){ 
  $subst->{$val} = $val ; 
}

my %fields = (
  cipher          => $subst,
  current_cipher  => {},
  inverse_cipher  => {},
  start_position  => 0,
  freq            => 1,
  use_count       => 0
);

# use Autoloading for accessors
use subs qw(cipher current_cipher inverse_cipher start_position freq use_count);

sub new {
  my $invocant = shift ;
  my $class = ref($invocant) || $invocant ;
  my $self = { %fields, @_ } ; 
  bless $self, $class ;
  $self->init(); # rotate the rotor to the correct position
  return $self ;
}

sub init {
  my $self = shift ; 
  # the current_cipher is based on the initial wiring of the rotor
  $self->current_cipher(Storable::dclone($self->cipher()));
  # Set the rotor to the correct position
  $self->rotate($self->start_position());
  # and set the appropriate reverse cipher
  my %inverse = reverse( %{$self->current_cipher()} );
  $self->inverse_cipher(\%inverse);
  # reset the use count
  $self->use_count(0);
}

sub encode {
  my $self = shift ; 
  my $source = shift;
  croak("Give me uppercase letters only") unless( $source =~ /[A-Z]/);
  my $result = $self->current_cipher()->{$source};
  $self->use_count($self->use_count() + 1);
  return $result;
}

# "reverse encode"
sub revencode {
  my $self = shift ; 
  my $source = shift;
  return $self->inverse_cipher()->{$source};
}

sub next{
  my $self = shift ; 
  # rotate if required
  if( ($self->use_count() % $self->freq()) == 0 ){
    $self->rotate(1);
  }
}

sub rotate {
  # TODO consider efficiency
  my $self = shift ; 
  my $places = shift;
  my @alpha = (A..Z);
  
  # get the old substitution and rotate it
  my @sub = (); 
  foreach my $key (@alpha){ 
    push @sub, $self->current_cipher()->{$key};
  }
  for(my $i = 0 ; $i < $places ; ++$i){
    unshift @sub, (pop @sub);
  }

  # create a new substitution hash from the new substitution
  my $newSub = {};
  foreach  my $key (@alpha){ 
    $newSub->{$key} = shift @sub ; 
  }

  # set up the new ciphers
  $self->current_cipher($newSub);
  my %inverse = reverse( %{$self->current_cipher()} );
  $self->inverse_cipher(\%inverse);

  return ;
}

sub AUTOLOAD {
  my $self = shift;
  # only access instance methods not class methods
  croak "$self is not an object" unless(ref($self));
  my $name = our $AUTOLOAD;
  return if($name =~ /::DESTROY/ );
  $name =~ s/.*://;   # strip fully-qualified portion
  unless (exists $self->{$name} ) {
    croak "Can't access `$name' field in object of class $self";
  } 
  if (@_) {
    return $self->{$name} = shift;
  } else {
    return $self->{$name};
  } 
}

1;