Subversion Repositories spk

/*
  these classes define behaviour of bob_dom_o*filestream and
  bob_dom_i*filestream on windows filesystem

  I also wanted to write streams for x2 filesystem (x2fd library) but they
  don't exist now
*/

#ifndef BOB_REALFILE_STREAM_INCLUDED
#define BOB_REALFILE_STREAM_INCLUDED

#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>

/*
        bob_dom_obinaryrealfile - output binary stream (real filesystem files)
        bob_dom_otextrealfile - output text stream (real filesystem files)
*/

template <class Ty>
class owinfilestream : public Ty
{
        private:
                static const size_t buffer_size = 4096;

                int m_fd;
                unsigned char *m_buffer;
                unsigned char *m_bufferPos;
                unsigned char *m_bufferEnd;

                size_t availBuffer() const { return m_bufferEnd - m_bufferPos; }

        public:
                typedef Ty base;
                typedef typename base::state state;
                typedef typename base::size_type size_type;
                typedef typename base::const_value_type_ptr const_value_type_ptr;
                typedef typename const base::value_type const_value_type;

                owinfilestream() 
                { 
                  m_buffer = new unsigned char[buffer_size];
                  m_fd = -1; 
                  m_bufferPos = m_buffer; 
                  m_bufferEnd = m_buffer + buffer_size; 
                  clear();
                }
                
                ~owinfilestream() 
                { 
                  close();
                  delete[] m_buffer;
                }

                static size_type bufferSize() { return buffer_size; }

                void clear(state s = goodbit) { base::clear(s); setstate(m_fd != -1 ? goodbit : badbit); }

                virtual bool open(const char *fileName, filestream::mode m)
                {
                        int f = 0, cf = 0;

                        name(fileName);

                        if((m & filestream::rdonly && m & filestream::create) || (m & filestream::rdonly && m & filestream::rdwr)){
                                clear(failbit);
                                return false;
                        }
                        if(m & filestream::rdonly)
                                f |= _O_RDONLY;
                        else if(m & filestream::rdwr)
                                f |= _O_RDWR;

                        if(m & filestream::create)
                                f |= _O_CREAT | _O_RDWR;

                        m_fd = ::_open(fileName, _O_BINARY | f, _S_IREAD | _S_IWRITE);
                        if(m & filestream::seekeof)
                                _lseek(m_fd, 0, SEEK_END);

                        clear();
                        return m_fd != -1;
                }

                virtual void close()
                {
                  if(m_fd == -1) return;
                  
                        flush();
                        _chsize(m_fd, ::_tell(m_fd));
                        ::_close(m_fd);
                        m_fd = -1;
                        setstate(badbit);
                }

                void flush()
                {
                        if(!good()) return;
                        size_t s = m_bufferPos - m_buffer;
                        if(s == 0) return;
                        if(::_write(m_fd, m_buffer, (unsigned int)s) != (unsigned int)s)
                                setstate(failbit);
                        else
                                m_bufferPos = m_buffer;
                }

                virtual size_type write(const_value_type_ptr data, size_t size)
                {
                        if(!good()) return -1;

                        size_type res = 0;
                        if(size > availBuffer())
                                flush();

                        if(size > availBuffer()){
                                res = ::_write(m_fd, data, (unsigned int)size);
                                if(res != size)
                                        setstate(failbit);
                        }
                        else {
                                memcpy(m_bufferPos, data, size);
                                m_bufferPos += size;
                                res = size;
                        }
                        return res;
                }

                virtual bool put(const_value_type& ch)
                {
                        return write(&ch, 1) > 0;
                }

                virtual size_t tell()
                {
                        size_t pos = ::_tell(m_fd);
                        if(pos >= 0) pos += m_bufferPos - m_buffer;
                        return pos;
                }

                virtual size_t seek(int offset, mystream::stream_base::seek_type origin)
                {
                        int o;
                        size_t res;
                        flush();

                        switch(origin){
                                case mystream::stream_base::seek_begin:
                                        o = SEEK_SET;
                                        break;
                                case mystream::stream_base::seek_end:
                                        o = SEEK_END;
                                        break;
                                case mystream::stream_base::seek_current:
                                        o = SEEK_CUR;
                                        break;
                                default:
                                        o = -1;
                        }
                        res = _lseek(m_fd, offset, o);

                        return res;
                }
};

typedef owinfilestream<obinaryfilestream> obinaryrealfile;
typedef owinfilestream<otextfilestream> otextrealfile;

class iwinfilestream : public ibinaryfilestream
{
        public:
                typedef ibinaryfilestream base;
                typedef base::value_type_ptr value_type_ptr;
                typedef base::value_type value_type;
                typedef base::size_type size_type;
                typedef base::state state;
                typedef base::offset_type offset_type;

        private:
                static const size_t m_bufferSize=5000;
                //static const size_t m_bufferSize=8;

                int m_fd;

                value_type_ptr m_buffer;
                const_value_type_ptr m_bufferEnd;
                const_value_type_ptr m_bufferPos;

                offset_type m_lineEnd;

                bool m_bBufferEOF;

        public:
                static size_type bufferSize() { return m_bufferSize; }

        private:
                size_type bufferAvail() const { return m_bufferEnd - m_bufferPos; }

                size_t fillBuffer()
                {
                        size_t r=(size_t)::_read(m_fd, m_buffer, m_bufferSize);
                        m_bufferEnd=m_buffer + r; // set buffer end
                        m_bufferPos=m_buffer; // buffer pos to beginning
                        m_bBufferEOF=::_eof(m_fd)!=0; // is this the last buffer?
                        return r;
                }

        public:
                iwinfilestream()
                {
                        m_fd=-1; clear(badbit);
                        m_buffer=new value_type[m_bufferSize];
                }

