OwlCyberSecurity - MANAGER

Edit File: BufferedFileHandle.pm

package Archive::Zip::BufferedFileHandle;

# File handle that uses a string internally and can seek
# This is given as a demo for getting a zip file written
# to a string.
# I probably should just use IO::Scalar instead.
# Ned Konz, March 2000

use strict;
use IO::File;
use Carp;

use vars qw{$VERSION};

BEGIN {
    $VERSION = '1.60';
    $VERSION = eval $VERSION;
}

sub new {
    my $class = shift || __PACKAGE__;
    $class = ref($class) || $class;
    my $self = bless(
        {
            content  => '',
            position => 0,
            size     => 0
        },
        $class
    );
    return $self;
}

# Utility method to read entire file
sub readFromFile {
    my $self     = shift;
    my $fileName = shift;
    my $fh       = IO::File->new($fileName, "r");
    CORE::binmode($fh);
    if (!$fh) {
        Carp::carp("Can't open $fileName: $!\n");
        return undef;
    }
    local $/ = undef;
    $self->{content} = <$fh>;
    $self->{size}    = length($self->{content});
    return $self;
}

sub contents {
    my $self = shift;
    if (@_) {
        $self->{content} = shift;
        $self->{size}    = length($self->{content});
    }
    return $self->{content};
}

sub binmode { 1 }

sub close { 1 }

sub opened { 1 }

sub eof {
    my $self = shift;
    return $self->{position} >= $self->{size};
}

sub seek {
    my $self   = shift;
    my $pos    = shift;
    my $whence = shift;

# SEEK_SET
    if ($whence == 0) { $self->{position} = $pos; }

# SEEK_CUR
    elsif ($whence == 1) { $self->{position} += $pos; }

# SEEK_END
    elsif ($whence == 2) { $self->{position} = $self->{size} + $pos; }
    else                 { return 0; }

return 1;
}

sub tell { return shift->{position}; }

# Copy my data to given buffer
sub read {
    my $self = shift;
    my $buf  = \($_[0]);
    shift;
    my $len = shift;
    my $offset = shift || 0;

$$buf = '' if not defined($$buf);
    my $bytesRead =
        ($self->{position} + $len > $self->{size})
      ? ($self->{size} - $self->{position})
      : $len;
    substr($$buf, $offset, $bytesRead) =
      substr($self->{content}, $self->{position}, $bytesRead);
    $self->{position} += $bytesRead;
    return $bytesRead;
}

# Copy given buffer to me
sub write {
    my $self = shift;
    my $buf  = \($_[0]);
    shift;
    my $len = shift;
    my $offset = shift || 0;

$$buf = '' if not defined($$buf);
    my $bufLen = length($$buf);
    my $bytesWritten =
      ($offset + $len > $bufLen)
      ? $bufLen - $offset
      : $len;
    substr($self->{content}, $self->{position}, $bytesWritten) =
      substr($$buf, $offset, $bytesWritten);
    $self->{size} = length($self->{content});
    return $bytesWritten;
}

sub clearerr() { 1 }