#define SEQ_SPAN_HPP_
#include <string>
+#include <map>
+#include <list>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
//! These classes provide for the internal implementation for the Sequence class
#include "seq.hpp"
+#include "annotations.hpp"
+#include "drawable.hpp"
class SeqSpan;
typedef boost::shared_ptr<SeqSpan> SeqSpanRef;
+typedef std::list<SeqSpanRef> SeqSpanRefList;
+typedef boost::shared_ptr<SeqSpanRefList> SeqSpanRefListRef;
//! Track what segment of a sequence we're looking at
class SeqSpan : public boost::enable_shared_from_this<SeqSpan> {
typedef SeqString::size_type size_type;
typedef SeqString::value_type value_type;
static const size_type npos = SeqString::npos;
+ //! Define strand types
+ /**!
+ * Unknown strand is treated as "either" strand
+ * Plus refers to the initially created strand
+ * Minus is the opposite strand
+ * Both is for any feature that applies to "both" strands
+ * (which may not actually be useful)
+ * Same strand is only used when creating a subsequence
+ * and implies the subsequence has the same orientation as the parent
+ * Opposite is only used for creating a subsequence
+ * and implies the subsequence has the opposite orientation as the parent
+ * Single indicates that this is single stranded and there can't be
+ * an opposite strand.
+ */
+ enum strand_type { UnknownStrand, MinusStrand, PlusStrand,
+ BothStrand, SameStrand, OppositeStrand, SingleStrand };
-public:
SeqSpan(const SeqSpan &);
SeqSpan(const SeqSpan *);
explicit SeqSpan(const std::string &,
- AlphabetRef = reduced_nucleic_alphabet
+ AlphabetRef a = dna_alphabet,
+ strand_type strand=PlusStrand
);
- SeqSpan(const SeqSpanRef, size_type start=0, size_type count=npos);
+ SeqSpan(const SeqSpanRef,
+ size_type start=0,
+ size_type count=npos,
+ strand_type strand=SameStrand);
//! assignment
SeqSpan& operator=(const SeqSpan&);
size_type stop() const { return seq_start + seq_count; }
//! set one past the last position relative to the root sequence.
void setStop(size_type);
+ strand_type strand() const { return seq_strand; }
//! get start position relative to the parent sequence
size_type parentStart() const;
size_type parentStop() const;
//! set stop position relative to parent sequence
void setParentStop(size_type);
- size_type parentSize() const { return (parent) ? parent->size() : size(); }
+ size_type parentSize() const { return (parent_seq) ? parent_seq->size() : size(); }
+ SeqSpanRef parent() { return parent_seq; }
//! return a subsequence, copying over any appropriate annotation
- SeqSpanRef subseq(size_type start=0, size_type count = std::string::npos);
+ SeqSpanRef subseq(size_type start=0,
+ size_type count = std::string::npos,
+ strand_type = PlusStrand);
//! get sequence
std::string sequence() const;
//! are both sequences derived from the same sequence tree?
static bool isFamily(const SeqSpan& a, const SeqSpan& b);
+
+ //! access annotations dictionary
+ AnnotationsRef annotations() const { return seq_annotations; }
+ //! set annotations dictionary
+ void setAnnotations(AnnotationsRef a) { seq_annotations = a; }
+ //! get data for drawing
+ DrawableRef drawable() const { return seq_drawable; }
+ //! store drawing data
+ void setDrawable(DrawableRef d) { seq_drawable = d; }
- friend class Sequence;
private:
//! do not statically initialize, only create with new
SeqSpan() {};
size_type seq_start;
//! how big we ware
size_type seq_count;
- // Do I need to track the strand here?
+ //! strand orientation
+ strand_type seq_strand;
//! keep a reference to who our parent span is
- SeqSpanRef parent;
-
+ SeqSpanRef parent_seq;
+
+ //! hold a reverse complement version of our sequence if needed
+ SeqStringRef rc_seq;
+ //! fill in our rc_seq variable
+ void initialize_rc_seq() const;
+
+ //! annotations provides a python-dictionary like place for metadata
+ AnnotationsRef seq_annotations;
+ //! store information needed for drawing
+ DrawableRef seq_drawable;
+
+ friend class Sequence;
// boost::serialization support
friend class boost::serialization::access;
template<class Archive>
ar & BOOST_SERIALIZATION_NVP(seq);
ar & BOOST_SERIALIZATION_NVP(seq_start);
ar & BOOST_SERIALIZATION_NVP(seq_count);
- ar & BOOST_SERIALIZATION_NVP(parent);
+ ar & BOOST_SERIALIZATION_NVP(seq_strand);
+ ar & BOOST_SERIALIZATION_NVP(parent_seq);
}
};
#endif /*SEQ_SPAN_HPP_*/