libMems/MatchHashEntry.h

Go to the documentation of this file.

/*******************************************************************************
 * $Id: Match.h,v 1.10 2004/03/01 02:40:08 darling Exp $
 * This file is copyright 2002-2007 Aaron Darling and authors listed in the AUTHORS file.
 * This file is licensed under the GPL.
 * Please see the file called COPYING for licensing details.
 * **************
 ******************************************************************************/

#ifndef __MatchHashEntry_h__
#define __MatchHashEntry_h__

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "libGenome/gnClone.h"
#include <iostream>
#include <set>
#include "libMems/Match.h"

namespace mems {

class MatchHashEntry : public Match
{
public:
        enum MemType
        {
                seed,
                extended
        };

public:
        MatchHashEntry();
        MatchHashEntry( const uint seq_count, const gnSeqI mersize, const MemType m_type = seed );
        MatchHashEntry* Clone() const;
        MatchHashEntry* Copy() const;
        virtual void Free();
        MatchHashEntry( const MatchHashEntry& mhe ){ *this = mhe; }
        MatchHashEntry& operator=(const MatchHashEntry& mhe);

        boolean operator==(const MatchHashEntry& mhe) const;


        boolean Extended() const{return m_extended;}
        void SetExtended(boolean extended){m_extended = extended;}
        uint MerSize() const{return m_mersize;}

        virtual void CalculateOffset();
        
        int64 Offset() const{return m_offset;};

        void SetOffset(int64 offset){m_offset = offset;};               

        static boolean offset_lessthan(const MatchHashEntry& a, const MatchHashEntry& b);
        static boolean start_lessthan_ptr(const MatchHashEntry* a, const MatchHashEntry* b);
        static bool start_lessthan(const MatchHashEntry& a, const MatchHashEntry& b);
        static boolean strict_start_lessthan_ptr(const MatchHashEntry* a, const MatchHashEntry* b);
        static int64 end_to_start_compare(const MatchHashEntry& a, const MatchHashEntry& b);
        static int64 start_compare(const MatchHashEntry& a, const MatchHashEntry& b);

        boolean Contains(const MatchHashEntry& mhe) const;

private:

        boolean m_extended;
        gnSeqI m_mersize;
        int64 m_offset;
};

inline
MatchHashEntry* MatchHashEntry::Copy() const
{
        return m_allocateAndCopy(*this);
}
inline
void MatchHashEntry::Free()
{
        m_free(this);
}

inline
bool MatchHashEntry::start_lessthan(const MatchHashEntry& a, const MatchHashEntry& b){
        return start_lessthan_ptr(&a, &b);
}

class MheCompare {
public:
        bool operator()(const MatchHashEntry* a, const MatchHashEntry* b) const{
                if( a->FirstStart() > b->FirstStart() ){
                        return true;
                }else if( a->FirstStart() == b->FirstStart() ){
                        // check that the matches hit the same genomes
                        for( size_t i = a->FirstStart(); i < a->SeqCount(); i++ )
                        {
                                if( a->LeftEnd(i) == NO_MATCH && b->LeftEnd(i) != NO_MATCH )
                                        return true;
                                else if( a->LeftEnd(i) != NO_MATCH && b->LeftEnd(i) == NO_MATCH )
                                        return false;
                        }
                        //offsets are the same, check for containment...
                        if(a->Contains(*b) || b->Contains(*a)){
                                return false;
                        }else
                                return MatchHashEntry::strict_start_lessthan_ptr(a, b);
                }
                return false;
        }
};

}

#endif // __MatchHashEntry_h__

---