BamFile.h

#ifndef theplu_yat_omic_bam_file
#define theplu_yat_omic_bam_file

// $Id: BamFile.h 2928 2012-12-25 23:20:10Z 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 "config_bam.h"

#include "yat/utility/Exception.h"

#include YAT_SAM_HEADER

#include <boost/utility.hpp>

#include <cassert>
#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);
    samfile_t* sf_;

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


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

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

    virtual ~InBamFile(void);

    const BamHeader& header(void) const;

    const bam_index_t* index(void) const;

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

    bool read(BamRead& read);

    bool read(BamRead& read, bam_iter_t iter);
  private:
    BamHeader header_;
    mutable bam_index_t* index_;
  };


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

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

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

    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 utility::runtime_error(ss.str());
    }
  }

}}}
#endif