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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/*
* Copyright (C) 2010 Regents of the University of Michigan
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __BGZFFILETYPE_H__
#define __BGZFFILETYPE_H__
#ifdef __ZLIB_AVAILABLE__
#include <stdexcept> // stdexcept header file
#include "bgzf.h"
#include "FileType.h"
class BgzfFileType : public FileType
{
public:
BgzfFileType()
{
bgzfHandle = NULL;
myEOF = false;
}
virtual ~BgzfFileType()
{
bgzfHandle = NULL;
}
BgzfFileType(const char * filename, const char * mode);
virtual bool operator == (void * rhs)
{
// No two file pointers are the same, so if rhs is not NULL, then
// the two pointers are different (false).
if (rhs != NULL)
return false;
return (bgzfHandle == rhs);
}
virtual bool operator != (void * rhs)
{
// No two file pointers are the same, so if rhs is not NULL, then
// the two pointers are different (true).
if (rhs != NULL)
return true;
return (bgzfHandle != rhs);
}
// Close the file.
virtual inline int close()
{
int result = bgzf_close(bgzfHandle);
bgzfHandle = NULL;
return result;
}
// Reset to the beginning of the file.
virtual inline void rewind()
{
// Just call rewind to move to the beginning of the file.
seek(myStartPos, SEEK_SET);
}
// Check to see if we have reached the EOF.
virtual inline int eof()
{
// check the file for eof.
return myEOF;
}
// Check to see if the file is open.
virtual inline bool isOpen()
{
if (bgzfHandle != NULL)
{
// bgzfHandle is not null, so the file is open.
return(true);
}
return(false);
}
// Write to the file
virtual inline unsigned int write(const void * buffer, unsigned int size)
{
return bgzf_write(bgzfHandle, buffer, size);
}
// Read into a buffer from the file. Since the buffer is passed in and
// this would bypass the fileBuffer used by this class, this method must
// be protected.
virtual inline int read(void * buffer, unsigned int size)
{
int bytesRead = bgzf_read(bgzfHandle, buffer, size);
if ((bytesRead == 0) && (size != 0))
{
myEOF = true;
}
else if((bytesRead != (int)size) & (bytesRead >= 0))
{
// Less then the requested size was read
// and an error was not returned (bgzf_read returns -1 on error).
myEOF = true;
}
else
{
myEOF = false;
}
return bytesRead;
}
// Get current position in the file.
// -1 return value indicates an error.
virtual inline int64_t tell()
{
if(myUsingBuffer)
{
throw std::runtime_error("IFILE: CANNOT use buffered reads and tell for BGZF files");
}
return bgzf_tell(bgzfHandle);
}
// Seek to the specified offset from the origin.
// origin can be any of the following:
// Note: not all are valid for all filetypes.
// SEEK_SET - Beginning of file
// SEEK_CUR - Current position of the file pointer
// SEEK_END - End of file
// Returns true on successful seek and false on a failed seek.
virtual inline bool seek(int64_t offset, int origin)
{
int64_t returnVal = bgzf_seek(bgzfHandle, offset, origin);
// Check for failure.
if (returnVal == -1)
{
return false;
}
// Successful.
// Reset EOF, assuming no longer at eof - first read will indicate
// eof if it is at the end.
myEOF = false;
return true;
}
// Set whether or not to require the EOF block at the end of the
// file. True - require the block. False - do not require the block.
static void setRequireEofBlock(bool requireEofBlock);
protected:
// A bgzfFile is used.
BGZF* bgzfHandle;
// Flag indicating EOF since there isn't one on the handle.
bool myEOF;
int64_t myStartPos;
// Static variable to track whether or not to require the EOF Block
// at the end of the file. If the block is required, but not on the file,
// the constructor fails to open the file.
static bool ourRequireEofBlock;
};
#endif
#endif
|
