BamReadIterator.h

#ifndef theplu_yat_omic_bam_read_iterator
#define theplu_yat_omic_bam_read_iterator

// $Id: BamReadIterator.h 3014 2013-04-04 02:43:32Z peter $
//
// Copyright (C) 2012, 2013 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;

  class BamReadIterator
    : public boost::iterator_facade<
    BamReadIterator, const BamRead, std::input_iterator_tag
    >
  {
  public:
    BamReadIterator(void);

    explicit BamReadIterator(InBamFile& in);

    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