source: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/algorithms/Match.java @ 1760

/*
 * 
 */
package de.ugoe.cs.autoquest.tasktrees.alignment.algorithms;

import java.util.Iterator;
import java.util.LinkedList;

// TODO: Auto-generated Javadoc
/**
 * The Class Match.
 */
public class Match {

        /** The matchseqs. */
        private final NumberSequence[] matchseqs;

        /** The occurences. */
        private LinkedList<MatchOccurrence> occurrences;

        /**
         * Instantiates a new match.
         */
        public Match() {
                matchseqs = new NumberSequence[2];
                occurrences = new LinkedList<MatchOccurrence>();
                
        }               

        /**
         * Adds the occurrence.
         *
         * @param occurence the occurrence
         */
        public void addOccurence(MatchOccurrence occurence) {
                occurrences.add(occurence);
        }

        /**
         * Adds the occurrences of given match to this match .
         *
         * @param m the match the occurrences should be merged with this one
         */
        public void addOccurencesOf(Match m) {
                occurrences.addAll(m.getOccurences());
        }

        /**
         * Equals.
         *
         * @param m the Match the equality should be checked against
         * @return true, if both Matches are equal
         */
        public boolean equals(Match m) {
                if ((m.getFirstSequence().equals(this.getFirstSequence()) || m
                                .getFirstSequence().equals(this.getSecondSequence()))
                                && (m.getSecondSequence().equals(this.getFirstSequence()) || m
                                                .getSecondSequence().equals(this.getSecondSequence()))) {
                        return true;
                }
                return false;
        }

        /**
         * Gets the first sequence.
         *
         * @return the first sequence
         */
        public NumberSequence getFirstSequence() {
                return matchseqs[0];
        }

        /**
         * Gets the occurrences.
         *
         * @return the occurrences
         */
        public LinkedList<MatchOccurrence> getOccurences() {
                return occurrences;
        }

        /**
         * Gets the second sequence.
         *
         * @return the second sequence
         */
        public NumberSequence getSecondSequence() {
                return matchseqs[1];
        }

        /**
         * Occurrence count.
         *
         * @return the number of occurrences of this match
         */
        public int occurenceCount() {
                return occurrences.size();
        }

        /**
         * Sets the first sequence.
         *
         * @param seq the new first sequence
         */
        public void setFirstSequence(NumberSequence seq) {
                matchseqs[0] = seq;
        }

        /**
         * Sets the occurrences.
         *
         * @param occurences the new occurrences
         */
        public void setOccurences(LinkedList<MatchOccurrence> occurences) {
                this.occurrences = occurences;
        }

        /**
         * Sets the second sequence.
         *
         * @param seq the new second sequence
         */
        public void setSecondSequence(NumberSequence seq) {
                matchseqs[1] = seq;
        }


        /**
         * Occurrence id sum. Used for comparing and sorting matches
         *
         * @return the sum of all occurrence ids.
         */
        public int ocurrenceIDSum() {
                int sum = 0;
                for(Iterator<MatchOccurrence> it = occurrences.iterator();it.hasNext();) {
                        MatchOccurrence mo = it.next();
                        sum+=mo.getSequenceId();
                }
                return sum;
        }
        
        /**
         * Task id sum. Used for comparing and sorting matches
         *
         * @return the int
         */
        public int taskIdSum() {
                int sum = 0;
                int[] first = this.getFirstSequence().getSequence();
                int[] second = this.getSecondSequence().getSequence();
                for(int i = 0;i < this.getFirstSequence().size();i++) {
                        sum= first[i]+second[i];
                }
                return sum;
        }
        
        
        
        /**
         * Clone without occurrences.
         *
         * @return the match
         * @throws CloneNotSupportedException the clone not supported exception
         */
        /*
        public Match cloneWithoutOccurrences()   {
                Match result = new Match();
                result.setFirstSequence(this.getFirstSequence());
                result.setSecondSequence(this.getSecondSequence());
                return result;
        }*/
        

        /**
         * Size.
         *
         * @return the size (number of aligned tasks)
         */
        public int size() {
                // Both sequences should be equally long
                return matchseqs[0].size();
        }
}