: seq(o.seq),
seq_start(o.seq_start),
seq_count(o.seq_count),
- parent(o.parent),
- rc_seq(o.rc_seq)
+ parent_seq(o.parent_seq),
+ rc_seq(o.rc_seq),
+ seq_annotations(o.seq_annotations),
+ seq_drawable(o.seq_drawable)
{
}
: seq(p->seq),
seq_start(p->seq_start),
seq_count(p->seq_count),
- parent(p->parent),
- rc_seq(p->rc_seq)
+ parent_seq(p->parent_seq),
+ rc_seq(p->rc_seq),
+ seq_annotations(p->seq_annotations),
+ seq_drawable(p->seq_drawable)
{
}
strand_type strand_)
: seq_start(0),
seq_count(seq_.length()),
- parent()
+ parent_seq()
{
switch (strand_) {
case PlusStrand:
strand_type strand_)
: seq(parent_->seq),
seq_start(parent_->seq_start + start_),
- parent(parent_)
+ parent_seq(parent_)
{
if (count_ == npos)
seq_count = parent_->seq_count;
seq_strand = strand_;
break;
case SameStrand:
- if (parent) {
- seq_strand = parent->strand();
+ if (parent_seq) {
+ seq_strand = parent_seq->strand();
} else {
throw sequence_invalid_strand("SameStrand is undefined with no parent");
}
break;
case OppositeStrand:
- if (parent) {
- switch (parent->strand()) {
+ if (parent_seq) {
+ switch (parent_seq->strand()) {
case PlusStrand:
seq_strand = MinusStrand;
break;
break;
case UnknownStrand:
case BothStrand:
- seq_strand = parent->strand();
+ seq_strand = parent_seq->strand();
break;
case SingleStrand:
throw sequence_invalid_strand(
}
break;
case SingleStrand:
- if (parent) {
- if (parent->strand() == SingleStrand) {
+ if (parent_seq) {
+ if (parent_seq->strand() == SingleStrand) {
seq_strand = SingleStrand;
} else {
throw sequence_invalid_strand("Can't change single strandedness");
// If our parent is on the minus strand, we need to adjust the start
// and count to look like we're selecting from the right side of the
// parent sequence (AKA the start of the minus strand)
- if (parent and parent->strand() == MinusStrand) {
- seq_start = parent->start() + parent->size() - (start_ + seq_count);
+ if (parent_seq and parent_seq->strand() == MinusStrand) {
+ seq_start = parent_seq->start() + parent_seq->size() - (start_ + seq_count);
}
}
seq = s.seq;
seq_start = s.seq_start;
seq_count = s.seq_count;
- parent = s.parent;
+ parent_seq = s.parent_seq;
rc_seq = s.rc_seq;
+ //seq_annotations.reset(s.seq_annotations);
+ //seq_drawable.reset(s.seq_drawable);
}
return *this;
}
SeqSpan::size_type SeqSpan::parentStart() const
{
- if (!parent) {
+ if (!parent_seq) {
// no parent
return start();
} else {
- return start() - parent->start();
+ return start() - parent_seq->start();
}
}
void SeqSpan::setParentStart(SeqSpan::size_type v)
{
- setStart(parent->start() + v);
+ setStart(parent_seq->start() + v);
}
SeqSpan::size_type SeqSpan::parentStop() const
{
- if (!parent) {
+ if (!parent_seq) {
// no parent
return stop();
} else {
- return stop() - parent->start();
+ return stop() - parent_seq->start();
}
}
void SeqSpan::setParentStop(SeqSpan::size_type v)
{
- setStop(parent->start() + v);
+ setStop(parent_seq->start() + v);
}
SeqSpanRef SeqSpan::subseq(size_type start, size_type count, strand_type strand)