source: trunk/yat/omic/BamFile.cc @ 2895

// $Id: BamFile.cc 2895 2012-12-10 21:38:12Z 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 <config.h>

#include "BamFile.h"
#include "BamHeader.h"

#include <bam.h>

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

namespace theplu {
namespace yat {
namespace omic {

  InBamFile::InBamFile(void)
    : super_t(), index_(NULL)
  {}


  InBamFile::InBamFile(const std::string& fn)
    : super_t(), index_(NULL)
  {
    open(fn);
  }


  InBamFile::~InBamFile(void)
  {
    bam_index_destroy(index_);
  }


  const BamHeader& InBamFile::header(void) const
  {
    return header_;
  }


  const bam_index_t* InBamFile::index(void) const
  {
    if (!index_) {
      index_ = bam_index_load(filename().c_str());
      if (!index_) {
        std::ostringstream ss;
        ss << "cannot load bam index '" << filename() << ".bai'";
        throw std::runtime_error(ss.str());
      }
    }
    return index_;
  }


  void InBamFile::open(const std::string& fn)
  {
    open_base(fn, "rb", NULL);
    header_.header_ = sf_->header;
    assert(header_.header_);
  }


  bool InBamFile::read(BamRead& read)
  {
    int result_ = samread(sf_, read.bam_);
    if (result_<-1) {
      std::ostringstream ss;
      ss << "read(1): invalid bam file '" << filename() << "'";
      if (result_ == -2)
        ss << " truncated file";
      else
        ss << " error: " << result_;
      throw std::runtime_error(ss.str());
    }
    return result_>=0;
  }


  bool InBamFile::read(BamRead& read, bam_iter_t iter)
  {
    assert(sf_->type & 1); // no random access from sam files
    int result_ = bam_iter_read(sf_->x.bam, iter, read.bam_);
    if (result_<-1) {
      std::ostringstream ss;
      ss << "read(2): invalid bam file '" << filename() << "'";
      if (result_ == -2)
        ss << " truncated file";
      else
        ss << " error: " << result_;
      throw std::runtime_error(ss.str());
    }
    return result_>=0;
  }


  OutBamFile::OutBamFile(void)
    : super_t() {}


  OutBamFile::OutBamFile(const std::string& fn, const BamHeader& header)
  {
    open(fn, header);
  }


  void OutBamFile::open(const std::string& fn, const BamHeader& h)
  {
    open_base(fn, "wb", h.header_);
  }


  void OutBamFile::write(const BamRead& read)
  {
    samwrite(sf_, read.bam_);
  }

}}}