Changeset 1585

Timestamp:

28/04/2007 18:11:36 (21 months ago)

Author:

chris

Message:

Add a stream which provides a source of zero bytes of arbitrary size,
useful for testing support for files over 2GB. (refs #3)

Location:

box/chris/merge/lib/common

Files:

• ZeroStream.cpp (copied) (copied from box/chris/merge/lib/common/BufferedStream.cpp) (13 diffs)
• ZeroStream.h (copied) (copied from box/chris/merge/lib/common/BufferedStream.h) (2 diffs)

box/chris/merge/lib/common/ZeroStream.cpp

@@ -2 +2 @@
 //
 // File
-//              Name:    BufferedStream.cpp
-//              Purpose: Buffering wrapper around IOStreams
-//              Created: 2007/01/16
+//              Name:    ZeroStream.cpp
+//              Purpose: An IOStream which returns all zeroes up to a certain size
+//              Created: 2007/04/28
 //
 // --------------------------------------------------------------------------
 
 #include "Box.h"
-#include "BufferedStream.h"
+#include "ZeroStream.h"
 #include "CommonException.h"
 
@@ -19 +19 @@
 //
 // Function
-//              Name:    BufferedStream::BufferedStream(const char *, int, int)
-//              Purpose: Constructor, set up buffer
-//              Created: 2007/01/16
+//              Name:    ZeroStream::ZeroStream(IOStream::pos_type)
+//              Purpose: Constructor
+//              Created: 2007/04/28
 //
 // --------------------------------------------------------------------------
-BufferedStream::BufferedStream(IOStream& rSource)
-: mrSource(rSource), mBufferSize(0), mBufferPosition(0)
+ZeroStream::ZeroStream(IOStream::pos_type size)
+: mSize(size), mPosition(0)
 { }
 
@@ -32 +32 @@
 //
 // Function
-//              Name:    BufferedStream::Read(void *, int)
+//              Name:    ZeroStream::Read(void *, int)
 //              Purpose: Reads bytes from the file
 //              Created: 2007/01/16
 //
 // --------------------------------------------------------------------------
-int BufferedStream::Read(void *pBuffer, int NBytes, int Timeout)
+int ZeroStream::Read(void *pBuffer, int NBytes, int Timeout)
 {
-        if (mBufferSize == mBufferPosition)
+        ASSERT(NBytes > 0);
+
+        int bytesToRead = NBytes;
+        
+        if (bytesToRead > mSize - mPosition)
         {
-                // buffer is empty, fill it.
-
-                int numBytesRead = mrSource.Read(mBuffer, sizeof(mBuffer), 
-                        Timeout);
-
-                if (numBytesRead < 0)
-                {
-                        return numBytesRead;
-                }
-
-                mBufferSize = numBytesRead;
+                bytesToRead = mSize - mPosition;
         }
 
-        int sizeToReturn = mBufferSize - mBufferPosition;
+        memset(pBuffer, 0, bytesToRead);
+        mPosition += bytesToRead;
 
-        if (sizeToReturn > NBytes)
-        {
-                sizeToReturn = NBytes;
-        }
-
-        memcpy(pBuffer, mBuffer + mBufferPosition, sizeToReturn);
-        mBufferPosition += sizeToReturn;
-
-        if (mBufferPosition == mBufferSize)
-        {
-                // clear out the buffer
-                mBufferSize = 0;
-                mBufferPosition = 0;
-        }
-
-        return sizeToReturn;
+        return bytesToRead;
 }
 
@@ -78 +58 @@
 //
 // Function
-//              Name:    BufferedStream::BytesLeftToRead()
+//              Name:    ZeroStream::BytesLeftToRead()
 //              Purpose: Returns number of bytes to read (may not be most efficient function ever)
 //              Created: 2007/01/16
 //
 // --------------------------------------------------------------------------
-IOStream::pos_type BufferedStream::BytesLeftToRead()
+IOStream::pos_type ZeroStream::BytesLeftToRead()
 {
-        return mrSource.BytesLeftToRead() + mBufferSize - mBufferPosition;
+        return mSize - mPosition;
 }
 
@@ -92 +72 @@
 //
 // Function
-//              Name:    BufferedStream::Write(void *, int)
+//              Name:    ZeroStream::Write(void *, int)
 //              Purpose: Writes bytes to the underlying stream (not supported)
 //              Created: 2003/07/31
 //
 // --------------------------------------------------------------------------
-void BufferedStream::Write(const void *pBuffer, int NBytes)
+void ZeroStream::Write(const void *pBuffer, int NBytes)
 {
         THROW_EXCEPTION(CommonException, NotSupported);
@@ -106 +86 @@
 //
 // Function
-//              Name:    BufferedStream::GetPosition()
+//              Name:    ZeroStream::GetPosition()
 //              Purpose: Get position in stream
 //              Created: 2003/08/21
 //
 // --------------------------------------------------------------------------
-IOStream::pos_type BufferedStream::GetPosition() const
+IOStream::pos_type ZeroStream::GetPosition() const
 {
-        return mrSource.GetPosition() - mBufferSize + mBufferPosition;
+        return mPosition;
 }
 
@@ -120 +100 @@
 //
 // Function
-//              Name:    BufferedStream::Seek(pos_type, int)
+//              Name:    ZeroStream::Seek(pos_type, int)
 //              Purpose: Seeks within file, as lseek, invalidate buffer
 //              Created: 2003/07/31
 //
 // --------------------------------------------------------------------------
-void BufferedStream::Seek(IOStream::pos_type Offset, int SeekType)
+void ZeroStream::Seek(IOStream::pos_type Offset, int SeekType)
 {
         switch (SeekType)
@@ -131 +111 @@
                 case SeekType_Absolute:
                 {
-                        // just go there
-                        mrSource.Seek(Offset, SeekType);
+                        mPosition = Offset;
                 }
                 break;
@@ -138 +117 @@
                 case SeekType_Relative:
                 {
-                        // Actual underlying file position is 
-                        // (mBufferSize - mBufferPosition) ahead of us.
-                        // Need to subtract that amount from the seek
-                        // to seek forward that much less, putting the 
-                        // real pointer in the right place.
-                        mrSource.Seek(Offset - mBufferSize + mBufferPosition, 
-                                SeekType);
+                        mPosition += Offset;
                 }
                 break;
@@ -150 +123 @@
                 case SeekType_End:
                 {
-                        // Actual underlying file position is 
-                        // (mBufferSize - mBufferPosition) ahead of us.
-                        // Need to add that amount to the seek
-                        // to seek backwards that much more, putting the 
-                        // real pointer in the right place.
-                        mrSource.Seek(Offset + mBufferSize - mBufferPosition, 
-                                SeekType);
+                        mPosition = mSize - Offset;
                 }
         }
-
-        // always clear the buffer for now (may be slightly wasteful)
-        mBufferSize = 0;
-        mBufferPosition = 0;
 }
 
@@ -169 +132 @@
 //
 // Function
-//              Name:    BufferedStream::Close()
+//              Name:    ZeroStream::Close()
 //              Purpose: Closes the underlying stream (not needed)
 //              Created: 2003/07/31
 //
 // --------------------------------------------------------------------------
-void BufferedStream::Close()
+void ZeroStream::Close()
 {
         THROW_EXCEPTION(CommonException, NotSupported);
@@ -183 +146 @@
 //
 // Function
-//              Name:    BufferedStream::StreamDataLeft()
+//              Name:    ZeroStream::StreamDataLeft()
 //              Purpose: Any data left to write?
 //              Created: 2003/08/02
 //
 // --------------------------------------------------------------------------
-bool BufferedStream::StreamDataLeft()
+bool ZeroStream::StreamDataLeft()
 {
-        return mrSource.StreamDataLeft();
+        return false;
 }
 
@@ -196 +159 @@
 //
 // Function
-//              Name:    BufferedStream::StreamClosed()
+//              Name:    ZeroStream::StreamClosed()
 //              Purpose: Is the stream closed?
 //              Created: 2003/08/02
 //
 // --------------------------------------------------------------------------
-bool BufferedStream::StreamClosed()
+bool ZeroStream::StreamClosed()
 {
-        return mrSource.StreamClosed();
+        return false;
 }
 

box/chris/merge/lib/common/ZeroStream.h

@@ -2 +2 @@
 //
 // File
-//              Name:    BufferedStream.h
-//              Purpose: Buffering wrapper around IOStreams
-//              Created: 2007/01/16
+//              Name:    ZeroStream.h
+//              Purpose: An IOStream which returns all zeroes up to a certain size
+//              Created: 2007/04/28
 //
 // --------------------------------------------------------------------------
 
-#ifndef BUFFEREDSTREAM__H
-#define BUFFEREDSTREAM__H
+#ifndef ZEROSTREAM__H
+#define ZEROSTREAM__H
 
 #include "IOStream.h"
 
-class BufferedStream : public IOStream
+class ZeroStream : public IOStream
 {
 private:
-        IOStream& mrSource;
-        char mBuffer[4096];
-        int  mBufferSize;
-        int  mBufferPosition;
+        IOStream::pos_type mSize, mPosition;
 
 public:
-        BufferedStream(IOStream& rSource);
+        ZeroStream(IOStream::pos_type mSize);
         
         virtual int Read(void *pBuffer, int NBytes, int Timeout = IOStream::TimeOutInfinite);
@@ -35 +32 @@
 
 private:
-        BufferedStream(const BufferedStream &rToCopy) 
-        : mrSource(rToCopy.mrSource) { /* do not call */ }
+        ZeroStream(const ZeroStream &rToCopy);
 };
 
-#endif // BUFFEREDSTREAM__H
+#endif // ZEROSTREAM__H