dna_iterator.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_GENOME_DNA_ITERATOR_HPP__
#define SHORE_GENOME_DNA_ITERATOR_HPP__

#include <boost/iterator/iterator_facade.hpp>

#include "shore/container/intpack.hpp"
#include "shore/datatype/nucleotide.hpp"

namespace shore {

template<typename Iter,
         typename Converted,
         typename ConversionFunc=Converted (*)(const typename std::iterator_traits<Iter>::value_type)>
class conversion_proxy
:public boost::iterator_facade<conversion_proxy<Iter,Converted,ConversionFunc>,
                               const Converted,
                               boost::random_access_traversal_tag,
                               const Converted>
{
 public:

        typedef Iter iterator_type;
        typedef Converted converted_type;
        typedef ConversionFunc conversion_func_type;

 private:

        friend class boost::iterator_core_access;

        typedef conversion_proxy<iterator_type,converted_type,conversion_func_type> this_type;

        iterator_type m_iter;
        conversion_func_type m_conv;

        void increment()
        {
                ++m_iter;
        }

        void decrement()
        {
                --m_iter;
        }

        void advance(ptrdiff_t n)
        {
                m_iter+=n;
        }

        ptrdiff_t distance_to(const this_type &other) const
        {
                return other.m_iter-m_iter;
        }

        bool equal(const this_type &other) const
        {
                return other.m_iter==m_iter;
        }

        converted_type dereference() const
        {
                return m_conv(*m_iter);
        }

 public:

        conversion_proxy(conversion_func_type fun=conversion_func_type())
        :m_conv(fun)
        {}

        conversion_proxy(iterator_type iter,conversion_func_type fun=conversion_func_type())
        :m_iter(iter),m_conv(fun)
        {}

        iterator_type base() const
        {
                return m_iter;
        }
};


struct conv_base_compl
{
        shore::nuc::base operator()(const shore::nuc::base b) const;
};

struct conv_packed_compl
{
        shore::nuc::packed_base operator()(const shore::nuc::packed_base b) const;
};

struct conv_char_compl
{
        char operator()(const char c) const;
};

struct conv_int2base
{
        shore::nuc::base operator()(const uint64_t c) const;
};

struct conv_int2base_compl
{
        shore::nuc::base operator()(const uint64_t c) const;
};

struct conv_int2packed
{
        shore::nuc::packed_base operator()(const uint64_t c) const;
};

struct conv_int2packed_compl
{
        shore::nuc::packed_base operator()(const uint64_t c) const;
};

struct conv_int2char
{
        char operator()(const uint64_t c) const;
};

struct conv_int2char_compl
{
        char operator()(const uint64_t c) const;
};

struct conv_char2base
{
        shore::nuc::base operator()(const char c) const;
};

struct conv_char2base_compl
{
        shore::nuc::base operator()(const char c) const;
};

struct conv_char2packed
{
        shore::nuc::packed_base operator()(const char c) const;
};

struct conv_char2packed_compl
{
        shore::nuc::packed_base operator()(const char c) const;
};

struct conv_base2char
{
        char operator()(const shore::nuc::base b) const;
};

struct conv_base2char_compl
{
        char operator()(const shore::nuc::base b) const;
};

struct conv_base2packed
{
        shore::nuc::packed_base operator()(const shore::nuc::base b) const;
};

struct conv_base2packed_compl
{
        shore::nuc::packed_base operator()(const shore::nuc::base b) const;
};

struct conv_packed2char
{
        char operator()(const shore::nuc::packed_base b) const;
};

struct conv_packed2char_compl
{
        char operator()(const shore::nuc::packed_base b) const;
};

struct conv_packed2base
{
        shore::nuc::base operator()(const shore::nuc::packed_base b) const;
};

struct conv_packed2base_compl
{
        shore::nuc::base operator()(const shore::nuc::packed_base b) const;
};


template<typename Iter>
class base_compl_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_base_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_base_compl> proxy_type;

        base_compl_iterator() {}

        base_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class packed_compl_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_packed_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_packed_compl> proxy_type;

        packed_compl_iterator() {}

        packed_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class char_compl_iterator
:public conversion_proxy<Iter,char,conv_char_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_char_compl> proxy_type;

        char_compl_iterator() {}

        char_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};


template<typename Iter>
class int2base_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_int2base>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_int2base> proxy_type;

        int2base_iterator() {}

        int2base_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class int2packed_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_int2packed>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_int2packed> proxy_type;

        int2packed_iterator() {}

        int2packed_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class int2char_iterator
