BamReadIterator.h

#ifndef theplu_yat_omic_bam_read_iterator
#define theplu_yat_omic_bam_read_iterator

// $Id: BamReadIterator.h 3360 2014-11-24 01:22:23Z peter $

/*
  Copyright (C) 2012, 2013, 2014 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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:
#if YAT_HAVE_HTSLIB
      boost::shared_ptr<hts_itr_t> iter_;
#else
      boost::shared_ptr<__bam_iter_t> iter_;
#endif
    };

    boost::shared_ptr<Actor> actor_;

    struct IndexDestroyer
    {
#if YAT_HAVE_HTSLIB
      void operator()(hts_itr_t* i) const
      {
        bam_itr_destroy(i);
      }
#else
      void operator()(bam_iter_t i) const
      {
        bam_iter_destroy(i);
      }
#endif
    };
  };
}}}
#endif