BamFile.h

#ifndef theplu_yat_omic_bam_file
#define theplu_yat_omic_bam_file

// $Id: BamFile.h 3550 2017-01-03 05:41:02Z peter $

/*
  Copyright (C) 2012, 2013, 2014, 2016 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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 "config_bam.h"

#include "yat/utility/Exception.h"
#include "yat/utility/yat_assert.h"

#include YAT_SAM_HEADER

#include <boost/utility.hpp>

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

namespace theplu {
namespace yat {
namespace omic {

  template<typename Derived>
  class BamFile : boost::noncopyable
  {
    typedef Derived derived_type;
  public:
    BamFile(void);

    virtual ~BamFile(void);

    void close(void);

    bool is_open(void) const;
  protected:
    void open_base(const std::string& fn, const std::string& mode,
                   const void* aux);

#ifndef YAT_HAVE_HTSLIB

    typedef samfile_t samFile;
#endif

    samFile* sf_;

    const std::string& filename(void) const { return filename_; }
  private:
    std::string filename_;
  };


  class InBamFile : public BamFile<InBamFile>
  {
    typedef BamFile<InBamFile> super_t;
  public:
#if YAT_HAVE_HTSLIB
    typedef hts_idx_t index_type;
#else
    typedef bam_index_t index_type;
#endif

    InBamFile(void);

    explicit InBamFile(const std::string& fn);

    virtual ~InBamFile(void);

    const BamHeader& header(void) const;

    const index_type* index(void) const;

    uint64_t n_mapped(int tid) const;

    uint64_t n_unmapped(int tid) const;

    uint64_t n_no_coordinate(void) const;

    void open(const std::string& fn);

    bool read(BamRead& read);

#if YAT_HAVE_HTSLIB
    bool read(BamRead& read, hts_itr_t* iter);
#else
    bool read(BamRead& read, bam_iter_t iter);
#endif
  private:
    uint64_t get_idx_stat(int tid, bool return_mapped) const;
    BamHeader header_;
    // always access index_ via function index(), so index is loaded
    // if needed
    mutable index_type* index_;
  };


  class OutBamFile : public BamFile<OutBamFile>
  {
    typedef BamFile<OutBamFile> super_t;
  public:
    OutBamFile(void);

    OutBamFile(const std::string&, const BamHeader& header);

    OutBamFile(const std::string&, const BamHeader& header,
               unsigned int compression);

    void open(const std::string& fn, const BamHeader& hdr);

    void open(const std::string& fn, const BamHeader& hdr,
              unsigned int compression);

    void write(const BamRead& read);

    class error : public utility::IO_error
    {
    public:
      error(const BamRead&);
      // has to be throw() since base class destructor is
      virtual ~error(void) throw();
      const BamRead& read(void) const;
    private:
      BamRead read_;
    }; // end of class error

  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)
  {
#if YAT_HAVE_HTSLIB
    if (sf_==NULL)
      return;
    if (sam_close(sf_))
      throw utility::IO_error("BamFile::close() failed");
#else
    samclose(sf_);
#endif
    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;
    YAT_ASSERT(!sf_);
#if YAT_HAVE_HTSLIB
    YAT_ASSERT(aux==NULL); // aux is ignored in htslib mode
    sf_ = sam_open(fn.c_str(), mode.c_str());
#else
    sf_ = samopen(fn.c_str(), mode.c_str(), aux);
#endif
    if (!sf_) {
      std::ostringstream ss;
      ss << "failed open '" << fn << "'";
      throw utility::runtime_error(ss.str());
    }
  }

}}}
#endif