This file is indexed.

/usr/include/libMems-1.6/libMems/MatchProjectionAdapter.h is in libmems-1.6-dev 1.6.0+4725-4build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*******************************************************************************
 * $Id: MatchProjectionAdapter.h,v 1.8 2004/02/27 23:08:55 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 __MatchProjectionAdapter_h__
#define __MatchProjectionAdapter_h__

#include "libMems/AbstractMatch.h"
#include <vector>

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

namespace mems {

/**
 * MatchProjectionAdapter is a wrapper around an AbstractMatch that effectively projects a multi-match to a
 * subset match.  The adapter class forwards most function calls to the original match
 * class, to which it stores a pointer.  Use of non-const functions results in undefined state.
 */
class MatchProjectionAdapter : public mems::AbstractMatch
{
public:
	MatchProjectionAdapter() : m(NULL){};
	MatchProjectionAdapter( mems::AbstractMatch* match, const std::vector< size_t >& projection ) :
	  seq(projection)
	{
		m = match->Copy();
	}

	MatchProjectionAdapter( const MatchProjectionAdapter& mpa ) : 
	seq( mpa.seq )
	{
		if( mpa.m != NULL )
			m = mpa.m->Copy();
		else
			m = NULL;
	}

	~MatchProjectionAdapter()
	{
		if( m != NULL )
			m->Free();
	}

	MatchProjectionAdapter* Clone() const { return new MatchProjectionAdapter( *this ); }

	inline
	MatchProjectionAdapter* Copy() const
	{
		return m_allocateAndCopy( *this );
	}

	void Free()
	{
		m_free(this);
	}

	MatchProjectionAdapter& operator=( const MatchProjectionAdapter& mpa )
	{
		if( m != NULL )
			m->Free();
		m = mpa.m->Copy();
		seq = mpa.seq;
		return *this;
	}

	//
	// forward all function calls to match
	//
	gnSeqI Length( uint seqI ) const { return m->Length(seq[seqI]); }
	void SetLength( gnSeqI len, uint seqI ) { m->SetLength(len, seq[seqI]); }
	int64 Start(uint startI) const { return m->Start(seq[startI]); }
	void SetStart(uint seqI, int64 start) { m->SetStart(seq[seqI],start); }
	gnSeqI LeftEnd(uint seqI) const { return m->LeftEnd(seq[seqI]); }
	orientation Orientation(uint seqI) const { return m->Orientation(seq[seqI]); }
	void SetLeftEnd(uint seqI, gnSeqI start) { m->SetLeftEnd(seq[seqI],start); }
	void SetOrientation(uint seqI, orientation o) { m->SetOrientation(seq[seqI],o); }
	void MoveStart(int64 move_amount) { m->MoveStart(move_amount); }
	void MoveEnd(int64 move_amount) { m->MoveEnd(move_amount); }
	uint Multiplicity() const 
	{ 
		size_t mult = 0;
		for( size_t projI = 0; projI < seq.size(); projI++ )
			if( m->LeftEnd(projI) != mems::NO_MATCH )
				++mult;
		return mult; 
	}
	uint SeqCount() const { return seq.size(); }
	uint FirstStart() const { return 0; }	
	gnSeqI AlignmentLength() const { return m->AlignmentLength(); }
	void Invert() { m->Invert(); }
	void CropStart(gnSeqI crop_amount) { m->CropStart(crop_amount); }
	void CropEnd(gnSeqI crop_amount) { m->CropEnd(crop_amount); }
	void CropLeft(gnSeqI crop_amount, uint seqI) { m->CropLeft(crop_amount, seq[seqI]); }
	void CropRight(gnSeqI crop_amount, uint seqI) { m->CropRight(crop_amount, seq[seqI]); }
	void GetAlignment( std::vector< mems::bitset_t >& align_matrix ) const 
	{
		std::vector< mems::bitset_t > aln_mat;
		m->GetAlignment(aln_mat);
		align_matrix.clear();
		for( size_t seqI = 0; seqI < seq.size(); ++seqI )
			align_matrix.push_back(aln_mat[seq[seqI]]);
	}
	void GetColumn( gnSeqI col, std::vector<gnSeqI>& pos, std::vector<bool>& column ) const 
	{
		std::vector<gnSeqI> m_pos; 
		std::vector<bool> m_column;
		m->GetColumn(col,m_pos,m_column);
		pos.clear();
		for( size_t seqI = 0; seqI < seq.size(); ++seqI )
		{
			pos.push_back(m_pos[seq[seqI]]);
			column.push_back(m_column[seq[seqI]]);
		}
	}
	bool IsGap( uint seqI, gnSeqI col ) const { return m->IsGap( seq[seqI],col ); }
	uint UsedSeq( uint seqI ) const 
	{
		uint c = 0;
		for( uint i = 0; i < seq.size(); i++ )
		{
			if(m->Start(seq[i]) != 0)
				c++;
			if(c>seqI)
				return i;
		}
		return (std::numeric_limits<uint>::max)();
	};

	mems::AbstractMatch* m;
	std::vector< size_t > seq;
};

}

#endif // __MatchProjectionAdapter_h__