trajwriter.hpp

/*
  This file is part of LOOS.
 
  LOOS (Lightweight Object-Oriented Structure library)
  Copyright (c) 2014, Tod D. Romo, Alan Grossfield
  Department of Biochemistry and Biophysics
  School of Medicine & Dentistry, University of Rochester
 
  This package (LOOS) is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation under version 3 of the License.
 
  This package is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#if !defined(LOOS_TRAJWRITER_HPP)
#define LOOS_TRAJWRITER_HPP
 
#include <iostream>
#include <string>
#include <stdexcept>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
 
#include <loos_defs.hpp>
#include <AtomicGroup.hpp>
#include <exceptions.hpp>
 
 
namespace loos {
 
 
 
  class TrajectoryWriter {
  public:
 
    TrajectoryWriter(const std::string& fname, const bool append = false)
      : _filename(fname), appending_(false) {
      struct stat statbuf;
 
      if (append && !stat(fname.c_str(), &statbuf))
    openStream(fname, true);
      else
    openStream(fname);
    }
 
 
 
    TrajectoryWriter(std::iostream* s, const bool append = false)
      : _filename("stream"), appending_(append), delete_(false) {}
 
 
    virtual ~TrajectoryWriter() {
      if (delete_)
    delete stream_;
    }
 
 
    virtual void setComments(const std::vector<std::string>& comments) { }
 
    virtual void setComments(const std::string& s) {
      std::vector<std::string> c(1, s);
      setComments(c);
    }
 
    virtual void writeFrame(const AtomicGroup& model) =0;
 
 
    virtual void writeFrame(const AtomicGroup& model, const uint step, const double time) {
      writeFrame(model);
    }
 
    virtual bool hasFrameStep() const { return(false); }
 
    virtual bool hasFrameTime() const { return(false); }
 
    virtual bool hasComments() const { return(false); }
 
 
    virtual uint framesWritten() const =0;
 
    bool isAppending() const { return(appending_); }
 
  protected:
    std::iostream* stream_;
    std::string _filename;
    bool appending_;
    bool delete_;
 
  private:
 
 
    // Handle opening up a stream to a file...  If it exists and we
    // are asked to append, seek to the end of the file.
    
    void openStream(const std::string& fname, const bool append = false) {
 
      
 
      std::ios_base::openmode mode = std::ios_base::out | std::ios_base::binary;
      if (append)
        mode |= std::ios_base::in;
      else
        mode |= std::ios_base::trunc;
 
      stream_ = new std::fstream(fname.c_str(), mode);
      if (append) {
    stream_->seekp(0, std::ios_base::end);
    // Check to see if file is empty...
    if (stream_->tellp() == 0)
      appending_ = false;
    else
      appending_ = true;
      }
 
      if (!stream_->good())
        throw(FileOpenError(fname, "Error while opening output trajectory file"));
 
 
      delete_ = true;    // Delete the stream pointer when dtor called
    }
    
 
  };
 
 
 
}
 
 
 
 
#endif