szfstream.hpp

Go to the documentation of this file.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use these files except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Copyright 2012 - Gonzalo Iglesias, Adrià de Gispert, William Byrne

#ifndef SZFSTREAM_HPP
#define SZFSTREAM_HPP

#ifdef USE_FDSTREAM_HPP
#include "fdstream.hpp"
#endif

namespace ucam {
namespace util {

class iszfstream {

 private:

  FILE* sfile_;

#ifndef  USE_FDSTREAM_HPP
  boost::scoped_ptr<std::ifstream> file;
  boost::scoped_ptr<boost::iostreams::filtering_streambuf<boost::iostreams::input> >
  in;
#endif
  std::istream *filestream_;
  std::string auxfilename;

 public:

  iszfstream () :
    sfile_ ( NULL ),
    filestream_ ( NULL ) {
  };
  iszfstream ( const std::string& filename ) :
    sfile_ ( NULL ),
    filestream_ ( NULL ) {
    open ( filename );
  };

  iszfstream ( const std::stringstream& ss ) :
    sfile_ ( NULL ),
    filestream_ ( NULL ) {
    open ( ss );
  };

  inline std::istream *getStream() {
    return filestream_;
  };

  inline void open ( const std::stringstream& ss ) {
    close();
    filestream_ = new std::stringstream ( ss.str() );
  };

  inline void open ( const std::string& filename ) {
    close();
#ifdef USE_FDSTREAM_HPP
    if ( filename != "-" ) {
      LDEBUG ( "Test file=[" << filename << "]" );
      sfile_ = fopen ( filename.c_str(), "r" );
      USER_CHECK ( sfile_ != NULL, "Error while opening file" );
      fclose ( sfile_ );
      //Now we can assume more or less safely that file really exists (sigh)
    }
    //lets open this with the pipe.
    std::string command = "zcat -f ";
    command += filename;
    LINFO ( "Opening (fd)" << command );
    sfile_ = popen ( command.c_str(), "r" );
    USER_CHECK ( sfile_ != NULL, "Error while opening pipe" );
    filestream_ = new boost::fdistream ( fileno ( sfile_ ) );
    USER_CHECK (filestream_, "File Stream allocation failed!");
#else
    LINFO ( "Opening " << filename );
    std::string auxfilename = filename;
    if (auxfilename == "-" ) auxfilename = "/dev/stdin";
    file.reset (new std::ifstream (auxfilename.c_str(),
                                   std::ios_base::in | std::ios_base::binary) );
    if (!USER_CHECK (file->is_open(),
                     "Error while opening file:") ) exit (EXIT_FAILURE);
    in.reset (new boost::iostreams::filtering_streambuf<boost::iostreams::input>);
    if (auxfilename.substr (0, 5) != "/dev/" ) {
      if (ends_with (auxfilename, ".gz") )
        in->push (boost::iostreams::gzip_decompressor() );
    }
    in->push (*file);
    filestream_ = new std::istream (&*in);
    if (!USER_CHECK (filestream_,
                     "File Stream allocation failed!") ) exit (EXIT_FAILURE);
    //Try to detect whether it actually _is_ a compressed file (sigh) .
    if (ends_with (auxfilename, ".gz") ) {
      filestream_->peek();
      if (!USER_CHECK (filestream_->good(),
                       "File not open/doesn't exist... Or possibly not compressed but ends with .gz? " ) )
        exit (EXIT_FAILURE);
    }
#endif
  };

  inline bool is_open() {
    return ( filestream_ != NULL );
  };

  ~iszfstream () {
    close();
  };

  virtual inline int eof() {
    return filestream_->eof();
  };

  inline void close() {
    if ( !is_open() ) return;
#ifndef USE_FDSTREAM_HPP
    in.reset();
    file.reset();
#endif
    if ( sfile_ ) {
      fclose ( sfile_ );
      sfile_ = NULL;
    }
    if ( filestream_ ) {
      delete filestream_;
      filestream_ = NULL;
    }
  };

  virtual operator void *() {
    return eof() ? NULL : this;
  };

  virtual inline iszfstream& getline ( std::string& line );

  friend iszfstream& getline ( iszfstream&, std::string&);

  template <typename T>
  friend iszfstream& operator>> ( iszfstream&, T&);

};

inline iszfstream& getline ( iszfstream&  izs, std::string& line ) {
  std::getline ( *izs.filestream_, line );
  return izs;
};

inline iszfstream& iszfstream::getline ( std::string& line ) {
  ::ucam::util::getline ( *this, line );
  return *this;
};

template <typename T>
inline iszfstream& operator>> ( iszfstream& iszf, T& stff ) {
  *iszf.filestream_ >> stff;
  return iszf;
};

class oszfstream {
 private:
  bool append_;

  FILE* sfile_;

#ifndef USE_FDSTREAM_HPP
  boost::scoped_ptr<std::ofstream> file;
  boost::scoped_ptr<boost::iostreams::filtering_streambuf<boost::iostreams::output> >
  out;
#endif
  std::ostream *filestream_;
  std::string myfilename;

