gecko-dev/xpcom/io/nsStorageStream.cpp

528 строки
15 KiB
C++
Исходник Обычный вид История

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998-1999 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
* Pierre Phaneuf <pp@ludusdesign.com>
*/
/*
* The storage stream provides an internal buffer that can be filled by a
* client using a single output stream. One or more independent input streams
* can be created to read the data out non-destructively. The implementation
* uses a segmented buffer internally to avoid realloc'ing of large buffers,
* with the attendant performance loss and heap fragmentation.
*/
#include "nsStorageStream.h"
#include "nsSegmentedBuffer.h"
#include "nsCOMPtr.h"
#include "prbit.h"
#include "nsIInputStream.h"
#include "prlog.h"
#if defined(PR_LOGGING)
//
// Log module for StorageStream logging...
//
// To enable logging (see prlog.h for full details):
//
// set NSPR_LOG_MODULES=StorageStreamLog:5
// set NSPR_LOG_FILE=nspr.log
//
// this enables PR_LOG_DEBUG level information and places all output in
// the file nspr.log
//
PRLogModuleInfo* StorageStreamLog = nsnull;
#endif /* PR_LOGGING */
nsStorageStream::nsStorageStream()
: mSegmentedBuffer(0), mSegmentSize(0), mWriteInProgress(PR_FALSE),
1999-11-18 09:59:28 +03:00
mLastSegmentNum(-1), mWriteCursor(0), mSegmentEnd(0), mLogicalLength(0)
{
NS_INIT_REFCNT();
#if defined(PR_LOGGING)
//
// Initialize the global PRLogModule for socket transport logging
// if necessary...
//
if (nsnull == StorageStreamLog) {
StorageStreamLog = PR_NewLogModule("StorageStreamLog");
}
#endif /* PR_LOGGING */
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("Creating nsStorageStream [%x].\n", this));
}
nsStorageStream::~nsStorageStream()
{
if (mSegmentedBuffer)
delete mSegmentedBuffer;
}
NS_IMPL_THREADSAFE_ISUPPORTS2(nsStorageStream,
nsIStorageStream,
nsIOutputStream)
NS_IMETHODIMP
nsStorageStream::Init(PRUint32 segmentSize, PRUint32 maxSize,
nsIMemory *segmentAllocator)
{
mSegmentedBuffer = new nsSegmentedBuffer();
if (!mSegmentedBuffer)
return NS_ERROR_OUT_OF_MEMORY;
mSegmentSize = segmentSize;
mSegmentSizeLog2 = PR_FloorLog2(segmentSize);
// Segment size must be a power of two
if (mSegmentSize != ((PRUint32)1 << mSegmentSizeLog2))
return NS_ERROR_INVALID_ARG;
return mSegmentedBuffer->Init(segmentSize, maxSize, segmentAllocator);
}
NS_IMETHODIMP
nsStorageStream::GetOutputStream(PRInt32 aStartingOffset,
nsIOutputStream * *aOutputStream)
{
NS_ENSURE_ARG(aOutputStream);
if (mWriteInProgress)
return NS_ERROR_NOT_AVAILABLE;
nsresult rv = Seek(aStartingOffset);
if (NS_FAILED(rv)) return rv;
// Enlarge the last segment in the buffer so that it is the same size as
// all the other segments in the buffer. (It may have been realloc'ed
// smaller in the Close() method.)
if (mLastSegmentNum >= 0)
mSegmentedBuffer->ReallocLastSegment(mSegmentSize);
// Need to re-Seek, since realloc might have changed segment base pointer
rv = Seek(aStartingOffset);
if (NS_FAILED(rv)) return rv;
NS_ADDREF(this);
*aOutputStream = NS_STATIC_CAST(nsIOutputStream*, this);
mWriteInProgress = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP
nsStorageStream::Close()
{
mWriteInProgress = PR_FALSE;
PRInt32 segmentOffset = SegOffset(mLogicalLength);
// Shrink the final segment in the segmented buffer to the minimum size
// needed to contain the data, so as to conserve memory.
if (segmentOffset)
mSegmentedBuffer->ReallocLastSegment(segmentOffset);
mWriteCursor = 0;
mSegmentEnd = 0;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Close mWriteCursor=%x mSegmentEnd=%x\n",
this, mWriteCursor, mSegmentEnd));
return NS_OK;
}
NS_IMETHODIMP
nsStorageStream::Flush()
{
return NS_OK;
}
NS_IMETHODIMP
nsStorageStream::Write(const char *aBuffer, PRUint32 aCount, PRUint32 *aNumWritten)
{
const char* readCursor;
PRUint32 count, availableInSegment, remaining;
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER(aNumWritten);
NS_ENSURE_ARG(aBuffer);
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Write mWriteCursor=%x mSegmentEnd=%x aCount=%d\n",
this, mWriteCursor, mSegmentEnd, aCount));
remaining = aCount;
readCursor = aBuffer;
while (remaining) {
availableInSegment = mSegmentEnd - mWriteCursor;
if (!availableInSegment) {
mWriteCursor = mSegmentedBuffer->AppendNewSegment();
if (!mWriteCursor) {
mSegmentEnd = 0;
rv = NS_ERROR_OUT_OF_MEMORY;
goto out;
}
mLastSegmentNum++;
mSegmentEnd = mWriteCursor + mSegmentSize;
availableInSegment = mSegmentEnd - mWriteCursor;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Write (new seg) mWriteCursor=%x mSegmentEnd=%x\n",
this, mWriteCursor, mSegmentEnd));
}
count = PR_MIN(availableInSegment, remaining);
memcpy(mWriteCursor, readCursor, count);
remaining -= count;
readCursor += count;
mWriteCursor += count;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Writing mWriteCursor=%x mSegmentEnd=%x count=%d\n",
this, mWriteCursor, mSegmentEnd, count));
};
out:
*aNumWritten = aCount - remaining;
mLogicalLength += *aNumWritten;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Wrote mWriteCursor=%x mSegmentEnd=%x numWritten=%d\n",
this, mWriteCursor, mSegmentEnd, *aNumWritten));
return rv;
}
NS_IMETHODIMP
nsStorageStream::WriteFrom(nsIInputStream *inStr, PRUint32 count, PRUint32 *_retval)
{
NS_NOTREACHED("WriteFrom");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval)
{
NS_NOTREACHED("WriteSegments");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::GetNonBlocking(PRBool *aNonBlocking)
{
NS_NOTREACHED("GetNonBlocking");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::SetNonBlocking(PRBool aNonBlocking)
{
NS_NOTREACHED("SetNonBlocking");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::GetObserver(nsIOutputStreamObserver * *aObserver)
{
NS_NOTREACHED("GetObserver");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::SetObserver(nsIOutputStreamObserver * aObserver)
{
NS_NOTREACHED("SetObserver");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageStream::GetLength(PRUint32 *aLength)
{
NS_ENSURE_ARG(aLength);
*aLength = mLogicalLength;
return NS_OK;
}
// Truncate the buffer by deleting the end segments
NS_IMETHODIMP
nsStorageStream::SetLength(PRUint32 aLength)
{
if (mWriteInProgress)
return NS_ERROR_NOT_AVAILABLE;
if (aLength > mLogicalLength)
return NS_ERROR_INVALID_ARG;
PRInt32 newLastSegmentNum = SegNum(aLength);
PRInt32 segmentOffset = SegOffset(aLength);
if (segmentOffset == 0)
newLastSegmentNum--;
while (newLastSegmentNum < mLastSegmentNum) {
mSegmentedBuffer->DeleteLastSegment();
mLastSegmentNum--;
}
mLogicalLength = aLength;
return NS_OK;
}
NS_IMETHODIMP
nsStorageStream::GetWriteInProgress(PRBool *aWriteInProgress)
{
NS_ENSURE_ARG(aWriteInProgress);
*aWriteInProgress = mWriteInProgress;
return NS_OK;
}
NS_METHOD
nsStorageStream::Seek(PRInt32 aPosition)
{
// An argument of -1 means "seek to end of stream"
if (aPosition == -1)
aPosition = mLogicalLength;
// Seeking beyond the buffer end is illegal
if ((PRUint32)aPosition > mLogicalLength)
return NS_ERROR_INVALID_ARG;
// Seeking backwards in the write stream results in truncation
SetLength(aPosition);
// Special handling for seek to start-of-buffer
if (aPosition == 0) {
mWriteCursor = 0;
mSegmentEnd = 0;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Seek mWriteCursor=%x mSegmentEnd=%x\n",
this, mWriteCursor, mSegmentEnd));
return NS_OK;
}
// Segment may have changed, so reset pointers
mWriteCursor = mSegmentedBuffer->GetSegment(mLastSegmentNum);
NS_ASSERTION(mWriteCursor, "null mWriteCursor");
mSegmentEnd = mWriteCursor + mSegmentSize;
PRInt32 segmentOffset = SegOffset(aPosition);
mWriteCursor += segmentOffset;
PR_LOG(StorageStreamLog, PR_LOG_DEBUG,
("nsStorageStream [%x] Seek mWriteCursor=%x mSegmentEnd=%x\n",
this, mWriteCursor, mSegmentEnd));
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// There can be many nsStorageInputStreams for a single nsStorageStream
class nsStorageInputStream : public nsIInputStream
{
public:
nsStorageInputStream(nsStorageStream *aStorageStream, PRUint32 aSegmentSize)
: mStorageStream(aStorageStream), mReadCursor(0),
1999-11-18 06:38:32 +03:00
mSegmentEnd(0), mSegmentNum(0),
mSegmentSize(aSegmentSize), mLogicalCursor(0)
{
NS_ADDREF(mStorageStream);
NS_INIT_REFCNT();
}
virtual ~nsStorageInputStream()
{
NS_IF_RELEASE(mStorageStream);
}
NS_DECL_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
protected:
NS_METHOD Seek(PRUint32 aPosition);
friend class nsStorageStream;
private:
1999-11-18 06:38:32 +03:00
nsStorageStream* mStorageStream;
const char* mReadCursor; // Next memory location to read byte, or NULL
const char* mSegmentEnd; // One byte past end of current buffer segment
PRUint32 mSegmentNum; // Segment number containing read cursor
PRUint32 mSegmentSize; // All segments, except the last, are of this size
PRUint32 mLogicalCursor; // Logical offset into stream
PRUint32 SegNum(PRUint32 aPosition) {return aPosition >> mStorageStream->mSegmentSizeLog2;}
PRUint32 SegOffset(PRUint32 aPosition) {return aPosition & (mSegmentSize - 1);}
};
NS_IMPL_THREADSAFE_ISUPPORTS1(nsStorageInputStream, nsIInputStream)
NS_IMETHODIMP
nsStorageStream::NewInputStream(PRInt32 aStartingOffset, nsIInputStream* *aInputStream)
{
nsStorageInputStream *inputStream = new nsStorageInputStream(this, mSegmentSize);
if (!inputStream)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(inputStream);
if (aStartingOffset) {
nsresult rv = inputStream->Seek(aStartingOffset);
if (NS_FAILED(rv)) {
NS_RELEASE(inputStream);
return rv;
}
}
*aInputStream = inputStream;
return NS_OK;
}
NS_IMETHODIMP
nsStorageInputStream::Close()
{
return NS_OK;
}
NS_IMETHODIMP
nsStorageInputStream::Available(PRUint32 *aAvailable)
{
*aAvailable = mStorageStream->mLogicalLength - mLogicalCursor;
return NS_OK;
}
NS_IMETHODIMP
nsStorageInputStream::Read(char* aBuffer, PRUint32 aCount, PRUint32 *aNumRead)
{
char* writeCursor;
PRUint32 count, availableInSegment, remainingCapacity;
remainingCapacity = aCount;
writeCursor = aBuffer;
while (remainingCapacity) {
1999-11-21 10:58:53 +03:00
availableInSegment = mSegmentEnd - mReadCursor;
if (!availableInSegment) {
PRUint32 available = mStorageStream->mLogicalLength - mLogicalCursor;
if (!available)
goto out;
1999-11-21 10:58:53 +03:00
mReadCursor = mStorageStream->mSegmentedBuffer->GetSegment(mSegmentNum++);
mSegmentEnd = mReadCursor + PR_MIN(mSegmentSize, available);
}
1999-11-21 10:58:53 +03:00
count = PR_MIN(availableInSegment, remainingCapacity);
memcpy(writeCursor, mReadCursor, count);
remainingCapacity -= count;
mReadCursor += count;
writeCursor += count;
mLogicalCursor += count;
};
out:
*aNumRead = aCount - remainingCapacity;
if (*aNumRead == 0)
return NS_BASE_STREAM_WOULD_BLOCK;
else
return NS_OK;
}
NS_IMETHODIMP
nsStorageInputStream::ReadSegments(nsWriteSegmentFun writer, void * closure, PRUint32 aCount, PRUint32 *aNumRead)
{
PRUint32 count, availableInSegment, remainingCapacity, bytesConsumed;
remainingCapacity = aCount;
while (remainingCapacity) {
availableInSegment = mSegmentEnd - mReadCursor;
if (!availableInSegment) {
PRUint32 available = mStorageStream->mLogicalLength - mLogicalCursor;
if (!available)
goto out;
mReadCursor = mStorageStream->mSegmentedBuffer->GetSegment(mSegmentNum++);
mSegmentEnd = mReadCursor + PR_MIN(mSegmentSize, available);
}
count = PR_MIN(availableInSegment, remainingCapacity);
writer(this, closure, mReadCursor, mLogicalCursor, count, &bytesConsumed);
remainingCapacity -= bytesConsumed;
mReadCursor += bytesConsumed;
mLogicalCursor += bytesConsumed;
};
out:
*aNumRead = aCount - remainingCapacity;
if (*aNumRead == 0)
return NS_BASE_STREAM_WOULD_BLOCK;
else
return NS_OK;
}
NS_IMETHODIMP
nsStorageInputStream::GetNonBlocking(PRBool *aNonBlocking)
{
NS_NOTREACHED("GetNonBlocking");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageInputStream::GetObserver(nsIInputStreamObserver * *aObserver)
{
NS_NOTREACHED("GetObserver");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsStorageInputStream::SetObserver(nsIInputStreamObserver * aObserver)
{
NS_NOTREACHED("SetObserver");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_METHOD
nsStorageInputStream::Seek(PRUint32 aPosition)
{
PRUint32 length = mStorageStream->mLogicalLength;
if (aPosition >= length)
return NS_ERROR_INVALID_ARG;
mSegmentNum = SegNum(aPosition);
PRUint32 segmentOffset = SegOffset(aPosition);
mReadCursor = mStorageStream->mSegmentedBuffer->GetSegment(mSegmentNum) +
segmentOffset;
PRUint32 available = length - aPosition;
mSegmentEnd = mReadCursor + PR_MIN(mSegmentSize - segmentOffset, available);
mLogicalCursor = aPosition;
return NS_OK;
}
NS_COM nsresult
NS_NewStorageStream(PRUint32 segmentSize, PRUint32 maxSize, nsIStorageStream **result)
{
NS_ENSURE_ARG(result);
nsStorageStream* storageStream = new nsStorageStream();
if (!storageStream) return NS_ERROR_OUT_OF_MEMORY;
storageStream->Init(segmentSize, maxSize);
NS_ADDREF(storageStream);
*result = storageStream;
return NS_OK;
}