converted self from hash ref to array ref

diff --git a/lib/Perl/Tidy/FileWriter.pm b/lib/Perl/Tidy/FileWriter.pm
index e596bcfec031d481258fcca18d3e07a279e6b25a..d898ff419d31625dba06580b085168fd3596e6f9 100644 (file)
--- a/lib/Perl/Tidy/FileWriter.pm
+++ b/lib/Perl/Tidy/FileWriter.pm
@@ -12,9 +12,32 @@ our $VERSION = '20200822';
 # Maximum number of little messages; probably need not be changed.
 my $MAX_NAG_MESSAGES = 6;
 
+BEGIN {
+
+    # Array index names for variables
+    my $i = 0;
+    use constant {
+        _line_sink_object_           => $i++,
+        _logger_object_              => $i++,
+        _rOpts_                      => $i++,
+        _output_line_number_         => $i++,
+        _consecutive_blank_lines_    => $i++,
+        _consecutive_nonblank_lines_ => $i++,
+        _first_line_length_error_    => $i++,
+        _max_line_length_error_      => $i++,
+        _last_line_length_error_     => $i++,
+        _first_line_length_error_at_ => $i++,
+        _max_line_length_error_at_   => $i++,
+        _last_line_length_error_at_  => $i++,
+        _line_length_error_count_    => $i++,
+        _max_output_line_length_     => $i++,
+        _max_output_line_length_at_  => $i++,
+    };
+}
+
 sub write_logfile_entry {
     my ( $self, $msg ) = @_;
-    my $logger_object = $self->{_logger_object};
+    my $logger_object = $self->[_logger_object_];
     if ($logger_object) {
         $logger_object->write_logfile_entry($msg);
     }
@@ -24,50 +47,51 @@ sub write_logfile_entry {
 sub new {
     my ( $class, $line_sink_object, $rOpts, $logger_object ) = @_;
 
-    return bless {
-        _line_sink_object           => $line_sink_object,
-        _logger_object              => $logger_object,
-        _rOpts                      => $rOpts,
-        _output_line_number         => 1,
-        _consecutive_blank_lines    => 0,
-        _consecutive_nonblank_lines => 0,
-        _first_line_length_error    => 0,
-        _max_line_length_error      => 0,
-        _last_line_length_error     => 0,
-        _first_line_length_error_at => 0,
-        _max_line_length_error_at   => 0,
-        _last_line_length_error_at  => 0,
-        _line_length_error_count    => 0,
-        _max_output_line_length     => 0,
-        _max_output_line_length_at  => 0,
-    }, $class;
+    my $self = [];
+    $self->[_line_sink_object_]           = $line_sink_object;
+    $self->[_logger_object_]              = $logger_object;
+    $self->[_rOpts_]                      = $rOpts;
+    $self->[_output_line_number_]         = 1;
+    $self->[_consecutive_blank_lines_]    = 0;
+    $self->[_consecutive_nonblank_lines_] = 0;
+    $self->[_first_line_length_error_]    = 0;
+    $self->[_max_line_length_error_]      = 0;
+    $self->[_last_line_length_error_]     = 0;
+    $self->[_first_line_length_error_at_] = 0;
+    $self->[_max_line_length_error_at_]   = 0;
+    $self->[_last_line_length_error_at_]  = 0;
+    $self->[_line_length_error_count_]    = 0;
+    $self->[_max_output_line_length_]     = 0;
+    $self->[_max_output_line_length_at_]  = 0;
+    bless $self, $class;
+    return $self;
 }
 
 sub get_output_line_number {
     my $self = shift;
-    return $self->{_output_line_number};
+    return $self->[_output_line_number_];
 }
 
 sub decrement_output_line_number {
     my $self = shift;
-    $self->{_output_line_number}--;
+    $self->[_output_line_number_]--;
     return;
 }
 
 sub get_consecutive_nonblank_lines {
     my $self = shift;
-    return $self->{_consecutive_nonblank_lines};
+    return $self->[_consecutive_nonblank_lines_];
 }
 
 sub reset_consecutive_blank_lines {
     my $self = shift;
-    $self->{_consecutive_blank_lines} = 0;
+    $self->[_consecutive_blank_lines_] = 0;
     return;
 }
 
 sub want_blank_line {
     my $self = shift;
-    unless ( $self->{_consecutive_blank_lines} ) {
+    unless ( $self->[_consecutive_blank_lines_] ) {
         $self->write_blank_code_line();
     }
     return;
@@ -79,8 +103,8 @@ sub require_blank_code_lines {
     # unless -mbl=0.  This allows extra blank lines to be written for subs and
     # packages even with the default -mbl=1
     my ( $self, $count ) = @_;
-    my $need   = $count - $self->{_consecutive_blank_lines};
-    my $rOpts  = $self->{_rOpts};
+    my $need   = $count - $self->[_consecutive_blank_lines_];
+    my $rOpts  = $self->[_rOpts_];
     my $forced = $rOpts->{'maximum-consecutive-blank-lines'} > 0;
     foreach my $i ( 0 .. $need - 1 ) {
         $self->write_blank_code_line($forced);
@@ -91,13 +115,13 @@ sub require_blank_code_lines {
 sub write_blank_code_line {
     my $self   = shift;
     my $forced = shift;
-    my $rOpts  = $self->{_rOpts};
+    my $rOpts  = $self->[_rOpts_];
     return
       if (!$forced
-        && $self->{_consecutive_blank_lines} >=
+        && $self->[_consecutive_blank_lines_] >=
         $rOpts->{'maximum-consecutive-blank-lines'} );
-    $self->{_consecutive_blank_lines}++;
-    $self->{_consecutive_nonblank_lines} = 0;
+    $self->[_consecutive_blank_lines_]++;
+    $self->[_consecutive_nonblank_lines_] = 0;
     $self->write_line("\n");
     return;
 }
@@ -107,16 +131,16 @@ sub write_code_line {
     my $a    = shift;
 
     if ( $a =~ /^\s*$/ ) {
-        my $rOpts = $self->{_rOpts};
+        my $rOpts = $self->[_rOpts_];
         return
-          if ( $self->{_consecutive_blank_lines} >=
+          if ( $self->[_consecutive_blank_lines_] >=
             $rOpts->{'maximum-consecutive-blank-lines'} );
-        $self->{_consecutive_blank_lines}++;
-        $self->{_consecutive_nonblank_lines} = 0;
+        $self->[_consecutive_blank_lines_]++;
+        $self->[_consecutive_nonblank_lines_] = 0;
     }
     else {
-        $self->{_consecutive_blank_lines} = 0;
-        $self->{_consecutive_nonblank_lines}++;
+        $self->[_consecutive_blank_lines_] = 0;
+        $self->[_consecutive_nonblank_lines_]++;
     }
     $self->write_line($a);
     return;
@@ -126,12 +150,12 @@ sub write_line {
     my ( $self, $a ) = @_;
 
     # TODO: go through and see if the test is necessary here
-    if ( $a =~ /\n$/ ) { $self->{_output_line_number}++; }
+    if ( $a =~ /\n$/ ) { $self->[_output_line_number_]++; }
 
-    $self->{_line_sink_object}->write_line($a);
+    $self->[_line_sink_object_]->write_line($a);
 
     # This calculation of excess line length ignores any internal tabs
-    my $rOpts  = $self->{_rOpts};
+    my $rOpts  = $self->[_rOpts_];
     my $exceed = length($a) - $rOpts->{'maximum-line-length'} - 1;
     if ( $a =~ /^\t+/g ) {
         $exceed += pos($a) * ( $rOpts->{'indent-columns'} - 1 );
@@ -139,45 +163,46 @@ sub write_line {
 
     # Note that we just incremented output line number to future value
     # so we must subtract 1 for current line number
-    if ( length($a) > 1 + $self->{_max_output_line_length} ) {
-        $self->{_max_output_line_length}    = length($a) - 1;
-        $self->{_max_output_line_length_at} = $self->{_output_line_number} - 1;
+    if ( length($a) > 1 + $self->[_max_output_line_length_] ) {
+        $self->[_max_output_line_length_] = length($a) - 1;
+        $self->[_max_output_line_length_at_] =
+          $self->[_output_line_number_] - 1;
     }
 
     if ( $exceed > 0 ) {
-        my $output_line_number = $self->{_output_line_number};
-        $self->{_last_line_length_error}    = $exceed;
-        $self->{_last_line_length_error_at} = $output_line_number - 1;
-        if ( $self->{_line_length_error_count} == 0 ) {
-            $self->{_first_line_length_error}    = $exceed;
-            $self->{_first_line_length_error_at} = $output_line_number - 1;
+        my $output_line_number = $self->[_output_line_number_];
+        $self->[_last_line_length_error_]    = $exceed;
+        $self->[_last_line_length_error_at_] = $output_line_number - 1;
+        if ( $self->[_line_length_error_count_] == 0 ) {
+            $self->[_first_line_length_error_]    = $exceed;
+            $self->[_first_line_length_error_at_] = $output_line_number - 1;
         }
 
-        if (
-            $self->{_last_line_length_error} > $self->{_max_line_length_error} )
+        if ( $self->[_last_line_length_error_] >
+            $self->[_max_line_length_error_] )
         {
-            $self->{_max_line_length_error}    = $exceed;
-            $self->{_max_line_length_error_at} = $output_line_number - 1;
+            $self->[_max_line_length_error_]    = $exceed;
+            $self->[_max_line_length_error_at_] = $output_line_number - 1;
         }
 
-        if ( $self->{_line_length_error_count} < $MAX_NAG_MESSAGES ) {
+        if ( $self->[_line_length_error_count_] < $MAX_NAG_MESSAGES ) {
             $self->write_logfile_entry(
                 "Line length exceeded by $exceed characters\n");
         }
-        $self->{_line_length_error_count}++;
+        $self->[_line_length_error_count_]++;
     }
     return;
 }
 
 sub report_line_length_errors {
     my $self                    = shift;
-    my $rOpts                   = $self->{_rOpts};
-    my $line_length_error_count = $self->{_line_length_error_count};
+    my $rOpts                   = $self->[_rOpts_];
+    my $line_length_error_count = $self->[_line_length_error_count_];
     if ( $line_length_error_count == 0 ) {
         $self->write_logfile_entry(
             "No lines exceeded $rOpts->{'maximum-line-length'} characters\n");
-        my $max_output_line_length    = $self->{_max_output_line_length};
-        my $max_output_line_length_at = $self->{_max_output_line_length_at};
+        my $max_output_line_length    = $self->[_max_output_line_length_];
+        my $max_output_line_length_at = $self->[_max_output_line_length_at_];
         $self->write_logfile_entry(
 "  Maximum output line length was $max_output_line_length at line $max_output_line_length_at\n"
         );
@@ -191,17 +216,18 @@ sub report_line_length_errors {
         );
 
         $word = ( $line_length_error_count > 1 ) ? "First" : "";
-        my $first_line_length_error    = $self->{_first_line_length_error};
-        my $first_line_length_error_at = $self->{_first_line_length_error_at};
+        my $first_line_length_error    = $self->[_first_line_length_error_];
+        my $first_line_length_error_at = $self->[_first_line_length_error_at_];
         $self->write_logfile_entry(
 " $word at line $first_line_length_error_at by $first_line_length_error characters\n"
         );
 
         if ( $line_length_error_count > 1 ) {
-            my $max_line_length_error     = $self->{_max_line_length_error};
-            my $max_line_length_error_at  = $self->{_max_line_length_error_at};
-            my $last_line_length_error    = $self->{_last_line_length_error};
-            my $last_line_length_error_at = $self->{_last_line_length_error_at};
+            my $max_line_length_error    = $self->[_max_line_length_error_];
+            my $max_line_length_error_at = $self->[_max_line_length_error_at_];
+            my $last_line_length_error   = $self->[_last_line_length_error_];
+            my $last_line_length_error_at =
+              $self->[_last_line_length_error_at_];
             $self->write_logfile_entry(
 " Maximum at line $max_line_length_error_at by $max_line_length_error characters\n"
             );