Re^2: Spinning cursor while waiting for search/copy process to be finished

[Ingvar]

Thank you very much, Ken. I tried a few options - wouldn't work :(. The best thing I can do is to have it rotate indefinitly - and I want it to stop after the process is over (and I don't know when). I even made the simpliest code I could to test it:

#!usr/bin/perl

use Time::HiRes;

$|=1; #autoflush

sub spin {
my ($arg) = @_;
$|++;
for (my $x = 0; $x <= $arg; ++$x){
  foreach (("-", "\\", "|", "/")){
    print $_; Time::HiRes::sleep (0.1); print "\b";
  }
} 
#print " \n";
}

my $i = 1;
print "Please wait...";
my $j = 0;
for ($i = 1; $i <= 10000; $i++) {
 $i++;
 $j=&spin($j);
}

print "Done\n";

I know I keep on missing something important... What?

[johngg]

I'm not sure why you are passing an argument to your spin subroutine and then feeding that back around as you do. You are not returning any thing explicitly from the subroutine so the likelihood is that it returns 1 denoting success of the last print statement in the loop.

You could make your subroutine into a closure, i.e. a reference to a subroutine, so that each time it is called it outputs the next symbol. That way, you don't have to worry about the looping logic in your subroutine but just call it whenever you want to show the next symbol. It is also probably a good idea to only show the next symbol once every 50 or 100 times around your logic loop, depending on the speed of that loop, as outputting a symbol every time will slow your program down.

$ perl -MTime::HiRes -MFcntl -Mstrict -Mwarnings -e '
> STDOUT->autoflush( 1 );
> 
> my $spinner = do {
>    my $idx = 0;
>    my @symbols = ( q{-}, q{\\}, q{|}, q{/} );
>    sub {
>        print $symbols[ $idx ++ ], qq{\b};
>        $idx = 0 if $idx > $#symbols;
>        };
>    };
> 
> for my $loop ( 1 .. 10_000 )
> {
>     $spinner->() unless $loop % 50;
>     Time::HiRes::sleep( 0.01 );
> }
> print qq{\n};'
/
$

I hope this is helpful.

[Ingvar]

Aha, it works with the loop! thank you so much! Next I will try to squeeze it somehow into my original code above and then write back...

[aitap]

You may have thought that the spin subroutine somehow runs at the same time with the main process, but that's not true: it's called in each iteration of the loop, $j never exceeds 1 (as explained), so each turn of the loop waits for 0.1*4=0.4 seconds and prints four characters: -, \, |, and /. You may want to use threads to make your subroutine run in parallel, as suggested above.

The idea of the spin function is printing only one character each time, incrementing the counter and continuing the loop, without sleeping or waiting for something else, without any inner loops. Consider this code:

sub spin {
 # as "golfy" as I could imagine for now
 print [qw{/ - \ |}]->[$_[0]++]."\033[1D";
 $_[0]%=4;
}
# ...
#somewhere outside the loop
my $j = 0;
# ...
foreach (@list_level_current_version) {
 spin($j); # print next spinning character
 # do the useful work
 if ($_ =~ /\Q$pattern/) { $dir = $_; last OUTER; } 
 # ...
}

The spin subroutine constructs an array of spinning characters, prints the character passed to it by index as the first argument, increments the index by one and makes it the remainder of devision by 4 (so it doesn't exceed possible index of spin character array). By modifying $_[0] directly it automatically modifies the $j variable passed as argument.
_{Edit: little rephrasing in the first paragraph}

[Ingvar]

Thanks a lot, it works perfectly well! The only thing I am still missing is how it can work? I mean, what is the function of $j variable if it is always 0? how is spin($j) processed then?

[aitap]

spin($j) increments $j by editing its $_[0]. As perlvar says,

A function is free to do in-place modifications of @_ and change its caller's values.

upcase_in($v1, $v2);  # this changes $v1 and $v2
sub upcase_in {
 for (@_) { tr/a-z/A-Z/ }
}

Scalars are already passed by reference, so you can modify scalar arguments without using typeglob mechanism (skipped) by referring explicitly to $_[0] etc.