BamFile.h

#ifndef theplu_yat_omic_bam_file
#define theplu_yat_omic_bam_file

// $Id: BamFile.h 3999 2020-10-08 23:22:32Z peter $

/*
  Copyright (C) 2012, 2013, 2014, 2016, 2017, 2018, 2020 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

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

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

#include <htslib/sam.h>

#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 have_index(void) const;

    bool is_open(void) const;
  protected:
    void build_index_base(void) const;

    void open_base(const std::string& fn, const std::string& mode,
                   const void* aux) YAT_DEPRECATE;

    void open_base(const std::string& fn, const std::string& mode);

    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:
    typedef hts_idx_t index_type;

    InBamFile(void);

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

    virtual ~InBamFile(void);

    void build_index(void) const;

    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);

    bool read(BamRead& read, hts_itr_t* iter);
  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 build_index(void) const;

    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:
    void open(const std::string& fn, const std::string& mode,
              const BamHeader& h);

  };


  // 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>::build_index_base(void) const
  {
    int res = bam_index_build(filename_.c_str(), 0);
    if (res) {
      std::ostringstream msg;
      msg << "failed building index file '" << filename_ << ".bai': ";
      if (res == -1)
        msg << "failed to build index";
      else if (res == -2)
        msg << "failed to open file '" << filename_ << "'";
      else if (res == -4)
        msg << "failed to save file";
      throw utility::runtime_error(msg.str());
    }
  }


  template<class Derived>
  void BamFile<Derived>::close(void)
  {
    if (sf_==NULL)
      return;
    if (sam_close(sf_))
      throw utility::IO_error("BamFile::close() failed");
    sf_ = NULL;
  }


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


  template<class Derived>
  bool BamFile<Derived>::have_index(void) const
  {
    return utility::FileUtil(filename() + ".bai").exists();
  }


  template<class Derived>
  void BamFile<Derived>::open_base(const std::string& fn,
                                   const std::string& mode,
                                   const void* aux)
  {
    YAT_ASSERT(aux==NULL); // aux is ignored in htslib mode
    open_base(fn, mode);
  }


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

}}}
#endif