source: trunk/yat/utility/CigarIterator.h @ 3372

#ifndef theplu_yat_utility_cigar_iterator
#define theplu_yat_utility_cigar_iterator

// $Id: CigarIterator.h 3372 2015-02-11 01:31:03Z peter $

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

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

#include <cstddef> // for size_t

namespace theplu {
namespace yat {
namespace utility {

  /**
     \brief Iterator over a CIGAR

     A CIGAR string is typically represented as a compact array, i.e.,
     an array \c MMMMMMDDMMMM is represented as \c 6M2D4M. This class
     is a proxy that allows iterating over a CIGAR as though the array
     was \c MMMMMMDDMMMM.

     CigarIterator is a \readable_iterator (not mutable) and
     models a \bidirectional_traversal_iterator. Its value_type is \c
     uint8_t. Since no \c uint8_t is stored in CIGAR, the dereference
     operator calculates the CIGAR element to return and returns by
     value. CigarIterator is therefore an \input_iterator.

     \since New in yat 0.13
   */
  template<typename BASE>
  class CigarIterator
    : public boost::iterator_facade<
    CigarIterator<BASE>, uint8_t
    , boost::bidirectional_traversal_tag, const uint8_t>
  {
  public:
    /**
       \brief Default constructor
     */
    CigarIterator(void);

    /**
       Construct an iterator that points to element offset in \a p. If
       \a p corresponds to \c 5M and offset is 2, the iterator points to
       the third \c M.
     */
    explicit CigarIterator(BASE p, size_t offset=0);

    /**
       \return underlying iterator
     */
    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&);
  };


  //// implementation  /////////////

  template<typename BASE>
  CigarIterator<BASE>::CigarIterator(void) {}


  template<typename BASE>
  CigarIterator<BASE>::CigarIterator(BASE b, size_t x)
    : base_(b), index_(x) {}


  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