pjs/xpcom/io/nsFileStream.cpp

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

1998-12-09 01:43:57 +03:00
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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/
1998-12-09 01:43:57 +03:00
*
* 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.
1998-12-09 01:43:57 +03:00
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
1998-12-09 01:43:57 +03:00
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
1998-12-09 01:43:57 +03:00
*/
// First checked in on 98/12/08 by John R. McMullen.
// Since nsFileStream.h is entirely templates, common code (such as open())
// which does not actually depend on the charT, can be placed here.
1998-12-09 01:43:57 +03:00
#include "nsFileStream.h"
1999-05-26 05:38:36 +04:00
#include "nsFileSpec.h"
#include "nsIFileSpec.h"
#include "nsIStringStream.h"
#include <string.h>
#include <stdio.h>
1998-12-09 01:43:57 +03:00
//========================================================================================
// nsInputStream
//========================================================================================
1998-12-09 01:43:57 +03:00
//----------------------------------------------------------------------------------------
nsInputStream::~nsInputStream()
1998-12-09 01:43:57 +03:00
//----------------------------------------------------------------------------------------
{
}
//----------------------------------------------------------------------------------------
char nsInputStream::get()
//----------------------------------------------------------------------------------------
{
char c;
if (read(&c, sizeof(c)) == sizeof(c))
return c;
return 0;
}
//----------------------------------------------------------------------------------------
PRInt32 nsInputStream::read(void* s, PRInt32 n)
//----------------------------------------------------------------------------------------
{
if (!mInputStream)
return 0;
PRInt32 result = 0;
mInputStream->Read((char*)s, n, (PRUint32*)&result);
2000-02-11 03:50:58 +03:00
if (result == 0)
set_at_eof(PR_TRUE);
return result;
} // nsInputStream::read
//----------------------------------------------------------------------------------------
static void TidyEndOfLine(char*& cp)
// Assumes that cp is pointing at \n or \r. Nulls out the character, checks for
// a second terminator (of the opposite persuasion), and returns cp pointing past the
// entire eol construct (one or two characters).
//----------------------------------------------------------------------------------------
{
char ch = *cp;
*cp++ = '\0'; // terminate at the newline, then skip past it
if ((ch == '\n' && *cp == '\r') || (ch == '\r' && *cp == '\n'))
cp++; // possibly a pair.
}
//----------------------------------------------------------------------------------------
nsInputStream& nsInputStream::operator >> (char& c)
//----------------------------------------------------------------------------------------
{
c = get();
return *this;
}
//========================================================================================
// nsOutputStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsOutputStream::~nsOutputStream()
//----------------------------------------------------------------------------------------
{
}
//----------------------------------------------------------------------------------------
void nsOutputStream::put(char c)
//----------------------------------------------------------------------------------------
{
write(&c, sizeof(c));
}
//----------------------------------------------------------------------------------------
PRInt32 nsOutputStream::write(const void* s, PRInt32 n)
//----------------------------------------------------------------------------------------
{
if (!mOutputStream)
return 0;
PRInt32 result = 0;
mOutputStream->Write((char*)s, n, (PRUint32*)&result);
return result;
} // nsOutputStream::write
//----------------------------------------------------------------------------------------
void nsOutputStream::flush()
//----------------------------------------------------------------------------------------
{
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (char c)
//----------------------------------------------------------------------------------------
{
put(c);
return *this;
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (const char* s)
//----------------------------------------------------------------------------------------
{
if (s)
write(s, strlen(s));
return *this;
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (short val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%hd", val);
return (*this << buf);
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (unsigned short val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%hu", val);
return (*this << buf);
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (long val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%ld", val);
return (*this << buf);
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (unsigned long val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%lu", val);
return (*this << buf);
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (int val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%d", val);
return (*this << buf);
}
//----------------------------------------------------------------------------------------
nsOutputStream& nsOutputStream::operator << (unsigned int val)
//----------------------------------------------------------------------------------------
{
char buf[30];
sprintf(buf, "%u", val);
return (*this << buf);
}
//========================================================================================
// nsRandomAccessInputStream
//========================================================================================
//----------------------------------------------------------------------------------------
PRBool nsRandomAccessInputStream::readline(char* s, PRInt32 n)
// This will truncate if the buffer is too small. Result will always be null-terminated.
//----------------------------------------------------------------------------------------
{
PRBool bufferLargeEnough = PR_TRUE; // result
if (!s || !n)
return PR_TRUE;
PRIntn position = tell();
if (position < 0)
return PR_FALSE;
PRInt32 bytesRead = read(s, n - 1);
if (failed())
return PR_FALSE;
s[bytesRead] = '\0'; // always terminate at the end of the buffer
char* tp = strpbrk(s, "\n\r");
if (tp)
{
TidyEndOfLine(tp);
bytesRead = (tp - s);
}
else if (!eof() && n-1 == bytesRead)
bufferLargeEnough = PR_FALSE;
position += bytesRead;
seek(position);
return bufferLargeEnough;
} // nsRandomAccessInputStream::readline
//========================================================================================
// nsInputStringStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsInputStringStream::nsInputStringStream(const char* stringToRead)
//----------------------------------------------------------------------------------------
{
nsISupports* stream;
if (NS_FAILED(NS_NewCharInputStream(&stream, stringToRead)))
return;
mInputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
NS_RELEASE(stream);
}
//----------------------------------------------------------------------------------------
nsInputStringStream::nsInputStringStream(const nsString& stringToRead)
//----------------------------------------------------------------------------------------
{
nsISupports* stream;
if (NS_FAILED(NS_NewStringInputStream(&stream, stringToRead)))
return;
mInputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
NS_RELEASE(stream);
}
//========================================================================================
// nsOutputStringStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsOutputStringStream::nsOutputStringStream(char*& stringToChange)
//----------------------------------------------------------------------------------------
{
nsISupports* stream;
if (NS_FAILED(NS_NewCharOutputStream(&stream, &stringToChange)))
return;
mOutputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
NS_RELEASE(stream);
}
//----------------------------------------------------------------------------------------
nsOutputStringStream::nsOutputStringStream(nsString& stringToChange)
//----------------------------------------------------------------------------------------
{
nsISupports* stream;
if (NS_FAILED(NS_NewStringOutputStream(&stream, stringToChange)))
return;
mOutputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
NS_RELEASE(stream);
}
//========================================================================================
// nsInputFileStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsInputFileStream::nsInputFileStream(
const nsFileSpec& inFile,
int nsprMode,
PRIntn accessMode)
//----------------------------------------------------------------------------------------
{
nsISupports* stream;
if (NS_FAILED(NS_NewIOFileStream(&stream, inFile, nsprMode, accessMode)))
return;
AssignFrom(stream);
NS_RELEASE(stream);
} // nsInputFileStream::nsInputFileStream
//----------------------------------------------------------------------------------------
nsInputFileStream::nsInputFileStream(nsIFileSpec* inSpec)
//----------------------------------------------------------------------------------------
{
nsIInputStream* stream;
if (NS_FAILED(inSpec->GetInputStream(&stream)))
return;
AssignFrom(stream);
NS_RELEASE(stream);
} // nsInputFileStream::nsInputFileStream
//----------------------------------------------------------------------------------------
void nsInputFileStream::AssignFrom(nsISupports* stream)
//----------------------------------------------------------------------------------------
{
mFile = do_QueryInterface(stream);
mInputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
mFileInputStream = do_QueryInterface(stream);
}
//========================================================================================
// nsOutputFileStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsOutputFileStream::nsOutputFileStream(nsIFileSpec* inSpec)
//----------------------------------------------------------------------------------------
{
1999-06-15 13:31:49 +04:00
if (!inSpec)
return;
nsIOutputStream* stream;
if (NS_FAILED(inSpec->GetOutputStream(&stream)))
return;
AssignFrom(stream);
NS_RELEASE(stream);
}
//----------------------------------------------------------------------------------------
void nsOutputFileStream::AssignFrom(nsISupports* stream)
//----------------------------------------------------------------------------------------
{
mFile = do_QueryInterface(stream);
mOutputStream = do_QueryInterface(stream);
mStore = do_QueryInterface(stream);
mFileOutputStream = do_QueryInterface(stream);
}
//----------------------------------------------------------------------------------------
void nsOutputFileStream::flush()
//----------------------------------------------------------------------------------------
{
if (mFileOutputStream)
mFileOutputStream->Flush();
}
1999-05-26 05:38:36 +04:00
//----------------------------------------------------------------------------------------
void nsOutputFileStream::abort()
//----------------------------------------------------------------------------------------
{
mResult = NS_FILE_FAILURE;
close();
}
//========================================================================================
// nsSaveViaTempStream
//========================================================================================
//----------------------------------------------------------------------------------------
nsSaveViaTempStream::nsSaveViaTempStream(const nsFileSpec& inFileToSave)
//----------------------------------------------------------------------------------------
: mFileToSave(inFileToSave)
, mTempFileSpec(new nsFileSpec(inFileToSave))
{
// Make sure the temp file's unique (in particular, different from the target file)
mTempFileSpec->MakeUnique();
2000-07-22 02:16:18 +04:00
open(*mTempFileSpec, (PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE), 0666);
1999-05-26 05:38:36 +04:00
} // nsSaveViaTempStream::nsSaveViaTempStream
//----------------------------------------------------------------------------------------
void nsSaveViaTempStream::close()
//----------------------------------------------------------------------------------------
{
if (!mTempFileSpec)
return;
nsresult currentResult = mResult;
Inherited::close();
mResult = currentResult;
if (error())
{
mTempFileSpec->Delete(PR_FALSE);
}
else
{
nsFileSpec thirdSpec(mFileToSave);
thirdSpec.MakeUnique();
nsSimpleCharString originalName(mFileToSave.GetLeafName());
((nsFileSpec&)mFileToSave).Rename(nsSimpleCharString(thirdSpec.GetLeafName()));
if (NS_SUCCEEDED(mTempFileSpec->Rename(originalName)) && mTempFileSpec->Valid())
mFileToSave.Delete(PR_FALSE);
}
delete mTempFileSpec;
} // nsSaveViaTempStream::~nsSaveViaTempStream
//----------------------------------------------------------------------------------------
nsSaveViaTempStream::~nsSaveViaTempStream()
//----------------------------------------------------------------------------------------
{
delete mTempFileSpec;
} // nsSaveViaTempStream::~nsSaveViaTempStream
//========================================================================================
// Manipulators
//========================================================================================
//----------------------------------------------------------------------------------------
nsOutputStream& nsEndl(nsOutputStream& os)
//----------------------------------------------------------------------------------------
{
#if defined(XP_WIN) || defined(XP_OS2)
1999-04-28 01:26:15 +04:00
os.write("\r\n", 2);
#elif defined (XP_MAC)
os.put('\r');
1999-04-28 01:26:15 +04:00
#else
os.put('\n');
1999-04-28 01:26:15 +04:00
#endif
//os.flush();
return os;
1999-03-20 05:34:54 +03:00
} // nsEndl