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 {
    public:
        typedef std::string name_t;
 
        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);
 
    private:
        typedef std::vector<std::string> annotation_t;
 
        annotation_t annotation_;
 
        static const SequenceAnnotation empty_instance_;
    };
}
 
#endif // LOCARNA_SEQUENCE_ANNOTATION_HH