InputFile Class Reference

Class for easily reading/writing files without having to worry about file type (uncompressed, gzip, bgzf) when reading. More...

#include <InputFile.h>

Collaboration diagram for InputFile:

[legend]

List of all members.

Public Types
enum	ifileCompression { DEFAULT, UNCOMPRESSED, GZIP, BGZF }
	Compression to use when writing a file & decompression used when reading a file from stdin. More...
Public Member Functions
	InputFile ()
	Default constructor.
	~InputFile ()
	Destructor.
	InputFile (const char *filename, const char *mode, InputFile::ifileCompression compressionMode=InputFile::DEFAULT)
	Constructor for opening a file.
void	bufferReads (unsigned int bufferSize=DEFAULT_BUFFER_SIZE)
	Set the buffer size for reading from files so that bufferSize bytes are read at a time and stored until accessed by another read call.
void	disableBuffering ()
	Disable read buffering.
int	ifclose ()
	Close the file.
int	ifread (void *buffer, unsigned int size)
	Read size bytes from the file into the buffer.
int	ifgetc ()
	Get a character from the file.
void	ifrewind ()
	Reset to the beginning of the file.
int	ifeof ()
	Check to see if we have reached the EOF.
unsigned int	ifwrite (const void *buffer, unsigned int size)
	Write the specified buffer into the file.
bool	isOpen ()
	Returns whether or not the file was successfully opened.
long int	iftell ()
	Get current position in the file.
bool	ifseek (long int offset, int origin)
	Seek to the specified offset from the origin.
const char *	getFileName () const
	Get the filename that is currently opened.
Protected Member Functions
bool	openFile (const char *filename, const char *mode, InputFile::ifileCompression compressionMode)
int	readFromFile (void *buffer, unsigned int size)
Protected Attributes
FileType *	myFileTypePtr
unsigned int	myAllocatedBufferSize
char *	myFileBuffer
unsigned int	myBufferIndex
unsigned int	myCurrentBufferSize
std::string	myFileName
Static Protected Attributes
static const unsigned int	DEFAULT_BUFFER_SIZE = 1048576

---

Detailed Description

Class for easily reading/writing files without having to worry about file type (uncompressed, gzip, bgzf) when reading.

Definition at line 35 of file InputFile.h.

---

Member Enumeration Documentation

enum InputFile::ifileCompression

Compression to use when writing a file & decompression used when reading a file from stdin.

Any other read checks the file to determine how to uncompress it.

Enumerator:

DEFAULT	Check the extension, if it is ".gz", treat as gzip, otherwise treat it as UNCOMPRESSED.
UNCOMPRESSED	uncompressed file.
GZIP	gzip file.
BGZF	bgzf file.

Definition at line 42 of file InputFile.h.

                          {
        DEFAULT,  ///< Check the extension, if it is ".gz", treat as gzip, otherwise treat it as UNCOMPRESSED.
        UNCOMPRESSED,  ///< uncompressed file.
        GZIP,  ///< gzip file.
        BGZF ///< bgzf file.
    };

---

Constructor & Destructor Documentation

InputFile::InputFile	(	const char *	filename,
		const char *	mode,
		InputFile::ifileCompression	compressionMode = InputFile::DEFAULT
	)

Constructor for opening a file.

Parameters:

	filename	file to open
	mode	same format as fopen: "r" for read & "w" for write.
	compressionMode	set the type of file to open for writing or for reading from stdin (when reading files, the compression type is determined by reading the file).

Definition at line 27 of file InputFile.cpp.

{
    myFileTypePtr = NULL;
    myBufferIndex = 0;
    myCurrentBufferSize = 0;
    myAllocatedBufferSize = DEFAULT_BUFFER_SIZE;
    myFileBuffer = new char[myAllocatedBufferSize];
    myFileName.clear();

    openFile(filename, mode, compressionMode);
}

---

Member Function Documentation

void InputFile::bufferReads

(

unsigned int

bufferSize = DEFAULT_BUFFER_SIZE

)

[inline]

