IO::File::Log - IO::File abstraction on logging files

  use IO::File::Log;

  my $fh = new IO::File::Log "mylogfile";

  while (my $line = $fh->readline) {
      # Your code here...
  }

  my @remaining = $fh->getlines;

package IO::File::Log;

require 5.005_62;
use Carp;
use strict;
use warnings;
use IO::File;
use IO::Select;
use vars qw($AUTOLOAD);

our $VERSION = '1.01';

our $TIMEOUT = 5;		# Seconds between checks for changed file

sub new ($) {
    my $type	= $_[0];
    my $class	= ref($type) || $type || "IO::File::Log";
    my $file	= $_[1];

    return undef unless -f $file;

    my $fh = new IO::File $file or return undef;
    my $sel = new IO::Select or return undef;

    $sel->add($fh);

    return bless { 

	file	=> $file, 
	sel	=> $sel, 
	fh	=> $fh, 
	stat	=> [ _stat($file) ] 

	}, $class;
}

sub _stat ($) {
    return (stat $_[0])[0, 1, 6];
}

sub _dcomp {
    my $l1 = shift;
    my $l2 = shift;

    return 0 unless @$l1 and @$l2;

    for (@$l1 < @$l2 ? 0 .. @$l1 : 0 .. @$l2) {
 	return 0 if 
 	    defined $l1->[$_] and defined $l2->[$_] and $l1->[$_] ne $l2->[$_];
    }

    return 1;
}

				# Tell the module to close the current log
				# and re-open it, possibly getting a
				# different file

sub _reset {
    my $self = shift;

    $self->{sel}->remove($self->{fh});
    $self->{fh}->close;
    $self->{fh} = new IO::File $self->{file}
    or croak "Cannot re-open changed file ", $self->{file}, ": $!";
    $self->{stat} = [ _stat($self->{file}) ];
    $self->{sel}->add($self->{fh});
}

				# At EOF, wait for either more output
				# or a new file with the same name, then
				# do the right thing.
sub _loop_on_end {
    my $self = shift;

    seek($self->{fh}, 0, 1);
    $self->{fh}->clearerr;
    return unless $self->{fh}->eof;

				# At EOF, select with a small timeout, while
				# checking for a new file...
    
    while (1) {

#	warn "# ostat = (", join(',', @{$self->{stat}}), ")\n";
#	warn "# nstat = (", join(',', (stat($self->{file}))[0, 1, 6]), ")\n";

	if (-f $self->{file} and 
	    ! _dcomp([(stat($self->{file}))[0, 1, 6]], 
		     $self->{stat})) 
	{
#	    warn "# File changed\n";

	    $self->_reset;

	}

				# The following might help to refresh
				# the error condition on some systems

	$self->{fh}->clearerr;
	seek($self->{fh}, 0, 1);

	my $fh = ($self->{sel}->can_read($TIMEOUT))[0];

#	warn "# select returned\n";

	unless (defined $fh) {
#	    warn "#select returned undef\n";
	    next;
	}

	unless ($fh->eof) {
	    return if ($fh eq $self->{fh});
	}

	sleep $TIMEOUT;
    }

}

				# Execute the named function on the
				# IO::File object
sub _drive {
    my $self = shift;
    my $func = shift;

#    warn "# Invoke $func on $self->{fh}\n";

    return $self->{fh}->$func(@_);
}

sub AUTOLOAD {

    my $self = shift;

    $AUTOLOAD =~ s/^IO::File::Log:://;

    if (grep { $AUTOLOAD eq $_ } 
	qw( 
	    eof 
	    stat
	    seek
	    tell
	    close 
	    error
	    fileno 
	    syssek
	    untaint
	    DESTROY 
	    getlines 
	    clearerr

	    )) {

				# Functions that can be executed at
				# any point...

	return $self->_drive($AUTOLOAD, @_);

    }
    elsif (grep { $AUTOLOAD eq $_ } 
	   qw( 
	       getline 
	       read 
	       getc 
	       sysread
	       
	       )) {

				# Functions that must be executed
				# at the end of the file...

	$self->_loop_on_end;
	return $self->_drive($AUTOLOAD, @_);
    }
    else {

				# Let the user know that we do not
				# support just anything

	croak "Function $AUTOLOAD not supported";

    }
}

# Preloaded methods go here.

1;
__END__