libStatGen Software 1
UncompressedFileType Class Reference
Inheritance diagram for UncompressedFileType:
Collaboration diagram for UncompressedFileType:

Public Member Functions

 UncompressedFileType (const char *filename, const char *mode)
 
bool operator== (void *rhs)
 
bool operator!= (void *rhs)
 
int close ()
 
void rewind ()
 
int eof ()
 
virtual bool isOpen ()
 
unsigned int write (const void *buffer, unsigned int size)
 
int read (void *buffer, unsigned int size)
 
virtual int64_t tell ()
 
virtual bool seek (int64_t offset, int origin)
 
- Public Member Functions inherited from FileType
virtual bool operator== (void *rhs)=0
 
virtual bool operator!= (void *rhs)=0
 
virtual int close ()=0
 
virtual void rewind ()=0
 
virtual int eof ()=0
 
virtual bool isOpen ()=0
 
virtual unsigned int write (const void *buffer, unsigned int size)=0
 
virtual int read (void *buffer, unsigned int size)=0
 
virtual int64_t tell ()=0
 
virtual bool seek (int64_t offset, int origin)=0
 
void setBuffered (bool buffered)
 
virtual bool attemptRecoverySync (bool(*checkSignature)(void *data), int length)
 

Protected Attributes

FILE * filePtr
 
knetFilekfilePtr
 
bool keof
 
- Protected Attributes inherited from FileType
bool myUsingBuffer
 

Detailed Description

Definition at line 26 of file UncompressedFileType.h.

Constructor & Destructor Documentation

◆ UncompressedFileType() [1/2]

UncompressedFileType::UncompressedFileType ( )
inline

Definition at line 29 of file UncompressedFileType.h.

30 {
31 filePtr = NULL;
32 kfilePtr = NULL;
33 keof = false;
34 }

◆ ~UncompressedFileType()

virtual UncompressedFileType::~UncompressedFileType ( )
inlinevirtual

Definition at line 36 of file UncompressedFileType.h.

37 {
38 if((filePtr != NULL) || (kfilePtr != NULL))
39 {
40 close();
41 }
42 }

◆ UncompressedFileType() [2/2]

UncompressedFileType::UncompressedFileType ( const char *  filename,
const char *  mode 
)

Definition at line 21 of file UncompressedFileType.cpp.

23 : filePtr(NULL),
24 kfilePtr(NULL),
25 keof(false)
26{
27 // Check if opening for read.
28 if((mode[0] == 'r') || (mode[0] == 'R'))
29 {
30 if(strcmp(filename, "-") == 0)
31 {
32 // read from stdin
33 filePtr = stdin;
34 }
35 else if((strstr(filename, "ftp://") == filename) ||
36 (strstr(filename, "http://") == filename))
37 {
38 // Reading http/ftp, so open the file using knetfile.
39 kfilePtr = knet_open(filename, mode);
40 }
41 else
42 {
43 // Open the file.
44 filePtr = fopen(filename, mode);
45 }
46 }
47 else
48 {
49 // Not for read.
50 // If the file is for write and is '-', then write to stdout.
51 if(((mode[0] == 'w') || (mode[0] == 'W')) &&
52 (strcmp(filename, "-") == 0))
53 {
54 // Write to stdout.
55 filePtr = stdout;
56 }
57 else
58 {
59 // Open the file.
60 filePtr = fopen(filename, mode);
61 }
62 }
63};

Member Function Documentation

◆ close()

int UncompressedFileType::close ( )
inlinevirtual

Implements FileType.

Definition at line 68 of file UncompressedFileType.h.

69 {
70 if(filePtr != NULL)
71 {
72 if((filePtr != stdout) && (filePtr != stdin))
73 {
74 int result = fclose(filePtr);
75 filePtr = NULL;
76 return result;
77 }
78 filePtr = NULL;
79 }
80 else if(kfilePtr != NULL)
81 {
82 int result = knet_close(kfilePtr);
83 kfilePtr = NULL;
84 return result;
85 }
86 return 0;
87 }

◆ eof()

int UncompressedFileType::eof ( )
inlinevirtual

Implements FileType.

Definition at line 105 of file UncompressedFileType.h.

106 {
107 // check the file for eof.
108 if(kfilePtr != NULL)
109 {
110 return(keof);
111 }
112 else
113 {
114 return feof(filePtr);
115 }
116 }

