SequenceFeature.h

Go to the documentation of this file.

//
// File: SequenceFeature.h
// Created by: Julien Dutheil
// Created on: Mon Nov 21 2011
//
 
/*
Copyright or © or Copr. Bio++ Development Team, (November 17, 2004)
 
This software is a computer program whose purpose is to provide classes
for sequences analysis.
 
This software is governed by the CeCILL  license under French law and
abiding by the rules of distribution of free software.  You can  use, 
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info". 
 
As a counterpart to the access to the source code and  rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty  and the software's author,  the holder of the
economic rights,  and the successive licensors  have only  limited
liability. 
 
In this respect, the user's attention is drawn to the risks associated
with loading,  using,  modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean  that it is complicated to manipulate,  and  that  also
therefore means  that it is reserved for developers  and  experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or 
data to be ensured and,  more generally, to use and operate it in the 
same conditions as regards security. 
 
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
 
#ifndef _SEQUENCEFEATURE_H_
#define _SEQUENCEFEATURE_H_
 
//From the STL:
#include <string>
#include <map>
#include <set>
#include <algorithm>
 
//From bpp-core:
#include <Bpp/Clonable.h>
#include <Bpp/Numeric/Range.h>
 
namespace bpp
{
 
class SeqRange:
  public Range<size_t>
{
  private:
    char strand_;
 
  public:
    SeqRange(size_t a, size_t b, char strand = '.'):
      Range<size_t>(a, b), strand_(strand) {
        if (strand != '+' && strand != '-' && strand != '?' && strand != '.')
          strand_ = '.';
    }
 
    SeqRange(const Range<size_t> range, char strand = '.'):
      Range<size_t>(range), strand_(strand) {
        if (strand != '+' && strand != '-' && strand != '?' && strand != '.')
          strand_ = '.';
    }
 
    SeqRange* clone() const { return new SeqRange(*this); }
 
  public:
    virtual char getStrand() const { return strand_; }
 
    virtual bool isNegativeStrand() const { return strand_ == '-'; }
    virtual bool isStranded() const { return strand_ == '+' || strand_ == '-'; }
    virtual void invert() {
      if (isStranded()) {
        if (isNegativeStrand()) {
          strand_ = '+';
        } else {
          strand_ = '-';
        }
      }
    }
 
};
 
class SequenceFeature:
  public virtual Clonable
{
  public:
    static const std::string NO_ATTRIBUTE_SET;
 
  public:
    virtual SequenceFeature* clone() const = 0;
 
  public:
    virtual const std::string& getId() const = 0;
    virtual void setId(const std::string& id) = 0;
 
    virtual const std::string& getSequenceId() const = 0;
    virtual void setSequenceId(const std::string& id) = 0;
 
    virtual const std::string& getSource() const = 0;
    virtual void setSource(const std::string& source) = 0;
 
    virtual const std::string& getType() const = 0;
    virtual void setType(const std::string& type) = 0;
 
    virtual const size_t getStart() const = 0;
 
    virtual const size_t getEnd() const = 0;
 
    virtual const size_t size() const {
      return getEnd() - getStart();
    };
 
    virtual bool isStranded() const = 0;
 
    virtual bool isNegativeStrand() const = 0;
 
    virtual void invert() = 0;
 
    virtual SeqRange getRange() const = 0;
 
    virtual bool isEmpty() const { return size() == 0; }
 
    virtual bool isPoint() const { return size() == 1; }
 
    virtual bool overlap(const SequenceFeature& feat) const = 0;
    
    virtual bool overlap(const SeqRange& range) const = 0;
 
    virtual bool includes(const SeqRange& range) const = 0;
 
    virtual bool isIncludedIn(const SeqRange& range) const = 0;
 
    virtual const double& getScore() const = 0;
    virtual void setScore(double score) = 0;
 
    virtual const std::string& getAttribute(const std::string& attribute) const = 0;
    
    virtual std::string& getAttribute(const std::string& attribute) = 0;
 
    virtual std::set< std::string > getAttributeList() const = 0;
    
    virtual void setAttribute(const std::string& attribute, const std::string& value) = 0;
 
    virtual void removeAttribute(const std::string& attribute) = 0;
 
};
 
class BasicSequenceFeature:
  public SequenceFeature
{
  protected:
    std::string id_;
    std::string sequenceId_;
    std::string source_;
    std::string type_;
    SeqRange range_;
    double score_;
    mutable std::map<std::string, std::string> attributes_;
    //SequenceFeatureSet subFeatures_;
 
  public:
    BasicSequenceFeature(): id_(""), sequenceId_(""), source_(""), type_(""), range_(0, 0, '.'), score_(-1), attributes_() {}
 
    BasicSequenceFeature(
        const std::string& id,
        const std::string& seqId,
        const std::string& source,
        const std::string& type,
        size_t start,
        size_t end,
        char strand,
        double score = -1):
      id_(id), sequenceId_(seqId), source_(source),
      type_(type), range_(start, end, strand), score_(score),
      attributes_()
      //attributes_(), subFeatures_()
    {}
 
    virtual BasicSequenceFeature* clone() const { return new BasicSequenceFeature(*this); }
 
  public:
    const std::string& getId() const { return id_; }
    void setId(const std::string& id) { id_ = id; }
    const std::string& getSequenceId() const { return sequenceId_; }
    void setSequenceId(const std::string& sid) { sequenceId_ = sid; }
    const std::string& getSource() const { return source_; }
    void setSource(const std::string& source) { source_ = source; }
    const std::string& getType() const { return type_; }
    void setType(const std::string& type) { type_ = type; }
    const size_t getStart() const { return range_.begin(); }
    const size_t getEnd() const { return range_.end(); }
    bool isStranded() const { return range_.isStranded(); }
    bool isNegativeStrand() const { return range_.isNegativeStrand(); }
    void invert() {
      range_.invert();
    }
    const double& getScore() const { return score_; }
    void setScore(double score) { score_ = score; }
 
    const std::string& getAttribute(const std::string& attribute) const {
      std::map<std::string, std::string>::iterator it = attributes_.find(attribute);
      if (it != attributes_.end())
        return it->second;
      else
        return NO_ATTRIBUTE_SET;
    }
    
    std::string& getAttribute(const std::string& attribute) {
      return attributes_[attribute];
    }
    
    void setAttribute(const std::string& attribute, const std::string& value) {
      attributes_[attribute] = value;
    }
 
    std::set< std::string > getAttributeList() const {
      std::set< std::string > d;
      for (std::map<std::string, std::string>::iterator it = attributes_.begin() ; it != attributes_.end() ; it++) {
        d.insert(it->first);
      }
      return d;
    }
 
    void removeAttribute(const std::string& attribute) {
      std::map<std::string, std::string>::iterator it = attributes_.find(attribute);
      if (it != attributes_.end()) {
        attributes_.erase(it);
      }
    }
 
    SeqRange getRange() const {
      return SeqRange(range_);
    }
 
    bool overlap(const SequenceFeature& feat) const {
      if (feat.getSequenceId() == sequenceId_) {
        return range_.overlap(feat.getRange());
      }
      return false;
    }
 
    bool overlap(const SeqRange& range) const {
      return range_.overlap(range);
    }
 
    virtual bool includes(const SeqRange& range) const {
      return range_.contains(range);
    }
 
    virtual bool isIncludedIn(const SeqRange& range) const {
      return range.contains(range_);
    }
 
     //const SequenceFeatureSet& getSubFeatures() const { return subFeatures; }
    //SequenceFeatureSet& getSubFeatures() { return subFeatures; }
 
};
 
class SequenceFeatureSet
{
  private:
    std::vector<SequenceFeature*> features_;
 
  public:
    SequenceFeatureSet(): features_() {};
 
    virtual ~SequenceFeatureSet() { clear(); }
 
    SequenceFeatureSet(const SequenceFeatureSet& sfs):
      features_()
    {
      for (std::vector<SequenceFeature*>::const_iterator it = sfs.features_.begin();
          it != sfs.features_.end();
          ++it) {
        features_.push_back((**it).clone());
      }
    }
    SequenceFeatureSet& operator=(const SequenceFeatureSet& sfs)
    {
      clear();
      for (std::vector<SequenceFeature*>::const_iterator it = sfs.features_.begin();
          it != sfs.features_.end();
          ++it) {
        features_.push_back((**it).clone());
      }
      return *this;
    }
 
  public:
    void clear()
    {
      for (std::vector<SequenceFeature*>::iterator it = features_.begin();
          it != features_.end();
          ++it) {
        delete *it;
      }
      features_.clear();
    }
 
    const SequenceFeature& getFeature(size_t i) const {
      return *features_[i];
    }
 
    const SequenceFeature& operator[](size_t i) const {
      return *features_[i];
    }
 
    size_t getNumberOfFeatures() const { return features_.size(); }
 
    bool isEmpty() const { return features_.size() == 0; }
 
    void addFeature(const SequenceFeature& feature) {
      features_.push_back(feature.clone());
    }
 
    std::set<std::string> getSequences() const {
      std::set<std::string> seqIds;
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        seqIds.insert((**it).getSequenceId());
      }
      return seqIds;
    }
 
    std::set<std::string> getTypes() const {
      std::set<std::string> types;
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        types.insert((**it).getType());
      }
      return types;
    }
 
    void fillRangeCollection(RangeCollection<size_t>& coords) const {
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        coords.addRange((**it).getRange());
      }
    }
 
    void fillRangeCollectionForSequence(const std::string& seqId, RangeCollection<size_t>& coords) const {
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if ((**it).getSequenceId() == seqId) {
          coords.addRange((**it).getRange());
        }
      }
    }
 
    SequenceFeatureSet* getSubsetForType(const std::string& type) const {
      SequenceFeatureSet* subset = new SequenceFeatureSet();
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if ((**it).getType() == type) {
          subset->addFeature(**it);
        }
      }
      return subset;
    }
 
    SequenceFeatureSet* getSubsetForTypes(const std::vector<std::string>& types) const {
      SequenceFeatureSet* subset = new SequenceFeatureSet();
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if (std::find(types.begin(), types.end(), (**it).getType()) != types.end()) {
          subset->addFeature(**it);
        }
      }
      return subset;
    }
 
    SequenceFeatureSet* getSubsetForSequence(const std::string& id) const {
      SequenceFeatureSet* subset = new SequenceFeatureSet();
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if ((**it).getSequenceId() == id) {
          subset->addFeature(**it);
        }
      }
      return subset;
    }
 
    SequenceFeatureSet* getSubsetForSequences(const std::vector<std::string>& ids) const {
      SequenceFeatureSet* subset = new SequenceFeatureSet();
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if (std::find(ids.begin(), ids.end(), (**it).getSequenceId()) != ids.end()) {
          subset->addFeature(**it);
        }
      }
      return subset;
    }
 
    SequenceFeatureSet* getSubsetForRange(const SeqRange& range, bool complete) const {
      SequenceFeatureSet* subset = new SequenceFeatureSet();
      for (std::vector<SequenceFeature*>::const_iterator it = features_.begin();
          it != features_.end();
          ++it) {
        if (complete) {
          if ((**it).isIncludedIn(range))
            subset->addFeature(**it);
        } else {
          if ((**it).overlap(range))
            subset->addFeature(**it);
        }
      }
      return subset;
    }
 
};
 
} //end of namespace bpp
 
#endif //_SEQUENCEFEATURE_H_