/usr/include/kmer/bio/kmeriface.H is in libkmer-dev 0~20150903+r2013-3.
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 | #if 0
// Documentation, really.
// Incomplete too.
class kMerInterface {
kMerInterface() {};
virtual ~kMerInterface() {};
// Reverse all the words, reverse and complement the bases in
// each word, then shift right to align the edge.
//
virtual kMerInterface &reverseComplement(void) = 0;
virtual void clear(void);
// Construct a mer by shifting bases onto the end:
// += shifts onto the right end
// -= shifts onto the left end
//
virtual void operator+=(uint64 x) = 0;
virtual void operator-=(uint64 x) = 0;
// used by merStream at least
//
virtual void mask(bool) = 0;
// Return the mer, as a 64-bit integer. If the mer is more than
// 32-bases long, then the left-most (the earliest, the start, etc)
// bases are used.
//
virtual operator uint64 () const = 0;
// These are written/read in 5'endian, which isn't the most natural
// implementation. It's done this way to keep the sequence in
// order (e.g., the merStreamFile). Don't change the order.
//
// On the otherhand, the implementation (of write anyway) is
// basically the same as merToString().
//
// Takes an optional number of BITS to write, pulled from the
// END of the mer.
//
virtual void writeToBitPackedFile(bitPackedFile *BPF, uint32 numBits=0) const = 0;
virtual void readFromBitPackedFile(bitPackedFile *BPF, uint32 numBits=0) = 0;
// Returns a sub-mer from either the start (left end) or the end
// (right end) of the mer. The sub-mer must be at most 64 bits
// long. Yes, BITS.
//
// The start is difficult, because it can span multiple words. The
// end is always in the first word.
//
virtual uint64 startOfMer(uint32 bits) const = 0;
virtual uint64 endOfMer(uint32 bits) const = 0;
// Set 'numbits' bits from (the end of) 'val' at bit position 'pos'
// in the mer. This is wildly low-level, but merylStreamReader
// needs it.
//
// The position is measured from the right end.
// (0, 8, X) would copy the bits 7 to 0 of X to bits 7 to 0 of the mer.
//
// Argh! Can't use set/getDecodedValue because that is doing things in the wrong order.
//
// Meryl
//
virtual uint64 getWord(uint32 wrd) const = 0; // { return(MERWORD(wrd)); };
virtual void setWord(uint32 wrd, uint64 val) = 0; // { MERWORD(wrd) = val; };
// Show the mer as ascii
//
// Doesn't print the last full word, if it's on the word boundary
//
// We build the string right to left, print any partial word first,
// then print whole words until we run out of words to print.
//
virtual char *merToString(char *instr) const = 0;
};
#endif
|