Set the buffer size for reading from files so that bufferSize bytes are read at a time and stored until accessed by another read call.

This improves performance over reading the file small bits at a time. Buffering reads disables the tell call for bgzf files. Any previous values in the buffer will be deleted.

Parameters:

bufferSize

number of bytes to read/buffer at a time, default buffer size is 1048576, and turn off read buffering by setting bufferSize = 1;

Definition at line 81 of file InputFile.h.

Referenced by disableBuffering().

    {
        // If the buffer size is the same, do nothing.
        if(bufferSize == myAllocatedBufferSize)
        {
            return;
        }
        // Delete the previous buffer.
        if(myFileBuffer != NULL)
        {
            delete[] myFileBuffer;
        }
        myBufferIndex = 0;
        myCurrentBufferSize = 0;
        // The buffer size must be at least 1 so one character can be
        // read and ifgetc can just assume reading into the buffer.
        if(bufferSize < 1)
        {
            bufferSize = 1;
        }
        myFileBuffer = new char[bufferSize];
        myAllocatedBufferSize = bufferSize;

        if(myFileTypePtr != NULL)
        {
            if(bufferSize == 1)
            {
                myFileTypePtr->setBuffered(false);
            }
            else
            {
                myFileTypePtr->setBuffered(true);
            }
        }
    }

const char* InputFile::getFileName

(

)

const [inline]

Get the filename that is currently opened.

Returns:

filename associated with this class

Definition at line 341 of file InputFile.h.

Referenced by SamFile::ReadBamIndex().

    {
        return(myFileName.c_str());
    }

int InputFile::ifclose

(

)

[inline]

Close the file.

Returns:

status of the close (0 is success).

Definition at line 131 of file InputFile.h.

Referenced by ifclose().

    {
        if (myFileTypePtr == NULL)
        {
            return EOF;
        }
        int result = myFileTypePtr->close();
        delete myFileTypePtr;
        myFileTypePtr = NULL;
        myFileName.clear();
        return result;
    }

int InputFile::ifeof

(

)

[inline]

Check to see if we have reached the EOF.

Returns:

0 if not EOF, any other value means EOF.

Definition at line 257 of file InputFile.h.

Referenced by ifeof().

    {
        // Not EOF if we are not at the end of the buffer.
        if (myBufferIndex < myCurrentBufferSize)
        {
            // There are still available bytes in the buffer, so NOT EOF.
            return false;
        }
        else
        {
            if (myFileTypePtr == NULL)
            {
                // No myFileTypePtr, so not eof (return 0).
                return 0;
            }
            // exhausted our buffer, so check the file for eof.
            return myFileTypePtr->eof();
        }
    }

int InputFile::ifgetc

(

)

[inline]

Get a character from the file.

Read a character from the internal buffer, or if the end of the buffer has been reached, read from the file into the buffer and return index 0.

Returns:

character that was read or EOF.

Definition at line 221 of file InputFile.h.

Referenced by ifgetc(), and operator>>().

    {
        if (myBufferIndex >= myCurrentBufferSize)
        {
            // at the last index, read a new buffer.
            myCurrentBufferSize = readFromFile(myFileBuffer, myAllocatedBufferSize);
            myBufferIndex = 0;
        }
        // If the buffer index is still greater than or equal to the
        // myCurrentBufferSize, then we failed to read the file - return EOF.
        if (myBufferIndex >= myCurrentBufferSize)
        {
            return(EOF);
        }
        return(myFileBuffer[myBufferIndex++]);
    }

int InputFile::ifread	(	void *	buffer,
		unsigned int	size
	)			[inline]

Read size bytes from the file into the buffer.

Parameters:

	buffer	pointer to memory at least size bytes big to write the data into.
	size	number of bytes to be read

Returns:

number of bytes read

Definition at line 149 of file InputFile.h.

