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

// $Id: BamReadIterator.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 "BamReadIterator.h"

#include "BamFile.h"

#include <cstddef>

namespace theplu {
namespace yat {
namespace omic {

  BamReadIterator::BamReadIterator(void)
  {
    actor_ = boost::shared_ptr<Actor>(new AllActor);
  }


  BamReadIterator::BamReadIterator(InBamFile& in)
  {
    actor_ = boost::shared_ptr<Actor>(new AllActor(in));
    increment();
  }


  BamReadIterator::BamReadIterator(InBamFile& bf, int32_t tid, int32_t start,
                                   int32_t end)
  {
    actor_ = boost::shared_ptr<Actor>(new IndexActor(bf, tid, start, end));
    assert(actor_);
    increment();
  }


  BamReadIterator::reference BamReadIterator::dereference(void) const
  {
    return actor_->read_;
  }


  bool BamReadIterator::equal(const BamReadIterator& other) const
  {
    return actor_->in_ == other.actor_->in_;
  }


  void BamReadIterator::increment(void)
  {
    actor_->increment();
  }


  ///// Actors //////

  BamReadIterator::Actor::Actor(InBamFile* bf)
    : in_(bf) {}


  BamReadIterator::Actor::~Actor(void)
  {}


  BamReadIterator::AllActor::AllActor(void)
    : Actor(NULL) {}


  BamReadIterator::AllActor::AllActor(InBamFile& bf)
    : Actor(&bf) {}


  void BamReadIterator::AllActor::increment(void)
  {
    if (!in_)
      return;
    try {
      if (!in_->read(read_))
        in_ = NULL;
    }
    catch (std::runtime_error& e) {
      in_ = NULL;
      throw e;
    }
  }


  BamReadIterator::IndexActor::IndexActor(InBamFile& bf, int32_t tid,
                                          int32_t begin,int32_t end)
    : Actor(&bf)
  {
    bam_iter_t it = bam_iter_query(bf.index(), tid, begin, end);
    assert(it);
    // iter_ takes ownership
    iter_ = boost::shared_ptr<__bam_iter_t>(it, IndexDestroyer());
    assert(iter_.get());
  }


  void BamReadIterator::IndexActor::increment(void)
  {
    if (!in_)
      return;
    assert(iter_.get());
    try {
      if (! in_->read(read_, iter_.get()))
        in_ = NULL;
    }
    catch (std::runtime_error& e) {
      in_ = NULL;
      throw e;
    }
  }

}}}