sequence_annotation.hh

#ifndef LOCARNA_SEQUENCE_ANNOTATION_HH
#define LOCARNA_SEQUENCE_ANNOTATION_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <string>
#include <vector>

#include <iosfwd>

#include "aux.hh"

namespace LocARNA {
    class AlignmentEdges;
    
    class SequenceAnnotation {

        typedef std::string name_t;
        
        typedef std::vector<std::string> annotation_t;
        
        annotation_t annotation_;
        
        static
        const
        SequenceAnnotation empty_instance_;

    public:
        
        explicit
        SequenceAnnotation(size_type name_length=0):annotation_(name_length) {}
        
        explicit
        SequenceAnnotation(const std::string &annotation_string);

        explicit
        SequenceAnnotation(const std::vector<std::string> &annotation_strings);
        
        SequenceAnnotation(const AlignmentEdges &edges, 
                           const SequenceAnnotation &annotationA,
                           const SequenceAnnotation &annotationB);


        static 
        const SequenceAnnotation&
        empty_instance() {
            return SequenceAnnotation::empty_instance_;
        }

        size_t
        length() const {
            return annotation_.size()>0?annotation_[0].size():0;
        }
        
        bool
        empty() const {
            return length()==0;
        }

        size_t 
        name_length() const {
            return annotation_.size();
        }
        
        const std::string &
        annotation_string(size_t i) const {
            assert(i<annotation_.size());
            return annotation_[i];
        }
        
        std::string
        single_string(char sep='#') const;
        
        static
        bool
        is_neutral_char(char c) {
            return c==' ' || c=='.';
        }
        
        static
        bool
        is_neutral(const name_t &name);

        bool
        is_neutral_pos(size_t i) const;
        
        std::string 
        name(size_t i) const;

        void
        push_back_name(const name_t &name);

        /*
         * @brief test for duplicate names
         * @return whether annotation contains duplicate names
         */
        bool
        duplicate_names() const;
        
        /*
         * @brief test for name clashs
         *
         * @param edges alignment edges between A and B
         * @param annotationA annotation A
         * @param annotationB annotation B
         *
         * @return whether names in A and B clash when aligned via edges
         */
        static
        bool
        clashing_names(const AlignmentEdges &edges, 
                       const SequenceAnnotation &annotationA,
                       const SequenceAnnotation &annotationB);
        
    };
}

#endif // LOCARNA_SEQUENCE_ANNOTATION_HH