libMems/MemHash.h

Go to the documentation of this file.

/*******************************************************************************
 * $Id: MemHash.h,v 1.23 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 _MemHash_h_
#define _MemHash_h_

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

#include <set>
#include <map>
#include <iostream>

#include "libMems/MatchFinder.h"
#include "libMems/Match.h"
#include "libGenome/gnException.h"
#include "libMems/MatchList.h"
#include "libMems/MatchHashEntry.h"
#include "libMems/SlotAllocator.h"
#include "boost/pool/object_pool.hpp"

namespace mems {

static const uint32 DEFAULT_MEM_TABLE_SIZE = 40000;
static const uint32 DEFAULT_REPEAT_TOLERANCE = 0;
static const uint32 DEFAULT_ENUMERATION_TOLERANCE = 1;

class MemHash : public MatchFinder{

   

public:
        MemHash();
        ~MemHash();
        MemHash(const MemHash& mh);
        MemHash& operator=( const MemHash& mh );
        virtual MemHash* Clone() const;
        virtual void Clear();
        virtual void ClearSequences();
        
        virtual void FindMatches( MatchList& match_list );
        virtual void FindMatchesFromPosition( MatchList& match_list, const std::vector<gnSeqI>& start_points );

        virtual boolean CreateMatches();

        virtual uint32 TableSize() const {return table_size;};
        virtual void SetTableSize(uint32 new_table_size);
        virtual MatchList GetMatchList() const;
        //virtual void GetMatchList( std::vector<Match*>& mem_list ) const;
        
        template< class MatchListType >
        void GetMatchList( MatchListType& mem_list ) const;
        
        virtual uint32 MemCount(){return m_mem_count;}
        virtual uint32 MemCollisionCount(){return m_collision_count;}
        virtual void MemTableCount(std::vector<uint32>& table_count){table_count = mem_table_count;}
        virtual void PrintDistribution(std::ostream& os) const;
        
        virtual void LoadFile(std::istream& mem_file);
        virtual void WriteFile(std::ostream& mem_file) const;

        virtual void SetRepeatTolerance(uint32 repeat_tolerance){m_repeat_tolerance = repeat_tolerance;}
        virtual uint32 GetRepeatTolerance() const{return m_repeat_tolerance;}
        virtual void SetEnumerationTolerance(uint32 enumeration_tolerance){m_enumeration_tolerance = enumeration_tolerance;}
        virtual uint32 GetEnumerationTolerance() const{return m_enumeration_tolerance;}
        
        void SetMatchLog( std::ostream* match_log ){ this->match_log = match_log; }

        

        //end void GetMatchList( std::vector<MatchListType*>& mem_list );

protected:
        virtual boolean EnumerateMatches( IdmerList& match_list );
        virtual boolean HashMatch(IdmerList& match_list);
        virtual void SetDirection(MatchHashEntry& mhe);
        virtual MatchHashEntry* AddHashEntry(MatchHashEntry& mhe);
        virtual uint32 quadratic_li(uint32 listI){return (listI*(listI+1))/2;}
                
        uint32 table_size;
        std::vector< std::vector<MatchHashEntry*> > mem_table;
        uint32 m_repeat_tolerance;
        uint32 m_enumeration_tolerance;
        uint64 m_mem_count;
        uint64 m_collision_count;
        std::vector<uint32> mem_table_count;

        std::ostream* match_log;
        SlotAllocator<MatchHashEntry>& allocator;
        std::vector<MatchHashEntry*> allocated; // used to track what needs to get explicitly destroyed later...
//      boost::object_pool<MatchHashEntry> allocator;
        MheCompare mhecomp;
};


template< class MatchListType >
void MemHash::GetMatchList( MatchListType& mem_list ) const {
        
        mem_list.clear();
        typedef typename MatchListType::value_type MatchType;
   
        //Boost to the rescue! use remove_pointer to get at MatchListType's type
        typedef typename boost::remove_pointer<MatchType>::type SinPtrMatchType;
        SinPtrMatchType mm;

        for(uint32 i=0; i < table_size; ++i)
        {
                std::vector<MatchHashEntry*>::const_iterator iter = mem_table[i].begin();
                for(; iter != mem_table[i].end(); iter++ )
                {
                        MatchType m = mm.Copy();
                        *m = **iter;
                        mem_list.push_back( m );
                }
        }

}


}

#endif //_MemHash_h_

---