BamReadIterator.h

#ifndef theplu_yat_omic_bam_read_iterator
#define theplu_yat_omic_bam_read_iterator

// $Id: BamReadIterator.h 4274 2023-01-24 15:27:25Z peter $

/*
  Copyright (C) 2012, 2013, 2014, 2017, 2018, 2020 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "BamFile.h"
#include "BamRead.h"

#include <htslib/sam.h>

#include <boost/iterator/iterator_facade.hpp>

#include <iterator>
#include <memory>
#include <vector>

namespace theplu {
namespace yat {
namespace omic {

  // forward declaration
  class BamRegion;
  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);

    BamReadIterator(InBamFile& in, int32_t tid, int32_t start=0);

    BamReadIterator(InBamFile& in, const BamRegion& region);

    BamReadIterator(InBamFile& in, const std::vector<BamRegion>& regions);
  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);
    };

    // functor calling bam_itr_destroy
    struct IndexDestroyer
    {
      void operator()(hts_itr_t* i) const;
    };

    class RegListDestroyer
    {
    public:
      RegListDestroyer(size_t n);
      void operator()(hts_reglist_t* r) const;
    private:
      size_t n_;
    };

    // class used when iterating over a sub-region of the bam file
    class IndexActor : public Actor
    {
    public:
      IndexActor(InBamFile& in,
                 std::unique_ptr<hts_itr_t, IndexDestroyer>&& iter);
      void increment(void);
    private:
      std::unique_ptr<hts_itr_t, IndexDestroyer> iter_;
    };

    std::shared_ptr<Actor> actor_;

  };
}}}
#endif