:public conversion_proxy<Iter,char,conv_int2char>
{
 public:

        typedef conversion_proxy<Iter,char,conv_int2char> proxy_type;

        int2char_iterator() {}

        int2char_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class int2base_compl_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_int2base_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_int2base_compl> proxy_type;

        int2base_compl_iterator() {}

        int2base_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class int2packed_compl_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_int2packed_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_int2packed_compl> proxy_type;

        int2packed_compl_iterator() {}

        int2packed_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class int2char_compl_iterator
:public conversion_proxy<Iter,char,conv_int2char_compl>
{
 public:

        typedef conversion_proxy<Iter,char,conv_int2char_compl> proxy_type;

        int2char_compl_iterator() {}

        int2char_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};


template<typename Iter>
class base2packed_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_base2packed>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_base2packed> proxy_type;

        base2packed_iterator() {}

        base2packed_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class base2char_iterator
:public conversion_proxy<Iter,char,conv_base2char>
{
 public:

        typedef conversion_proxy<Iter,char,conv_base2char> proxy_type;

        base2char_iterator() {}

        base2char_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class base2packed_compl_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_base2packed_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_base2packed_compl> proxy_type;

        base2packed_compl_iterator() {}

        base2packed_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class base2char_compl_iterator
:public conversion_proxy<Iter,char,conv_base2char_compl>
{
 public:

        typedef conversion_proxy<Iter,char,conv_base2char_compl> proxy_type;

        base2char_compl_iterator() {}

        base2char_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};


template<typename Iter>
class packed2base_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_packed2base>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_packed2base> proxy_type;

        packed2base_iterator() {}

        packed2base_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class packed2char_iterator
:public conversion_proxy<Iter,char,conv_packed2char>
{
 public:

        typedef conversion_proxy<Iter,char,conv_packed2char> proxy_type;

        packed2char_iterator() {}

        packed2char_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class packed2base_compl_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_packed2base_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_packed2base_compl> proxy_type;

        packed2base_compl_iterator() {}

        packed2base_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class packed2char_compl_iterator
:public conversion_proxy<Iter,char,conv_packed2char_compl>
{
 public:

        typedef conversion_proxy<Iter,char,conv_packed2char_compl> proxy_type;

        packed2char_compl_iterator() {}

        packed2char_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};


template<typename Iter>
class char2base_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_char2base>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_char2base> proxy_type;

        char2base_iterator() {}

        char2base_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class char2packed_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_char2packed>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_char2packed> proxy_type;

        char2packed_iterator() {}

        char2packed_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class char2base_compl_iterator
:public conversion_proxy<Iter,shore::nuc::base,conv_char2base_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::base,conv_char2base_compl> proxy_type;

        char2base_compl_iterator() {}

        char2base_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};

template<typename Iter>
class char2packed_compl_iterator
:public conversion_proxy<Iter,shore::nuc::packed_base,conv_char2packed_compl>
{
 public:

        typedef conversion_proxy<Iter,shore::nuc::packed_base,conv_char2packed_compl> proxy_type;

        char2packed_compl_iterator() {}

        char2packed_compl_iterator(const Iter it)
        :proxy_type(it)
        {}
};


class dna_iterator
:public boost::iterator_facade<
dna_iterator,const shore::nuc::base,boost::random_access_traversal_tag,const shore::nuc::base>
{
 private:

        friend class boost::iterator_core_access;

        const char* m_pt;
        shore::intpack::const_iterator m_it;
        bool m_complement;


        void increment()
        {
                if(m_pt!=0)
                        ++m_pt;
                else
                        ++m_it;
        }

        void decrement()
        {
                if(m_pt!=0)
                        --m_pt;
                else
                        --m_it;
        }

        void advance(difference_type n)
        {
                if(m_pt!=0)
                        m_pt+=n;
                else
                        m_it+=n;
        }

        difference_type distance_to(const dna_iterator& other) const
        {
                if(m_pt!=0)
                        return other.m_pt-m_pt;
                return other.m_it-m_it;
        }

        bool equal(const dna_iterator& other) const
        {
                if(m_pt!=0)
                        return m_pt==other.m_pt;
                return m_it==other.m_it;
        }

        reference dereference() const
        {
                if(m_complement)
                {
                        if(m_pt!=0)
                                return shore::nuc::comp(shore::nuc::dec(*m_pt));
                        return shore::nuc::comp(shore::nuc::unpack(static_cast<shore::nuc::packed_base>(
                                static_cast<shore::intpack::int_type>(*m_it))));
                }
                if(m_pt!=0)
                        return shore::nuc::dec(*m_pt);
                return shore::nuc::unpack(static_cast<shore::nuc::packed_base>(
                        static_cast<shore::intpack::int_type>(*m_it)));
        }

 public:

        dna_iterator()
        :m_pt(0),m_complement(false)
        {}

        dna_iterator(const char*const pt)
        :m_pt(pt),m_complement(false)
        {}

        dna_iterator(const shore::intpack::const_iterator& it)
        :m_pt(0),m_it(it),m_complement(false)
        {}

        void set_complement(const bool comp)
        {
                m_complement=comp;
        }

        static dna_iterator begin(const std::string& s)
        {
                return dna_iterator(s.data());
        }

        static dna_iterator end(const std::string& s)
        {
                return dna_iterator(s.data()+s.size());
        }
};

class packeddna_iterator
:public boost::iterator_facade<
packeddna_iterator,const shore::nuc::packed_base,boost::random_access_traversal_tag,const shore::nuc::packed_base>
{
 private:

        friend class boost::iterator_core_access;

        const char* m_pt;
        shore::intpack::const_iterator m_it;
        bool m_complement;


        void increment()
        {
                if(m_pt!=0)
                        ++m_pt;
                else
                        ++m_it;
        }

        void decrement()
        {
                if(m_pt!=0)
                        --m_pt;
                else
                        --m_it;
        }

        void advance(difference_type n)
        {
                if(m_pt!=0)
                        m_pt+=n;
                else
                        m_it+=n;
        }

        difference_type distance_to(const packeddna_iterator& other) const
        {
                if(m_pt!=0)
                        return other.m_pt-m_pt;
                return other.m_it-m_it;
        }

        bool equal(const packeddna_iterator& other) const
        {
                if(m_pt!=0)
                        return m_pt==other.m_pt;
                return m_it==other.m_it;
        }

        reference dereference() const
        {
                if(m_complement)
                {
                        if(m_pt!=0)
                                return shore::nuc::pack(shore::nuc::comp(shore::nuc::dec(*m_pt)));
                        return shore::nuc::pack(shore::nuc::comp(shore::nuc::unpack(
                                static_cast<shore::nuc::packed_base>(
                                        static_cast<shore::intpack::int_type>(*m_it)))));
                }
                if(m_pt!=0)
                        return shore::nuc::pack(shore::nuc::dec(*m_pt));
                return static_cast<shore::nuc::packed_base>(
                        static_cast<shore::intpack::int_type>(*m_it));
        }

 public:

        packeddna_iterator()
        :m_pt(0),m_complement(false)
        {}

        packeddna_iterator(const char*const pt)
        :m_pt(pt),m_complement(false)
        {}

        packeddna_iterator(const shore::intpack::const_iterator& it)
        :m_pt(0),m_it(it),m_complement(false)
        {}

        void set_complement(const bool comp)
        {
                m_complement=comp;
        }

        static packeddna_iterator begin(const std::string& s)
        {
                return packeddna_iterator(s.data());
        }

        static packeddna_iterator end(const std::string& s)
        {
                return packeddna_iterator(s.data()+s.size());
        }
};

class chardna_iterator
:public boost::iterator_facade<
chardna_iterator,const char,boost::random_access_traversal_tag,const char>
{
 private:

        friend class boost::iterator_core_access;

        const char* m_pt;
        shore::intpack::const_iterator m_it;
        bool m_complement;


        void increment()
        {
                if(m_pt!=0)
                        ++m_pt;
                else
                        ++m_it;
        }

        void decrement()
        {
                if(m_pt!=0)
                        --m_pt;
                else
                        --m_it;
        }

        void advance(difference_type n)
        {
                if(m_pt!=0)
                        m_pt+=n;
                else
                        m_it+=n;
        }

        difference_type distance_to(const chardna_iterator& other) const
        {
                if(m_pt!=0)
                        return other.m_pt-m_pt;
                return other.m_it-m_it;
        }

        bool equal(const chardna_iterator& other) const
        {
                if(m_pt!=0)
                        return m_pt==other.m_pt;
                return m_it==other.m_it;
        }

        reference dereference() const
        {
                if(m_complement)
                {
                        if(m_pt!=0)
                                return shore::nuc::enc(shore::nuc::comp(shore::nuc::dec(*m_pt)));
                        return shore::nuc::enc(shore::nuc::comp(shore::nuc::unpack(
                                static_cast<shore::nuc::packed_base>(
                                        static_cast<shore::intpack::int_type>(*m_it)))));
                }
                if(m_pt!=0)
                        return *m_pt;
                return shore::nuc::enc(shore::nuc::unpack(
                        static_cast<shore::nuc::packed_base>(
                                static_cast<shore::intpack::int_type>(*m_it))));
        }

 public:

        chardna_iterator()
        :m_pt(0),m_complement(false)
        {}

        chardna_iterator(const char*const pt)
        :m_pt(pt),m_complement(false)
        {}

        chardna_iterator(const shore::intpack::const_iterator& it)
        :m_pt(0),m_it(it),m_complement(false)
        {}

        void set_complement(const bool comp)
        {
                m_complement=comp;
        }
};

} // namespace

#endif // SHORE_GENOME_DNA_ITERATOR_HPP__