alg/seq_span.hpp

   1 #ifndef SEQ_SPAN_HPP_
   2 #define SEQ_SPAN_HPP_
   3
   4 #include <string>
   5
   6 #include <boost/serialization/base_object.hpp>
   7 #include <boost/serialization/export.hpp>
   8 #include <boost/serialization/list.hpp>
   9 #include <boost/serialization/nvp.hpp>
  10 #include <boost/serialization/string.hpp>
  11 #include <boost/serialization/shared_ptr.hpp>
  12 #include <boost/serialization/utility.hpp>
  13 #include <boost/serialization/version.hpp>
  14 #include <boost/serialization/vector.hpp>
  15
  16 #include <boost/shared_ptr.hpp>
  17 #include <boost/enable_shared_from_this.hpp>
  18
  19 //! These classes provide for the internal implementation for the Sequence class
  20 #include "seq.hpp"
  21
  22 class SeqSpan;
  23 typedef boost::shared_ptr<SeqSpan> SeqSpanRef;
  24
  25 //! Track what segment of a sequence we're looking at
  26 class SeqSpan : public boost::enable_shared_from_this<SeqSpan> {
  27 public:
  28   typedef SeqString::difference_type difference_type;
  29   typedef SeqString::iterator iterator;
  30   typedef SeqString::reverse_iterator reverse_iterator;
  31   typedef SeqString::const_iterator const_iterator;
  32   typedef SeqString::const_reverse_iterator const_reverse_iterator;
  33   typedef SeqString::reference reference;
  34   typedef SeqString::const_reference const_reference;
  35   typedef SeqString::size_type size_type;
  36   typedef SeqString::value_type value_type;
  37   static const size_type npos = SeqString::npos;
  38
  39 public:
  40   SeqSpan(const SeqSpan &);
  41   SeqSpan(const SeqSpan *);
  42   explicit SeqSpan(const std::string &);
  43   SeqSpan(const SeqSpanRef, size_type start=0, size_type count=npos);
  44
  45   //! assignment
  46   SeqSpan& operator=(const SeqSpan&);
  47   //! output
  48   friend std::ostream& operator<<(std::ostream&, const SeqSpan&);
  49   //! equality
  50   friend bool operator==(const SeqSpan&, const SeqSpan&);
  51   friend bool operator!=(const SeqSpan&, const SeqSpan&);
  52
  53   //! \defgroup string_operators
  54   //! @{
  55   //! retrive element at specific position
  56   const_reference at(size_type n) const;
  57   //! retrieve element at specific location
  58   const_reference operator[](SeqSpan::size_type i) const;
  59   //! return c pointer to the sequence data
  60   const char *data() const;
  61   //! forward iterator
  62   const_iterator begin() const;
  63   //! last iterator
  64   const_iterator end() const;
  65   //! is our sequence empty?
  66   bool empty() const;
  67   //! find first
  68   size_type find_first_not_of(const std::string&, size_type index=0) const;
  69   //! how many base pairs are there in our sequence
  70   size_type size() const { return seq_count; }
  71   //! alias for size (used by string)
  72   size_type length() const { return size(); }
  73   //! reverse iterator
  74   const_reverse_iterator rbegin() const;
  75   //! reverse end iterator
  76   const_reverse_iterator rend() const;
  77   //! @}
  78
  79   //! start position relative to root sequence
  80   size_type start() const { return seq_start; }
  81   //! set position relative to root sequence
  82   void setStart(size_type);
  83   //! one past the last position relative to the root sequence
  84   size_type stop() const { return seq_start + seq_count; }
  85   //! set one past the last position relative to the root sequence.
  86   void setStop(size_type);
  87
  88   //! get start position relative to the parent sequence
  89   size_type parentStart() const;
  90   //! set start position relative to parent sequence
  91   void setParentStart(size_type);
  92   //! get stop position relative to the parent sequence
  93   size_type parentStop() const;
  94   //! set stop position relative to parent sequence
  95   void setParentStop(size_type);
  96   size_type parentSize() const { return (parent) ? parent->size() : size(); }
  97
  98
  99   //! return a subsequence, copying over any appropriate annotation
 100   SeqSpanRef subseq(size_type start=0, size_type count = std::string::npos);
 101   //! get sequence
 102   std::string sequence() const;
 103   //! are both sequences derived from the same sequence tree?
 104   static bool isFamily(const SeqSpan& a, const SeqSpan& b);
 105
 106   friend class Sequence;
 107 private:
 108   //! do not statically initialize, only create with new
 109   SeqSpan() {};
 110 protected:
 111   //! keep a reference to the sequence container
 112   SeqStringRef seq;
 113   //! where our start location is in the full sequence
 114   size_type seq_start;
 115   //! how big we ware
 116   size_type seq_count;
 117   // Do I need to track the strand here?
 118
 119   //! keep a reference to who our parent span is
 120   SeqSpanRef parent;
 121
 122   // boost::serialization support
 123   friend class boost::serialization::access;
 124   template<class Archive>
 125   void serialize(Archive& ar, const unsigned int /*version*/) {
 126     ar & BOOST_SERIALIZATION_NVP(seq);
 127     ar & BOOST_SERIALIZATION_NVP(seq_start);
 128     ar & BOOST_SERIALIZATION_NVP(seq_count);
 129     ar & BOOST_SERIALIZATION_NVP(parent);
 130   }
 131 };
 132 #endif /*SEQ_SPAN_HPP_*/