---

BufferedFile.C

Go to the documentation of this file.

#include "BufferedFile.h"
#ifndef BUFFEREDFILEFACTORY_H
#include "BufferedFileFactory.h"
#endif

#define TIMETOWAIT 1000

extern int write(int fd,void * data, int size);
BufferedFile::BufferedFile(int fdesc)  {
        pushBackBlocks = list<CharAndSize *>();
        this->fd = fdesc;       
        parent = NULL;
        preadReady = false;
        pwriteReady = false;
        hasRead = false;
        hasWritten  = false;
        reading = writing = true;
        timeToWait = TIMETOWAIT;
}
BufferedFile::BufferedFile()  {
        parent = NULL;
        pushBackBlocks = list<CharAndSize *>();
        preadReady = false;
        pwriteReady = false;
        reading = writing = true;
        timeToWait = TIMETOWAIT;
}
void BufferedFile::setBufferedFileFactory(void * p) {
        parent = p;
}

int BufferedFile::Write(const char * data,int size) {
        hasWritten = true;
        return write(fd,(const void *)data, size);
        //i = write(this->fd,(void *)data, sizeof(char)*size);
        //return (int)i;
}
BufferedFile::~BufferedFile() {
        //cerr << "~BufferedFile\n";
        list<CharAndSize *>::iterator iter = pushBackBlocks.begin();
        while (iter != pushBackBlocks.end()) {
        //for (iter = pushBackBlocks.begin(); iter < pushBackBlocks.end(); iter++) {
                delete [] (*iter)->data;
                delete (*iter);
                iter++;
        }
        if (fd) {
                close(fd);
        }
}
void BufferedFile::pushBack(char * data,int size) {
        struct CharAndSize * c = new CharAndSize();
        c->data = data;
        c->size = size;
        c->alreadyRead = 0;
        pushBackBlocks.push_front(c);
}
int BufferedFile::Read(char * data, int size) {
        hasRead = true; //Read was called.
        int index = 0;
        if (!pushBackBlocks.empty()) {
                int si = 0;
                int sar = 0;
                int min = 0;
                int alr = 0;
                //list<CharAndSize *>::iterator iter;
                while (!pushBackBlocks.empty()) {
                        CharAndSize * block = *(pushBackBlocks.begin());
                        pushBackBlocks.pop_front();
                        si = size-index; //bytes left to read
                        min = si; 
                        alr = block->alreadyRead; //already read bytes
                        sar = (block->size) - alr; //bytes left in this block
                        if (sar < min) { sar = min; }
                        for (int i = 0; i < min; i++) {
                                data[index+i] = block->data[alr+i];
                        }
                        //if (sar > si) { //We haven't read enough of a block to count!
                        if (sar > si) { //We haven't read enough of a block to count!
                                        //Case 1 we aren't done with this
                                        //block
                                block->alreadyRead+=min;
                                pushBackBlocks.push_front(block);
                                return size;
                        } else if ( sar == si  ) { //We have read all we need to read!
                                                   //Case2 The block is all we
                                                   //needed!
                                delete [] block->data;
                                block->data = NULL;
                                delete block;
                                return size;
                        } else if (sar < si) { //We need more blocks
                                delete [] block->data;
                                block->data = NULL;
                                delete block;
                                index+=sar;
                        }
                }
        }
        if (index >= size) {
                return size;
        }
        int total = read(fd,(void *)(data+index), sizeof(char)*(size-index));
        if (index) {
                return total + index;
        } else {
                return total;
        }
}
//bool BufferedFile::readReady() {return ready(0);}
//bool BufferedFile::writeReady() {return ready(1);}
bool BufferedFile::readReady() {return preadReady;}
bool BufferedFile::writeReady() {return pwriteReady;}

void BufferedFile::Close() {
        if (parent!=NULL) {
                ((BufferedFileFactory*)parent)->closeFile(this);
        }
        parent = NULL;
        if (fd > 0) {
                close(fd);
                fd = 0;
        }
}

bool BufferedFile::ready(int rw) {
        if (pushBackBlocks.size() > 0) {
                return true;
        }
        fd_set tmp_set;
        FD_ZERO (&tmp_set);
        FD_SET (fd, &tmp_set);
        struct timeval tv;
        tv.tv_sec = 0;
        tv.tv_usec = timeToWait; 
        int currCount;
        if (!rw) {
                currCount = select(fd+1, &tmp_set, NULL, NULL, &tv);
        } else {
                currCount = select(fd+1 ,NULL, &tmp_set,  NULL, &tv);
        }
        return (currCount > 0);
}
void BufferedFile::setWait(int w) {
        timeToWait = w;
}
int BufferedFile::getWait() {
        return timeToWait;
}
int BufferedFile::getFileHandle() {
        return fd;
}
void BufferedFile::setWriteReady(bool b) {
        pwriteReady = b;
        hasWritten = false;
}
void BufferedFile::setReadReady(bool b) {
        preadReady = b;
        hasRead = false;
}
void BufferedFile::setWriteOnly() {
        reading = false;
        writing = true;
        setParentRW();
}
void BufferedFile::setParentRW() {
        if (parent!=NULL) {
                ((BufferedFileFactory*)parent)->setBufferedFileWrite(this,writing);
                ((BufferedFileFactory*)parent)->setBufferedFileRead(this,reading);
        }
}
void BufferedFile::setReadOnly() {
        reading = true;
        writing = false;
        setParentRW();
}
void BufferedFile::setReadWrite() {
        reading = true;
        writing = true;
        setParentRW();
}
bool BufferedFile::doesRead() {
        return reading;
}
bool BufferedFile::doesWrite() {
        return writing;
}
bool BufferedFile::hasBeenWritten() {
        return hasWritten;
}
bool BufferedFile::hasBeenRead() {
        return hasRead;
}

---