◆ isOpen()

virtual bool UncompressedFileType::isOpen ( )
inlinevirtual

Implements FileType.

Definition at line 119 of file UncompressedFileType.h.

120 {
121 if((filePtr != NULL) || (kfilePtr != NULL))
122 {
123 // filePtr is not null, so the file is open.
124 return(true);
125 }
126 return(false);
127 }

◆ operator!=()

bool UncompressedFileType::operator!= ( void *  rhs)
inlinevirtual

Implements FileType.

Definition at line 56 of file UncompressedFileType.h.

57 {
58 // No two file pointers are the same, so if rhs is not NULL, then
59 // the two pointers are different (true).
60 if (rhs != NULL)
61 return true;
62 // rhs is NULL. They are the different if either filePtr or kfilePtr
63 // are not NULL.
64 return((filePtr != rhs) || (kfilePtr != rhs));
65 }

◆ operator==()

bool UncompressedFileType::operator== ( void *  rhs)
inlinevirtual

Implements FileType.

Definition at line 46 of file UncompressedFileType.h.

47 {
48 // No two file pointers are the same, so if rhs is not NULL, then
49 // the two pointers are different (false).
50 if (rhs != NULL)
51 return false;
52 // rhs is NULL. They are the same if both filePtr & kfilePtr are NULL.
53 return((filePtr == rhs) && (kfilePtr == rhs));
54 }

◆ read()

int UncompressedFileType::read ( void *  buffer,
unsigned int  size 
)
inlinevirtual

Implements FileType.

Definition at line 139 of file UncompressedFileType.h.

140 {
141 if(kfilePtr != NULL)
142 {
143 int bytesRead = knet_read(kfilePtr, buffer, size);
144 if((bytesRead == 0) && (size != 0))
145 {
146 keof = true;
147 }
148 else if((bytesRead != (int)size) && (bytesRead >= 0))
149 {
150 // Less then the requested size was read and an error
151 // was not returned (bgzf_read returns -1 on error).
152 keof = true;
153 }
154 else
155 {
156 keof = false;
157 }
158 return(bytesRead);
159 }
160 return fread(buffer, 1, size, filePtr);
161 }

◆ rewind()

void UncompressedFileType::rewind ( )
inlinevirtual

Implements FileType.

Definition at line 91 of file UncompressedFileType.h.

92 {
93 // Just call rewind to move to the beginning of the file.
94 if(filePtr != NULL)
95 {
96 ::rewind(filePtr);
97 }
98 else if (kfilePtr != NULL)
99 {
100 knet_seek(kfilePtr, 0, SEEK_SET);
101 }
102 }

◆ seek()

virtual bool UncompressedFileType::seek ( int64_t  offset,
int  origin 
)
inlinevirtual

Implements FileType.

Definition at line 183 of file UncompressedFileType.h.

184 {
185 int returnVal = 0;
186 if(kfilePtr != NULL)
187 {
188 returnVal = knet_seek(kfilePtr, offset, origin);
189 keof = false;
190 }
191 else
192 {
193 returnVal = fseek(filePtr, offset, origin);
194 }
195 // Check for success - 0 return value.
196 if (returnVal == 0)
197 {
198 return true;
199 }
200 // Successful.
201 return false;
202 }

◆ tell()

virtual int64_t UncompressedFileType::tell ( )
inlinevirtual

Implements FileType.

Definition at line 166 of file UncompressedFileType.h.

167 {
168 if(kfilePtr != NULL)
169 {
170 return knet_tell(kfilePtr);
171 }
172 return ftell(filePtr);
173 }

◆ write()

unsigned int UncompressedFileType::write ( const void *  buffer,
unsigned int  size 
)
inlinevirtual

Implements FileType.

Definition at line 130 of file UncompressedFileType.h.

131 {
132 // knetfile is never used for writing.
133 return fwrite(buffer, 1, size, filePtr);
134 }

Member Data Documentation

◆ filePtr

FILE* UncompressedFileType::filePtr
protected

Definition at line 207 of file UncompressedFileType.h.

◆ keof

bool UncompressedFileType::keof
protected

Definition at line 209 of file UncompressedFileType.h.

◆ kfilePtr

knetFile* UncompressedFileType::kfilePtr
protected

Definition at line 208 of file UncompressedFileType.h.


The documentation for this class was generated from the following files: