/usr/include/kmer/bigQueue.H is in libmeryl-dev 0~20150903+r2013-1.
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 143 144 145 146 147 148 149 150 | #ifndef BIGQUEUE_H
#define BIGQUEUE_H
#include "util++.H"
// A disk-backed list of user-defined objects.
//
// At creation time, you can opt to have it sorted, using a
// user-defined function.
// An list based on a variable length object (let alone a sort!)
// must use some form of dereferencing scheme. So, if you want to
// use variable length records, you have to use pointers, and supply
// functions to do everything (compare, read, write).
//
// On the otherhand, it would be quite more convenient (to use) if we
// used objects (would need copy, compare, read, write).
//
// 1) Restrict to void*, fixed block size, functions for compare,
// destroy. read, write and copy done with fread(), fwrite() and
// memcpy().
//
// 2) Restrict to void*, functions for compare, read, write and
// destroy. I allocate an array of pointers. Assume shallow copies
// are ok (qsort will be used). On construct, we need to know the
// size of the data so we know how many objects to buffer before
// sorting and writing. It's also possible to use fread() and
// fwrite().
//
// 3) Restrict to objects, operators for copy, compare, read, write,
// default construct, destroy. I allocate an array of objects.
//
// 1 is the easiest to write, 2 and 3 are conceptually the same. 1
// cannot write out deep data (pointer to string). 2 is a trivial
// extenstion to 1, and fixes that. 3 is the correct version, but I
// don't want to deal with streams io. So, 2 it is.
//
class bigQueue {
public:
// Initialize the bigQueue for anonymous storage, with an
// option to later save the array.
//
bigQueue(bool (*readfcn)(FILE *, void *),
bool (*writfcn)(FILE *, void *),
void (*killfcn)(void *),
uint32 objectSize,
char *tmpPath) {
_initialize(0L, readfcn, writfcn, killfcn, objectSize, 0, tmpPath, 0L);
};
// Initialize the bigQueue with a file of objects, presumabely from
// a previous invocation of bigQueue.
//
bigQueue(bool (*readfcn)(FILE *, void *),
bool (*writfcn)(FILE *, void *),
void (*killfcn)(void *),
uint32 objectSize,
char *tmpPath,
char *filename) {
_initialize(0L, readfcn, writfcn, killfcn, objectSize, 0, tmpPath, filename);
};
// Initialize the bigQueue for sorting.
//
bigQueue(int (*sortfcn)(const void *a, const void *b),
bool (*readfcn)(FILE *, void *),
bool (*writfcn)(FILE *, void *),
void (*killfcn)(void *),
uint32 objectSize,
uint32 memoryToUse,
char *tmpPath) {
_initialize(sortfcn, readfcn, writfcn, killfcn, objectSize, memoryToUse, tmpPath, 0L);
};
private:
void _initialize(int (*sortfcn)(const void *a, const void *b),
bool (*readfcn)(FILE *f, void *a),
bool (*writfcn)(FILE *f, void *a),
void (*killfcn)(void *),
uint32 objectSize,
uint32 memoryToUse,
char *tmppath,
char *filename);
public:
~bigQueue();
// Add elements to the end of the array.
void add(void *);
// We are designed for streaming access.
bool next(void);
void *get(void);
// Rewind to the start. Sortable must be sorted.
void rewind(void);
// Save the anonymous array into a real file.
void save(char *filepath);
// Sort the sortable. Flush the flushable.
void sort(void);
void flush(void);
private:
void sortAndWriteBuffer(void);
void clearBuffer(void);
void mergeTemporaryFiles(void);
char *_saveFile;
char *_tmpPath;
int (*_sortFunction)(const void *a, const void *b);
bool (*_writFunction)(FILE *f, void *a);
bool (*_readFunction)(FILE *f, void *a);
void (*_killFunction)(void *a);
uint32 _objectSize;
uint32 _memoryToUse;
uint32 _maxOpenFiles;
uint32 _numTemporaryFiles;
uint32 _numMergeFiles;
// _temporaryFiles is all the opened output files. If we aren't
// sorting, then only the first one is opened.
//
// _inputFile is a dup of the first temporary file. If we are
// sorting, and you start reading before you sort, then you'll get
// a very short read.
//
FILE **_temporaryFiles;
FILE *_inputFile;
// Stores things read back from disk, for return to the user.
// Currently just one, but should be extended to many.
//
void *_thingBuffer;
uint32 _bufferMax;
uint32 _bufferLen;
void **_buffer;
};
#endif // BIGQUEUE_H
|