algorithm.h

#ifndef theplu_yat_omic_algorithm
#define theplu_yat_omic_algorithm

// $Id: algorithm.h 3625 2017-03-06 03:09:59Z peter $

/*
  Copyright (C) 2012, 2013, 2014, 2016, 2017 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 <yat/utility/config_public.h>

#ifdef YAT_HAVE_LIBBAM
#include "BamPairIterator.h"
#endif
#include "DnaComplementer.h"

#include <boost/iterator/iterator_concepts.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/concept_check.hpp>

#include <algorithm>
#include <vector>

namespace theplu {
namespace yat {
namespace omic {

#ifdef YAT_HAVE_LIBBAM
  template<class Iterator, class Visitor>
  void bam_pair_analyse(Iterator first, Iterator last, Visitor& visitor);
#endif

  template<typename InputIterator, typename OutputIterator>
  void dna_complement(InputIterator begin, InputIterator end,
                      OutputIterator out);

  template<typename BidirectionalIterator>
  void dna_reverse_complement(BidirectionalIterator begin,
                              BidirectionalIterator end);

  template<typename BidirectionalIterator, typename OutputIterator>
  void dna_reverse_complement_copy(BidirectionalIterator begin,
                                   BidirectionalIterator end,
                                   OutputIterator out);


  // template implementations

#ifdef YAT_HAVE_LIBBAM
  template<class Iterator, class Visitor>
  void bam_pair_analyse(Iterator first, Iterator last, Visitor& visitor)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<Iterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<Iterator>));
    BamPairIterator<Iterator> iter(first, last);
    BamPairIterator<Iterator> end(last, last);
    for (; iter!=end; ++iter)
      visitor((*iter).first(), (*iter).second());
  }
#endif


  template<typename InputIterator, typename OutputIterator>
  void dna_complement(InputIterator begin, InputIterator end,
                      OutputIterator out)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<InputIterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<InputIterator>));

    typedef typename boost::iterator_value<InputIterator>::type value_type;
    BOOST_CONCEPT_ASSERT((boost::Convertible<value_type, char>));

    using namespace boost_concepts;
    BOOST_CONCEPT_ASSERT((WritableIterator<OutputIterator, char>));
    BOOST_CONCEPT_ASSERT((IncrementableIterator<OutputIterator>));
    std::transform(begin, end, out, DnaComplementer());
  }


  template<typename BidirectionalIterator>
  void dna_reverse_complement(BidirectionalIterator begin,
                              BidirectionalIterator end)
  {
    BOOST_CONCEPT_ASSERT((
      boost::Mutable_BidirectionalIterator<BidirectionalIterator>
    ));
    dna_complement(begin, end, begin);
    std::reverse(begin, end);
  }


  template<typename BidirectionalIterator, typename OutputIterator>
  void dna_reverse_complement_copy(BidirectionalIterator begin,
                                   BidirectionalIterator end,
                                   OutputIterator out)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::BidirectionalTraversal<BidirectionalIterator>));

    dna_complement(boost::make_reverse_iterator(end),
                   boost::make_reverse_iterator(begin), out);
  }

}}}
#endif