 public:

  oszfstream ( const std::string& filename , bool append = false) :
    sfile_ ( NULL ),
    filestream_ ( NULL ),
    append_ (append) {
    open ( filename );
  }

  oszfstream ( const std::stringstream& ss ) :
    sfile_ ( NULL ), filestream_ ( NULL ), append_ (false) {
    open ( ss );
  }

  inline std::ostream *getStream() {
    return filestream_;
  };

  void open ( const std::stringstream& ss ) {
    close();
    filestream_ = new std::stringstream ( ss.str() );
  }

  void open ( const std::string& filename ) {
    close();
    if (filename == "") {
      LWARN ("Empty file name?");
      return;
    }
    std::string cmd;
    DirName ( cmd, filename );
    if ( cmd != "" && cmd != "./" && cmd != "/" ) {
      cmd = "mkdir -p " + cmd;
      int a = system ( cmd.c_str() );
    }
#ifdef USE_FDSTREAM_HPP
    std::string command = "cat - >";
    if ( filename.size() > 3 )
      if ( filename.substr ( filename.size() - 3 ) == ".gz" ) command = "gzip > ";
    if (append_) command += ">";
    if ( filename == "-" ) command += "/dev/stdout";
    else command += filename;
    if ( ( sfile_ = popen ( command.c_str(), "w" ) ) == NULL ) {
      cerr << "Error while opening file via: " << command << endl;
      exit ( EXIT_FAILURE );
    }
    LINFO ( "Opening (fd)" << command );
    filestream_ = new boost::fdostream ( fileno ( sfile_ ) );
#else
    if ( filename == "-" ) myfilename = "/dev/stdout";
    else myfilename = filename;
    if (!append_)
      file.reset (new std::ofstream (myfilename.c_str(),
                                     std::ios_base::out | std::ios_base::binary ) );
    else
      file.reset (new std::ofstream (myfilename.c_str(),
                                     std::ios_base::out | std::ios_base::binary | std::ios_base::app ) );
    if (!file->is_open() ) {
      std::cerr << "Error while opening " << filename << std::endl;
      exit (EXIT_FAILURE);
    }
    out.reset (new boost::iostreams::filtering_streambuf<boost::iostreams::output>);
    if (filename.substr (0, 5) != "/dev/" ) {
      if (ends_with (filename, ".gz") ) {
        out->push (boost::iostreams::gzip_compressor() );
      }
    }
    out->push (*file);
    LINFO ( "Opening " << filename  );
    filestream_ = new std::ostream (&*out);
    if (filestream_ == NULL) {
      std::cerr << "Error while opening " << filename << std::endl;
      exit (EXIT_FAILURE);
    }
#endif
  };

  ~oszfstream () {
    close();
  };

  bool is_open() {
    return ( filestream_ != NULL );
  };

  inline void close() {
    if ( !is_open() ) return;
#ifndef USE_FDSTREAM_HPP
    out.reset();
    file.reset();
#endif
    if ( filestream_ ) {
      delete filestream_;
      filestream_ = NULL;
    }
    if ( sfile_ ) {
      fclose ( sfile_ );
      sfile_ = NULL;
    }
  };

  typedef std::basic_ostream<char, std::char_traits<char> > CoutType;
  typedef CoutType& ( *StandardEndLine ) ( CoutType&);

  oszfstream& operator<< ( StandardEndLine manip ) {
    *this << "\n";
    return *this;
  };

  template <typename T>
  inline oszfstream& operator<< ( const T& stff ) {
    *filestream_ << stff;
    return *this;
  };

};

template <typename FM>
inline void readtextfile ( const std::string& filename, FM& fm ) {
  iszfstream iszf ( filename );
  std::string line;
  while ( getline ( iszf, line ) ) {
    fm.parse ( line );
  }
  iszf.close();
};

template <typename FM>
inline void writetextfile ( const std::string& filename, FM& fm ) {
  oszfstream oszf ( filename );
  std::string line;
  while ( fm.toLine ( line ) ) {
    oszf << line << endl;
  }
  oszf.close();
};

template <class StreamT = std::istream >
class FastForwardRead {
 private:
  boost::scoped_ptr<StreamT> af_;
  uint idx_;
 public:
  FastForwardRead ( StreamT *af ) :
    af_ ( af ),
    idx_ ( 0 ) {
    LDEBUG ( "Ready!" );
  };

  inline bool operator() ( uint id, std::string *line ) {
    bool finished = false;
    std::string aux;
    *line = "";
    USER_CHECK ( idx_ <= id, "Will not read backwards!" );
    while ( ++idx_ < id ) {
      USER_CHECK ( getline ( *af_, aux ), "source text file out of range!" );
    }
    if ( !getline ( *af_, *line ) ) {
      finished = true;
    }
    return finished;
  };

};

}
} // end namespaces

#endif