my @files = <*.txt>;

@files = map { $_->[0] }
     sort { $b->[1] <=> $a->[1] }
     map { [ $_, (-M $_) ] } @files;
[download]

You'll have to be in the appropriate directory for this to work, and you'll end up with @files containing a the filenames, sorted ascending by last modification time. You could do a simple addition and splice operation to pare down the list to the files you haven't used before.

It's a different approach, anyway.

use File::CounterFile;
my $counter = File::CounterFile->new("/path/to/sentinel.txt", "0000");
chdir "/path/to/where/the/files/are" or die "chdir: $!";
## see if a new file has arrived
while (-e (my $file = "elmo$counter.txt")) {
  process_file($file);
  $counter = "0000" if ++$counter == "10000";
}
[download]

update: (to add some explanation...)

The File::Counterfile module creates a persistent file. The object returned from the module is overloaded so that it can be incremented and interpolated, but every change to the object gets reflected as a change to the original file. It uses Perl's "magical autoincrement" to generate items here from 0000 to 9999. Of course, when that wraps, I need to force it back to 0000. I'm also presuming this program gets invoked every 15 minutes or whatever, and that process_file unlinks the file as it does the job.

And now the explanation is longer than the program, so I'll stop. {grin}

-- Randal L. Schwartz, Perl hacker

$next_id = ($id + 1) % 10000;
[download]

$named_id = sprintf('%04d', $id);
[download]

 # Pass list of filenames as arguments
 sub listnumbers {
  my %files;
  foreach (@_) {
   next unless (/^elmo(\d+)\.txt$/);
   my $n = int($1); # Force string to integer
   $files{$n} = $_;
  }
  # Did we wrap-around? This happens iff we have a 0 and a
  # 9999
  if (exists($files{0}) && exists($files{9999})) {
   # OK, so this is the tricky case
   # Count down from 9999 to find the first file
   my $lwm = 9999;
   while (exists($files{$lwm})) {
     --$lwm;
     die "I think something broke" if ($lwm < 5000);
   }
   # And count up from 0 to get the last file
   my $hwm = 0;
   while (exists($files{$hwm})) {
    ++$hwm;
    die "I think something broke" if ($hwm > 5000);
   }
   # And return the intervals
   ($lwm+1..9999, 0..$hwm-1);
  }
  else {
   # Easy case
   sort keys %files;
  }
 }
 # Main code
 my @numbers = listnumbers(<>);
 my $lastkey = read_lastkey();
 my $foundlast = 0;
 foreach (@numbers) {
  if ($_ == $lastkey) {
   $foundlast = 1;
   next;
  }
  if ((($_ + 1) % 10000) == $lastkey) {
   $foundlast = 1;
  }
  if ($foundlast) {
    process_file(sprintf("elmo%04d.txt", $_));
    $lastkey = $_;
  }
 }
 if ($foundlast) {
  write_lastkey($lastkey);
 }
 else {
  die "Didn't find a plausible sequel to $lastkey in [@numbers]";
 }
[download]

• cannot rely on the mtime from the remote server and the files actually arriving in a sequence that corresponds to the mtime.
• I cannot either rely on the comm's link to the remote server being up
• cannot trust the files to be in sequence, but they will be in order, the gap will be unspecific.

But thanks for the above, to all, I have something now that 'will do'

...cannot trust the files to be in sequence, but
they will be in order, the gap will be unspecific

Woah! That really throws a monkey wrench in things. So the file 9999 might not even exist, but 9998 and 0000 will? Hrmm....this calls for another solution. Let's have the program make a best guess as to where the selection of files actually begins. First, some code to generate "random elmos" (but not infinite elmos!):

my ($rand,%seen,@files);
my $number=shift || 15;
{
  $rand = substr(rand,-7,4);
  unless ($seen{$rand}++) { ## Files must be unique!
    push @files, "elmo$rand.txt";
    --$number or last;
  }
  redo;
}
[download]

And here's the actual code. Globbing is a better way for actual use, of course.

my @files = <elmo*.txt>;

## Convert the list to numbers and warn about any unusual elmos:
@files = map {
  m/^elmo(\d{4})\.txt$/ and $1 or 
  die "What is $_ doing here?!\n"; } @files;

## Now figure out where the largest gap is:
my ($diff,$old,$high);
for (sort @files) {
  $diff=$_-$old and $high=$_ if $_-$old>$diff;
  $old=$_;
}

## Now go in order, starting at the first value after the gap:
for (
  map  {$_->[0]}
  sort {$a->[1] <=> $b->[1] }
  map  {[$_, $_ >= $high ? $_-10000 : $_]} @files) {
  print "Parsing elmo$_.txt\n";
}
[download]