source: trunk/yat/omic/BamReadIterator.h @ 2986

#ifndef theplu_yat_omic_bam_read_iterator
#define theplu_yat_omic_bam_read_iterator

// $Id: BamReadIterator.h 2986 2013-02-18 08:07:44Z 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 "BamFile.h"
#include "BamRead.h"
#include "config_bam.h"

#include YAT_SAM_HEADER

#include <boost/iterator/iterator_facade.hpp>
#include <boost/shared_ptr.hpp>

#include <iterator>

namespace theplu {
namespace yat {
namespace omic {

  // forward declaration
  class InBamFile;

  /**
     \brief class to iterate through a InBamFile

     Iterator is a single pass \input_iterator which means iterator
     can only be used read bam file. If creating two iterators working
     on the same InBamFile, the iterators are not independent of each
     other. Incrementing one, the behaviour of the other is undefined.

     Iterator can either be constructed to iterate over entire bam
     file or if a region is specified only over that region. When no
     more elements are available, iterator turns into a end-of-file
     iterator and is no longer dereferencable.

     \see InBamFile

     \since New in yat 0.10
   */
  class BamReadIterator
    : public boost::iterator_facade<
    BamReadIterator, const BamRead, std::input_iterator_tag
    >
  {
  public:
    /**
       \brief Contructs end of file iterator.
     */
    BamReadIterator(void);

    /**
       Creates an iterator pointing to first BamRead in
       InBamFile.

       \param in file to iterate over
     */
    explicit BamReadIterator(InBamFile& in);

    /**
       Iterator that walks over specified region. Iterator iterates
       over all BamReads in file \a in that overlap with specified
       region and then it turns into an end-of-region iterator.

       This function requires an index file is available, see
       InBamFile::index().

       All reads iterated over overlap with defined region, in other
       words, iter->tid == \a tid; iter->pos() < \a end and iter->end()
       > start

       \param in file to iterate over
       \param tid segment (chromosome) to iterate over
       \param start left most position of specified region
       \param end right most position of specified region
     */
    BamReadIterator(InBamFile& in, int32_t tid, int32_t start, int32_t end);
  private:
    friend class boost::iterator_core_access;
    BamReadIterator::reference dereference(void) const;
    bool equal(const BamReadIterator& other) const;
    void increment(void);

    /*
       Interface class for the actor that handles difference between
       an iterator that iterates the entire file and one that uses
       index to iterate over a specific region.
     */
    class Actor
    {
    public:
      explicit Actor(InBamFile*);
      virtual ~Actor(void);
      virtual void increment(void)=0;
      InBamFile* in_;
      BamRead read_;
    };

    // class used when region is entire file
    class AllActor : public Actor
    {
    public:
      AllActor(void);
      explicit AllActor(InBamFile&);
      void increment(void);
    };

    // class used when iterating over a sub-region of the bam file
    class IndexActor : public Actor
    {
    public:
      IndexActor(InBamFile& bf, int32_t tid, int32_t begin, int32_t end);
      void increment(void);
    private:
      boost::shared_ptr<__bam_iter_t> iter_;
    };

    boost::shared_ptr<Actor> actor_;

    struct IndexDestroyer
    {
      void operator()(bam_iter_t i) const
      {
        bam_iter_destroy(i);
      }
    };
  };
}}}
#endif