source: trunk/yat/omic/BamFile.h @ 2883

#ifndef theplu_yat_omic_bam_file
#define theplu_yat_omic_bam_file

// $Id: BamFile.h 2883 2012-12-03 12:48:51Z peter $
//
// Copyright (C) 2012 Peter Johansson
//
// This program 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; either version 3 of the License, or
// (at your option) any later version.
//
// This program 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/>.

#include "BamHeader.h"
#include "BamRead.h"

#include <sam.h>

#include <boost/utility.hpp>

#include <cassert>
#include <cstdio>
#include <sstream>
#include <stdexcept>
#include <string>

namespace theplu {
namespace yat {
namespace omic {

  /**
     Base class for bam files
   */
  template<typename Derived>
  class BamFile : boost::noncopyable
  {
    typedef Derived derived_type;
  public:
    /**
       Default Constructor
     */
    BamFile(void);

    /**
       \brief Destructor

       Closes file if it is open.
     */
    virtual ~BamFile(void);

    /**
       \brief close file
     */
    void close(void);

    /**
       \return \c true iff open
     */
    bool is_open(void) const;
  protected:
    /**
       open a bam file named \a fn with mode \a mode

       \see samopen
     */
    void open_base(const std::string& fn, const std::string& mode,
                   const void* aux);
    /**
       bam file handler
     */
    samfile_t* sf_;

    /**
       \brief filename of bam file

       The filename is set in open_base().
     */
    const std::string& filename(void) const { return filename_; }
  private:
    std::string filename_;
  };


  /**
     This class supports reading from a bam file.
   */
  class InBamFile : public BamFile<InBamFile>
  {
    typedef BamFile<InBamFile> super_t;
  public:
    /**
       \brief Default constructor
     */
    InBamFile(void);

    /**
       Create an input file

       \param fn string specifying the filename

       \see open(const std::string&)
     */
    explicit InBamFile(const std::string& fn);

    /**
       \brief destructor
     */
    virtual ~InBamFile(void);

    /**
       \return header
     */
    const BamHeader& header(void) const;

    /**
       \return index associated with BamFile

       First time this function is called an index file is loaded from
       disk. If bam file is named 'foo.bam', the index file should be
       named 'foo.bam.bai'. If no such file exists or this bam file
       reads from stdin, thsi function throws.
     */
    const bam_index_t* index(void) const;

    /**
       \brief Open an input bam file.

       \param fn string specifying the filename
     */
    void open(const std::string& fn);

    /**
       \brief read the next BamRead

       \return true on success
     */
    bool read(BamRead& read);

    /**
       \brief read the next BamRead

       \return true on success
     */
    bool read(BamRead& read, bam_iter_t iter);
  private:
    BamHeader header_;
    mutable bam_index_t* index_;
  };


  /**
     This class supports writing to a bam file.
   */
  class OutBamFile : public BamFile<OutBamFile>
  {
    typedef BamFile<OutBamFile> super_t;
  public:
    /**
       Create an output bam file
     */
    OutBamFile(void);

    /**
       \brief Create an output bam file.

       Equivalent to default constructor followed by a call to open(2).

       \see open(const std::string&, const BamHeader&)
     */
    OutBamFile(const std::string&, const BamHeader& header);

    /**
       \brief Open an output bam file.

       Opens an output bam file and writes the header contained in \a
       hdr.

       \param fn string specifying the filename
       \param hdr header
     */
    void open(const std::string& fn, const BamHeader& hdr);

    /**
       \brief write a read to output file
     */
    void write(const BamRead& read);
  private:
  };


  // template implementations
  template<class Derived>
  BamFile<Derived>::BamFile(void)
  : sf_(NULL) {}


  template<class Derived>
  BamFile<Derived>::~BamFile(void)
  {
    close();
  }


  template<class Derived>
  void BamFile<Derived>::close(void)
  {
    samclose(sf_);
    sf_ = NULL;
  }


  template<class Derived>
  bool BamFile<Derived>::is_open(void) const
  {
    return sf_;
  }


  template<class Derived>
  void BamFile<Derived>::open_base(const std::string& fn,
                                   const std::string& mode,
                                   const void* aux)
  {
    filename_ = fn;
    assert(!sf_);
    sf_ = samopen(fn.c_str(), mode.c_str(), aux);
    if (!sf_) {
      std::ostringstream ss;
      ss << "failed open " << fn;
      throw std::runtime_error(ss.str());
    }
  }

}}}
#endif