src/LocARNA/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