Referenced by ifread().

    {
        // There are 2 cases:
        //  1) There are already size available bytes in buffer.
        //  2) There are not size bytes in buffer.

        // Determine the number of available bytes in the buffer.
        unsigned int availableBytes = myCurrentBufferSize - myBufferIndex;
        unsigned int returnSize = 0;

        // Case 1: There are already size available bytes in buffer.
        if (size <= availableBytes)
        {
            //   Just copy from the buffer, increment the index and return.
            memcpy(buffer, myFileBuffer+myBufferIndex, size);
            // Increment the buffer index.
            myBufferIndex += size;
            returnSize = size;
        }
        // Case 2: There are not size bytes in buffer.
        else
        {
            // Check to see if there are some bytes in the buffer.
            if (availableBytes > 0)
            {
                // Size > availableBytes > 0
                // Copy the available bytes into the buffer.
                memcpy(buffer, myFileBuffer+myBufferIndex, availableBytes);
            }
            unsigned int remainingSize = size - availableBytes;

            // Check if the remaining size is more or less than the
            // max buffer size.
            if(remainingSize < myAllocatedBufferSize)
            {
                // the remaining size is not the full buffer, but read
                //  a full buffer worth of data anyway.
                myCurrentBufferSize =
                    readFromFile(myFileBuffer, myAllocatedBufferSize);
                
                // Check to see how much was copied.
                unsigned int copySize = remainingSize;
                if(copySize > myCurrentBufferSize)
                {
                    copySize = myCurrentBufferSize;
                }

                // Now copy the rest of the bytes into the buffer.
                memcpy((char*)buffer+availableBytes, myFileBuffer, copySize);

                // set the buffer index to the location after what we read.
                myBufferIndex = copySize;
                
                returnSize = availableBytes + copySize;
            }
            else
            {
                // More remaining to be read than the max buffer size, so just
                // read directly into the output buffer.
                int readSize = readFromFile((char*)buffer + availableBytes,
                                            remainingSize);
                returnSize = readSize + availableBytes;
            }
        }
        return(returnSize);
    }

bool InputFile::ifseek	(	long int	offset,
		int	origin
	)			[inline]

Seek to the specified offset from the origin.

Parameters:

	offset	offset into the file to move to (must be from a tell call)
	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.

Definition at line 326 of file InputFile.h.

Referenced by ifseek().

    {
        if (myFileTypePtr == NULL)
        {
            // No myFileTypePtr, so return false - could not seek.
            return false;
        }
        // Reset buffering since a seek is being done.
        myBufferIndex = 0;
        myCurrentBufferSize = 0;
        return myFileTypePtr->seek(offset, origin);
    }

long int InputFile::iftell

(

)

[inline]

Get current position in the file.

Returns:

current position in the file, -1 indicates an error.

Definition at line 307 of file InputFile.h.

Referenced by iftell().

    {
        if (myFileTypePtr == NULL)
        {
            // No myFileTypePtr, so return false - could not seek.
            return -1;
        }
        return myFileTypePtr->tell();
    }

unsigned int InputFile::ifwrite	(	const void *	buffer,
		unsigned int	size
	)			[inline]

Write the specified buffer into the file.

Parameters:

	buffer	buffer containing size bytes to write to the file.
	size	number of bytes to write

Returns:

number of bytes written We do not buffer the write call, so just leave this as normal.

Definition at line 282 of file InputFile.h.

Referenced by ifwrite().

    {
        if (myFileTypePtr == NULL)
        {
            // No myFileTypePtr, so return 0 - nothing written.
            return 0;
        }
        return myFileTypePtr->write(buffer, size);
    }

bool InputFile::isOpen

(

)

[inline]

Returns whether or not the file was successfully opened.

Returns:

true if the file is open, false if not.

Definition at line 294 of file InputFile.h.

Referenced by ifopen(), GlfHeader::read(), SamRecord::setBufferFromFile(), GlfHeader::write(), and SamRecord::writeRecordBuffer().

    {
        // It is open if the myFileTypePtr is set and says it is open.
        if ((myFileTypePtr != NULL) && myFileTypePtr->isOpen())
        {
            return true;
        }
        // File was not successfully opened.
        return false;
    }

---

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

• lib/general/InputFile.h
• lib/general/InputFile.cpp