InSilicoSpectro::Utils::io - InSilicoSpectro::Utils::io documentation

use strict;

package InSilicoSpectro::Utils::io;
require Exporter;

our (@ISA,@EXPORT,@EXPORT_OK, $VERBOSE);
@ISA = qw(Exporter);

@EXPORT = qw(&getFD $VERBOSE &compressFile &uncompressFile &zipFiles &getMD5 &croakIt &isInteractive);
@EXPORT_OK = ();

use Carp;
use File::Glob qw(:glob);

sub isInteractive{
  return -t STDIN && -t STDOUT;
}

sub getFD{
  my ($this, $v)=@_;

  if((ref $v) eq "GLOB"){
    return $v;
  }else{
    my $fd;
    open ($fd, "$v") or return undef;
    return $fd;
  }
}



use Compress::Zlib;

sub uncompressFile{
  my ($fname, $arg)=@_;

  my $rmSource=1;

  if(defined $arg){
    $rmSource=$arg->{remove} if defined $arg->{remove};
  }

  croak "try to gunzip a file without a .gz suffix [$fname]" unless $fname=~/^(.*)\.gz$/i;

  my $outFile=$1;
  $outFile=$arg->{dest} if $arg->{dest};

  open(FDOUT, ">$outFile") or croak "cannot de-inlfate towards [$outFile]: $!";

  my $gz = gzopen($fname, "rb") or croak "Cannot open $fname: $gzerrno";
  my $buffer;
  print FDOUT $buffer while $gz->gzread($buffer) > 0 ;

  croak "Error uncompressing from $fname: $gzerrno" . ($gzerrno+0) if $gzerrno != Z_STREAM_END ;
  #$gz->gzflush("Z_FINISH");
  $gz->gzclose() ;

  undef $gz;
  unlink $fname if $rmSource;
  close FDOUT;
  return $outFile;
}


sub compressFile{
  my ($fname, $arg)=@_;

  my $rmSource=1;

  if(defined $arg){
    $rmSource=$arg->{remove} if defined $arg->{remove};
  }


  open(FDIN, "<$fname") or croak "cannot compress from [$fname]: $!";

  my $outFile="$fname.gz";

  if($rmSource){
    unless (system ("gzip --version")){
      unlink $outFile;
      my $cmd="gzip $fname";
      system ($cmd) && die "cannot $cmd";
      return $outFile;
    }
  }

  my $gz = gzopen("$outFile", "wb")
    or CORE::die "Cannot open [$outFile]: $gzerrno\n" ;
  while (<FDIN>) {
    $gz->gzwrite($_) 
      or CORE::die "error writing: $gzerrno\n" ;
  }
  close FDIN;
  $gz->gzclose;
  unlink $fname if $rmSource;
  undef $gz;

  return $outFile;
}


sub headGz{
  my ($fname, $lines, $re)=@_;
  $lines=10 unless $lines;
  open(FDIN, "<$fname") or croakIt("cannot compress from [$fname]: $!");

  my @res;
  croakIt("try to gunzip a file without a .gz suffix [$fname]") unless $fname=~/^(.*)\.gz$/i;

  my $qr;
  if(defined $re){
    eval "\$qr = qr$re";
    croakIt("unable to compile regular expresion [$re]") unless defined $qr;
  }

  my $gz = gzopen($fname, "rb") or croakIt("Cannot open $fname: $gzerrno");
  my $buffer;
  my $i=0;
  while($gz->gzread($buffer) > 0){
    foreach(split /\n/, $buffer){
      if(((defined $re) and ($_=~$qr)) or (not defined $re)){
	chomp;
	push @res, $_;
	$i++;
      }
      last if $i>=$lines;
    }
    last if $i>=$lines;
  }

  $gz->gzclose() ;
  undef $gz;

  return wantarray?@res:(join "\n", @res);;
}

use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
use SelectSaver;
use File::Basename;

sub zipFiles{
  my ($dest, $files, $baseNameOnly)=@_;

  my $zip = Archive::Zip->new();
  #my $member = $zip->addDirectory("./");
  foreach(@$files){
    if($baseNameOnly){
      $zip->addFile($_, basename $_);
    }else{
      $zip->addFile($_);
    }
  }

  if((!defined $dest) || ((ref $dest) eq 'GLOB')){
    new SelectSaver(InSilicoSpectro::Utils::io->getFD($dest)) if defined $dest;
    croak "io::zipFiles($dest, $files): write error" unless $zip->writeToFileHandle(\*STDOUT) == AZ_OK;
  }else{
    croak "io::zipFiles($dest, $files): write error" unless $zip->writeToFileNamed($dest) == AZ_OK;
  }
}

use Digest::MD5 qw(md5);
sub getMD5{
  my $f=$_[0];
  open (*fd, "<$f") or croak "Cannot open for reading [$f]: $!";
  my $md5 = Digest::MD5->new();
  $md5->addfile(\*fd);
  close *fd;
  return $md5->b64digest();
}


sub croakIt{
  my $msg=shift;
  if($InSilicoSpectro::Utils::io::VERBOSE){
    croak "$msg\n<pre>".Carp::longmess()."\n</pre>\n";
  }else{
    croak $msg;
  }
}

1;