                ~iwinfilestream() { close(); delete m_buffer; }

                void clear(state s=goodbit) { base::clear(s); setstate(m_fd!=-1 ? goodbit : badbit); }

                bool open(const char *fileName, filestream::mode m)
                {
                        int f=0, cf=0;

                        name(fileName);

                        if((m & filestream::rdonly && m & filestream::create) || (m & filestream::rdonly && m & filestream::rdwr)){
                                clear(failbit);
                                return false;
                        }
                        if(m & filestream::rdonly)
                                f|=_O_RDONLY;
                        else if(m & filestream::rdwr)
                                f|=_O_RDWR;

                        if(m & filestream::create)
                                f|=_O_CREAT | _O_RDWR;

                        m_fd=::_open(fileName, _O_BINARY | f, _S_IREAD | _S_IWRITE);
                        clear();

                        if(m & filestream::seekeof)
                                _lseek(m_fd, 0, SEEK_END);

                        m_bufferPos = m_bufferEnd = m_buffer + m_bufferSize;
                        m_bBufferEOF=false;

                        m_lineEnd=0;

                        return m_fd!=-1;
                }

                void close()
                {
                  if(m_fd == -1) return;
                  
                        ::_close(m_fd);
                        m_fd=-1;
                        setstate(badbit);
                }

                bool advance(offset_type off)
                {
                        // offset is in our buffer, just shift the buffer pos
                        if((m_bufferPos + off >= m_buffer) && (m_bufferPos + off <= m_bufferEnd)){
                                m_bufferPos+=off;
                                // our buffer is the last one, if we are at its end we are at eof
                                if(m_bBufferEOF && m_bufferPos==m_bufferEnd)
                                        setstate(eofbit);
                                else
                                        clear((state)(rdstate() & ~eofbit));
                                return true;
                        }
                        // offset is outside our buffer, do a file seek
                        else{
                                // file offset is always at end of our buffer but buffer offset is different
                                // we must adjust the offset to lseek by difference between end of buffer and buffer pos
                                int res=::_lseek(m_fd, off - (long)(m_bufferEnd - m_bufferPos), SEEK_CUR);
                                if(res==-1)
                                        setstate(failbit);
                                else
                                        m_bufferPos=m_bufferEnd; // "erase" the buffer

                                if(::_eof(m_fd))
                                        setstate(eofbit);
                                else
                                        clear((state)(rdstate() & ~eofbit));

                                return res!=-1;
                        }
                }

                size_t tell() const
                {
                        return ::_tell(m_fd) - (m_bufferEnd - m_bufferPos);
                }

                size_type read(value_type_ptr buffer, size_type size)
                {
                        if(eof() && size > 0) setstate(failbit);
                        if(!good()) return -1;

                        // copy everything from our buffer to the out buffer
                        size_t readed=0;
                        size_t s=bufferAvail();
                        if(size < s) s=size;

                        memcpy(buffer, m_bufferPos, s);
                        advance((offset_type)s);
                        size-=s;
                        readed=s;

                        // our buffer doesn't have all the required data - we must read more
                        if(size){
                                // our buffer is not large enough - read the data directly
                                if(size > m_bufferSize){
                                        readed+=(size_t)::_read(m_fd, buffer + s, (unsigned int)size);
                                        m_bufferPos=m_bufferEnd; // this means that our buffer is empty
                                        if(::_eof(m_fd))
                                                setstate(eofbit);
                                        else
                                                clear((state)(rdstate() & ~eofbit));
                                }
                                // read the data to our buffer and copy the required size to out buffer
                                else{
                                        size_t r=fillBuffer();
                                        if(size < r) r=size; // copy the missing data to out buffer
                                        memcpy(buffer + readed, m_bufferPos, r);
                                        readed+=r;
                                        advance((offset_type) r);
                                }
                        }
                        return readed;
                }

                value_type_ptr readln()
                {
                        value_type_ptr buff=0;
                        value_type ch, old;
                        int size;

                        if(!good()) return 0;

                        while(!mystream::stream_base::eof()){
                                if(bufferAvail()==0)
                                        fillBuffer();

                                // 0xD might be followed by 0xA
                                ch=old=*m_bufferPos++;
                                if(ch==0xD || ch==0xA){
                                        size=(offset_type)tell() - m_lineEnd;
                                        advance(-size);
                                        buff=new value_type[size];
                                        read(buff, size);
                                        buff[size-1]=0; // to overwrite line end (0xD or 0xA)

                                        advance(1);
                                        m_lineEnd=(offset_type)tell();

                                        if(ch==0xD){
                                                // we are not at eof
                                                if(!eof()){
                                                        if(bufferAvail()==0) fillBuffer();
                                                        if(*m_bufferPos==0xA){
                                                                advance(1);
                                                                m_lineEnd++;
                                                        }
                                                }
                                        }
                                        break;
                                }
                        }
                        if(buff==0){
                                size=(offset_type)tell() - m_lineEnd;
                                advance(-size);
                                buff=new value_type[size + 1];
                                read(buff, size);
                                buff[size]=0;
                        }

                        return buff;
                }

                value_type_ptr readln2()
                {
                        if(!good()) return 0;

                        if(bufferAvail()==0) fillBuffer();
                        /*
                        value_type *pos;
                        for(pos=m_bufferPos; pos < m_bufferEnd; ++pos){
                                if(*pos==0xD || 0xA){
                                        newLineEnd=tell() + pos;

                                        lseek(m_fd, m_lineEnd, SEEK_SET);
                                        ::read
                                }
                        }*/
                }
};

typedef iwinfilestream ibinaryrealfile;

#endif // !defined(BOB_REALFILE_STREAM_INCLUDED)