5 #include "seq_span.hpp"
6 #include "mussa_exceptions.hpp"
8 SeqSpan::SeqSpan(const SeqSpan &o)
10 seq_start(o.seq_start),
11 seq_count(o.seq_count),
16 SeqSpan::SeqSpan(const SeqSpan *p)
18 seq_start(p->seq_start),
19 seq_count(p->seq_count),
24 SeqSpan::SeqSpan(const std::string &seq_,
26 : seq(new SeqString(seq_, a)),
28 seq_count(seq_.length()),
33 SeqSpan::SeqSpan(const SeqSpanRef parent_, size_type start_, size_type count_)
35 seq_start(parent_->seq_start + start_),
39 seq_count = parent_->seq_count;
46 SeqSpan &SeqSpan::operator=(const SeqSpan& s)
50 seq_start = s.seq_start;
51 seq_count = s.seq_count;
57 std::ostream& operator<<(std::ostream& out, const SeqSpan& s)
62 /* Not implemented yet
64 //! \throws sequence_invalid_comparison
65 friend bool operator<(const SeqSpan&, const SeqSpan&);
66 bool operator<(const SeqSpan& a, const SeqSpan& b)
68 // are we subcomponents of the same sequence region?
69 if (a.seq.get() == b.seq.get()) {
70 if (a.seq_start < b.seq_start)
75 throw mussa_error("can only compare two spans from the same sequence");
80 bool operator==(const SeqSpan& a, const SeqSpan& b)
82 if (SeqSpan::isFamily(a, b)) {
83 // can do fast comparison
84 if (a.seq_start == b.seq_start and a.seq_count == b.seq_count) {
93 bool operator!=(const SeqSpan& a, const SeqSpan& b)
98 SeqSpan::const_reference SeqSpan::operator[](SeqSpan::size_type i) const
103 SeqSpan::const_reference SeqSpan::at(SeqSpan::size_type i) const
105 if (!seq) throw std::out_of_range("empty sequence");
106 return seq->at(i+seq_start);
109 const char *SeqSpan::data() const
112 return seq->c_str()+seq_start;
117 SeqSpan::const_iterator SeqSpan::begin() const
119 if (seq and seq_count != 0)
120 return seq->begin()+seq_start;
122 return SeqSpan::const_iterator(0);
125 SeqSpan::const_iterator SeqSpan::end() const
127 if (seq and seq_count != 0) {
128 return seq->begin() + seq_start + seq_count;
130 return SeqSpan::const_iterator(0);
134 SeqSpan::const_reverse_iterator SeqSpan::rbegin() const
136 if (seq and seq_count != 0)
137 return seq->rbegin()+(seq->size()-(seq_start+seq_count));
139 return SeqSpan::const_reverse_iterator();
142 SeqSpan::const_reverse_iterator SeqSpan::rend() const
144 if (seq and seq_count != 0) {
145 return rbegin() + seq_count;
147 return SeqSpan::const_reverse_iterator();
151 bool SeqSpan::empty() const
153 return (seq_count == 0) ? true : false;
156 SeqSpan::size_type SeqSpan::find_first_not_of(
157 const std::string& query,
158 SeqSpan::size_type index) const
160 typedef std::set<std::string::value_type> sequence_set;
161 sequence_set match_set;
163 for(const_iterator query_item = query.begin();
164 query_item != query.end();
167 match_set.insert(*query_item);
169 for(const_iterator base = begin();
173 if(match_set.find(*base) == match_set.end()) {
177 return SeqSpan::npos;
180 void SeqSpan::setStart(SeqSpan::size_type v)
184 throw mussa_error("can't set Start > Stop");
186 seq_count += seq_start - v;
190 void SeqSpan::setStop(SeqSpan::size_type v)
193 // negative sized sequences are bad
194 throw mussa_error("can't set Stop < Start");
196 seq_count = std::min<size_type>(v - seq_start, parentSize()-parentStart());
199 SeqSpan::size_type SeqSpan::parentStart() const
205 return start() - parent->start();
209 void SeqSpan::setParentStart(SeqSpan::size_type v)
211 setStart(parent->start() + v);
214 SeqSpan::size_type SeqSpan::parentStop() const
220 return stop() - parent->start();
224 void SeqSpan::setParentStop(SeqSpan::size_type v)
226 setStop(parent->start() + v);
229 SeqSpanRef SeqSpan::subseq(size_type start, size_type count)
231 count = std::min<size_type>(count, seq_count - start);
233 SeqSpanRef new_span(new SeqSpan(this->shared_from_this(), start, count));
237 std::string SeqSpan::sequence() const
240 return seq->substr(seq_start, seq_count);
242 return std::string();
246 bool SeqSpan::isFamily(const SeqSpan& a, const SeqSpan& b)
248 return a.seq.get() == b.seq.get();