CigarIterator.h

#ifndef theplu_yat_utility_cigar_iterator
#define theplu_yat_utility_cigar_iterator

// $Id: CigarIterator.h 3385 2015-03-13 07:55:49Z peter $

/*
  Copyright (C) 2014, 2015 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 "Cigar.h"

#include <boost/concept_check.hpp>
#include <boost/cstdint.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_concepts.hpp>

#include <cstddef> // for size_t

namespace theplu {
namespace yat {
namespace utility {

  template<typename BASE>
  class CigarIterator
    : public boost::iterator_facade<
    CigarIterator<BASE>, uint8_t
    , boost::bidirectional_traversal_tag, const uint8_t>
  {
  public:
    CigarIterator(void);

    explicit CigarIterator(BASE p, size_t offset=0);

    BASE base(void) const;
  private:
    friend class boost::iterator_core_access;

    BASE base_;
    size_t index_;

    void decrement(void);
    uint8_t dereference(void) const;
    bool equal(const CigarIterator& other) const;
    void increment(void);

    // using compiler generated copy
    //CigarIterator(const CigarIterator& other);
    //CigarIterator& operator=(const CigarIterator&);
  };



  template<typename BASE>
  CigarIterator<BASE>::CigarIterator(void)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<BASE>));
    BOOST_CONCEPT_ASSERT((boost_concepts::BidirectionalTraversal<BASE>));
  }


  template<typename BASE>
  CigarIterator<BASE>::CigarIterator(BASE b, size_t x)
    : base_(b), index_(x)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<BASE>));
    BOOST_CONCEPT_ASSERT((boost_concepts::BidirectionalTraversal<BASE>));
  }


  template<typename BASE>
  BASE CigarIterator<BASE>::base(void) const
  {
    return base_;
  }


  template<typename BASE>
  void CigarIterator<BASE>::decrement(void)
  {
    if (index_)
      --index_;
    else {
      --base_;
      index_ = bam_cigar_oplen(*base_)-1;
    }
  }


  template<typename BASE>
  uint8_t CigarIterator<BASE>::dereference(void) const
  {
    return bam_cigar_op(*base_);
  }


  template<typename BASE>
  bool CigarIterator<BASE>::equal(const CigarIterator& other) const
  {
    return base_==other.base_ && index_==other.index_;
  }


  template<typename BASE>
  void CigarIterator<BASE>::increment(void)
  {
    if (++index_ == bam_cigar_oplen(*base_)) {
      index_=0;
      ++base_;
    }
  }

}}}
#endif