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_)
25 : seq(new SeqString(seq_)),
27 seq_count(seq_.length()),
32 SeqSpan::SeqSpan(const SeqSpanRef parent_, size_type start_, size_type count_)
34 seq_start(parent_->seq_start + start_),
38 seq_count = parent_->seq_count;
45 SeqSpan &SeqSpan::operator=(const SeqSpan& s)
49 seq_start = s.seq_start;
50 seq_count = s.seq_count;
56 std::ostream& operator<<(std::ostream& out, const SeqSpan& s)
61 /* Not implemented yet
63 //! \throws sequence_invalid_comparison
64 friend bool operator<(const SeqSpan&, const SeqSpan&);
65 bool operator<(const SeqSpan& a, const SeqSpan& b)
67 // are we subcomponents of the same sequence region?
68 if (a.seq.get() == b.seq.get()) {
69 if (a.seq_start < b.seq_start)
74 throw mussa_error("can only compare two spans from the same sequence");
79 bool operator==(const SeqSpan& a, const SeqSpan& b)
81 if (SeqSpan::isFamily(a, b)) {
82 std::cout << " " << a.seq_start
85 << " " << b.seq_count << std::endl;
86 // can do fast comparison
87 if (a.seq_start == b.seq_start and a.seq_count == b.seq_count) {
96 bool operator!=(const SeqSpan& a, const SeqSpan& b)
101 SeqSpan::const_reference SeqSpan::operator[](SeqSpan::size_type i) const
106 SeqSpan::const_reference SeqSpan::at(SeqSpan::size_type i) const
108 if (!seq) throw std::out_of_range("empty sequence");
109 return seq->at(i+seq_start);
112 const char *SeqSpan::data() const
115 return seq->c_str()+seq_start;
120 SeqSpan::const_iterator SeqSpan::begin() const
122 if (seq and seq_count != 0)
123 return seq->begin()+seq_start;
125 return SeqSpan::const_iterator(0);
128 SeqSpan::const_iterator SeqSpan::end() const
130 if (seq and seq_count != 0) {
131 return seq->begin() + seq_start + seq_count;
133 return SeqSpan::const_iterator(0);
137 SeqSpan::const_reverse_iterator SeqSpan::rbegin() const
139 if (seq and seq_count != 0)
140 return seq->rbegin()+(seq->size()-(seq_start+seq_count));
142 return SeqSpan::const_reverse_iterator();
145 SeqSpan::const_reverse_iterator SeqSpan::rend() const
147 if (seq and seq_count != 0) {
148 return rbegin() + seq_count;
150 return SeqSpan::const_reverse_iterator();
154 bool SeqSpan::empty() const
156 return (seq_count == 0) ? true : false;
159 SeqSpan::size_type SeqSpan::find_first_not_of(
160 const std::string& query,
161 SeqSpan::size_type index) const
163 typedef std::set<std::string::value_type> sequence_set;
164 sequence_set match_set;
166 for(const_iterator query_item = query.begin();
167 query_item != query.end();
170 match_set.insert(*query_item);
172 for(const_iterator base = begin();
176 if(match_set.find(*base) == match_set.end()) {
180 return SeqSpan::npos;
183 void SeqSpan::setStart(SeqSpan::size_type v)
187 throw mussa_error("can't set Start > Stop");
189 seq_count += seq_start - v;
193 void SeqSpan::setStop(SeqSpan::size_type v)
196 // negative sized sequences are bad
197 throw mussa_error("can't set Stop < Start");
199 seq_count = std::min<size_type>(v - seq_start, parentSize()-parentStart());
202 SeqSpan::size_type SeqSpan::parentStart() const
208 return start() - parent->start();
212 void SeqSpan::setParentStart(SeqSpan::size_type v)
214 setStart(parent->start() + v);
217 SeqSpan::size_type SeqSpan::parentStop() const
223 return stop() - parent->start();
227 void SeqSpan::setParentStop(SeqSpan::size_type v)
229 setStop(parent->start() + v);
232 SeqSpanRef SeqSpan::subseq(size_type start, size_type count)
234 count = std::min<size_type>(count, seq_count - start);
236 SeqSpanRef new_span(new SeqSpan(this->shared_from_this(), start, count));
240 std::string SeqSpan::sequence() const
243 return seq->substr(seq_start, seq_count);
245 return std::string();
249 bool SeqSpan::isFamily(const SeqSpan& a, const SeqSpan& b)
251 return a.seq.get() == b.seq.get();