normalize most lineendings

1 files changed, 274 insertions, 274 deletions

diff --git a/zen/file_io.cpp b/zen/file_io.cpp
index 0c5ff490..d291e741 100755
--- a/zen/file_io.cpp
+++ b/zen/file_io.cpp
@@ -1,274 +1,274 @@
-// *****************************************************************************

-// * This file is part of the FreeFileSync project. It is distributed under    *

-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *

-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *

-// *****************************************************************************

-

-#include "file_io.h"

-#include "file_access.h"

-

-    #include <sys/stat.h>

-    #include <fcntl.h>  //open, close

-    #include <unistd.h> //read, write

-

-using namespace zen;

-

-

-namespace

-{

-//- "filePath" could be a named pipe which *blocks* forever for open()!

-//- open() with O_NONBLOCK avoids the block, but opens successfully

-//- create sample pipe: "sudo mkfifo named_pipe"

-void checkForUnsupportedType(const Zstring& filePath) //throw FileError

-{

-    struct ::stat fileInfo = {};

-    if (::stat(filePath.c_str(), &fileInfo) != 0) //follows symlinks

-        return; //let the caller handle errors like "not existing"

-

-    if (!S_ISREG(fileInfo.st_mode) &&

-        !S_ISLNK(fileInfo.st_mode) &&

-        !S_ISDIR(fileInfo.st_mode))

-    {

-        auto getTypeName = [](mode_t m) -> std::wstring

-        {

-            const wchar_t* name =

-            S_ISCHR (m) ? L"character device":

-            S_ISBLK (m) ? L"block device" :

-            S_ISFIFO(m) ? L"FIFO, named pipe" :

-            S_ISSOCK(m) ? L"socket" : nullptr;

-            const std::wstring numFmt = printNumber<std::wstring>(L"0%06o", m & S_IFMT);

-            return name ? numFmt + L", " + name : numFmt;

-        };

-        throw FileError(replaceCpy(_("Type of item %x is not supported:"), L"%x", fmtPath(filePath)) + L" " + getTypeName(fileInfo.st_mode));

-    }

-}

-}

-

-

-    const FileBase::FileHandle FileBase::invalidHandleValue = -1;

-

-

-FileBase::~FileBase()

-{

-    if (fileHandle_ != invalidHandleValue)

-        try

-        {

-            close(); //throw FileError

-        }

-        catch (FileError&) { assert(false); }

-}

-

-

-void FileBase::close() //throw FileError

-{

-    if (fileHandle_ == invalidHandleValue)

-        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"Contract error: close() called more than once.");

-    ZEN_ON_SCOPE_EXIT(fileHandle_ = invalidHandleValue);

-

-    //no need to clean-up on failure here (just like there is no clean on FileOutput::write failure!) => FileOutput is not transactional!

-

-    if (::close(fileHandle_) != 0)

-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"close");

-}

-

-//----------------------------------------------------------------------------------------------------

-

-namespace

-{

-FileBase::FileHandle openHandleForRead(const Zstring& filePath) //throw FileError, ErrorFileLocked

-{

-    checkForUnsupportedType(filePath); //throw FileError; opening a named pipe would block forever!

-

-    //don't use O_DIRECT: http://yarchive.net/comp/linux/o_direct.html

-    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY);

-    if (fileHandle == -1) //don't check "< 0" -> docu seems to allow "-2" to be a valid file handle

-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open file %x."), L"%x", fmtPath(filePath)), L"open");

-    return fileHandle; //pass ownership

-}

-}

-

-

-FileInput::FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :

-    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}

-

-

-FileInput::FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :

-    FileBase(openHandleForRead(filePath), filePath), //throw FileError, ErrorFileLocked

-    notifyUnbufferedIO_(notifyUnbufferedIO)

-{

-    //optimize read-ahead on input file:

-    if (::posix_fadvise(getHandle(), 0, 0, POSIX_FADV_SEQUENTIAL) != 0)

-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(filePath)), L"posix_fadvise");

-

-}

-

-

-size_t FileInput::tryRead(void* buffer, size_t bytesToRead) //throw FileError; may return short, only 0 means EOF!

-{

-    if (bytesToRead == 0) //"read() with a count of 0 returns zero" => indistinguishable from end of file! => check!

-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));

-    assert(bytesToRead == getBlockSize());

-

-    ssize_t bytesRead = 0;

-    do

-    {

-        bytesRead = ::read(getHandle(), buffer, bytesToRead);

-    }

-    while (bytesRead < 0 && errno == EINTR); //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz

-

-    if (bytesRead < 0)

-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"read");

-    if (static_cast<size_t>(bytesRead) > bytesToRead) //better safe than sorry

-        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"ReadFile: buffer overflow."); //user should never see this

-

-    //if ::read is interrupted (EINTR) right in the middle, it will return successfully with "bytesRead < bytesToRead"

-

-    return bytesRead; //"zero indicates end of file"

-}

-

-

-size_t FileInput::read(void* buffer, size_t bytesToRead) //throw FileError, X; return "bytesToRead" bytes unless end of stream!

-{

-    const size_t blockSize = getBlockSize();

-

-    while (memBuf_.size() < bytesToRead)

-    {

-        memBuf_.resize(memBuf_.size() + blockSize);

-        const size_t bytesRead = tryRead(&*(memBuf_.end() - blockSize), blockSize); //throw FileError; may return short, only 0 means EOF! => CONTRACT: bytesToRead > 0

-        memBuf_.resize(memBuf_.size() - blockSize + bytesRead); //caveat: unsigned arithmetics

-

-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesRead); //throw X

-

-        if (bytesRead == 0) //end of file

-            bytesToRead = std::min(bytesToRead, memBuf_.size());

-    }

-

-    std::copy(memBuf_.begin(), memBuf_.begin() + bytesToRead, static_cast<char*>(buffer));

-    memBuf_.erase(memBuf_.begin(), memBuf_.begin() + bytesToRead);

-    return bytesToRead;

-}

-

-//----------------------------------------------------------------------------------------------------

-

-namespace

-{

-FileBase::FileHandle openHandleForWrite(const Zstring& filePath, FileOutput::AccessFlag access) //throw FileError, ErrorTargetExisting

-{

-    //checkForUnsupportedType(filePath); -> not needed, open() + O_WRONLY should fail fast

-

-    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC),

-                                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); //0666

-    if (fileHandle == -1)

-    {

-        const int ec = errno; //copy before making other system calls!

-        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(filePath));

-        const std::wstring errorDescr = formatSystemError(L"open", ec);

-

-        if (ec == EEXIST)

-            throw ErrorTargetExisting(errorMsg, errorDescr);

-        //if (ec == ENOENT) throw ErrorTargetPathMissing(errorMsg, errorDescr);

-

-        throw FileError(errorMsg, errorDescr);

-    }

-    return fileHandle; //pass ownership

-}

-}

-

-

-FileOutput::FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :

-    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}

-

-

-FileOutput::FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO) :

-    FileBase(openHandleForWrite(filePath, access), filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {} //throw FileError, ErrorTargetExisting

-

-

-FileOutput::~FileOutput()

-{

-    notifyUnbufferedIO_ = nullptr; //no call-backs during destruction!!!

-    try

-    {

-        flushBuffers(); //throw FileError, (X)

-    }

-    catch (...) { assert(false); }

-}

-

-

-size_t FileOutput::tryWrite(const void* buffer, size_t bytesToWrite) //throw FileError; may return short! CONTRACT: bytesToWrite > 0

-{

-    if (bytesToWrite == 0)

-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));

-    assert(bytesToWrite <= getBlockSize());

-

-    ssize_t bytesWritten = 0;

-    do

-    {

-        bytesWritten = ::write(getHandle(), buffer, bytesToWrite);

-    }

-    while (bytesWritten < 0 && errno == EINTR);

-

-    if (bytesWritten <= 0)

-    {

-        if (bytesWritten == 0) //comment in safe-read.c suggests to treat this as an error due to buggy drivers

-            errno = ENOSPC;

-

-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write");

-    }

-    if (bytesWritten > static_cast<ssize_t>(bytesToWrite)) //better safe than sorry

-        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write: buffer overflow."); //user should never see this

-

-    //if ::write() is interrupted (EINTR) right in the middle, it will return successfully with "bytesWritten < bytesToWrite"!

-    return bytesWritten;

-}

-

-

-void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileError, X

-{

-    auto bufFirst = static_cast<const char*>(buffer);

-    memBuf_.insert(memBuf_.end(), bufFirst, bufFirst + bytesToWrite);

-

-    const size_t blockSize = getBlockSize();

-    size_t bytesRemaining = memBuf_.size();

-    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));

-    while (bytesRemaining >= blockSize)

-    {

-        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), blockSize); //throw FileError; may return short! CONTRACT: bytesToWrite > 0

-        bytesRemaining -= bytesWritten;

-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!

-    }

-}

-

-

-void FileOutput::flushBuffers() //throw FileError, X

-{

-    size_t bytesRemaining = memBuf_.size();

-    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));

-    while (bytesRemaining > 0)

-    {

-        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), bytesRemaining); //throw FileError; may return short! CONTRACT: bytesToWrite > 0

-        bytesRemaining -= bytesWritten;

-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!

-    }

-}

-

-

-void FileOutput::finalize() //throw FileError, X

-{

-    flushBuffers(); //throw FileError, X

-    //~FileBase() calls this one, too, but we want to propagate errors if any:

-    close(); //throw FileError

-}

-

-

-void FileOutput::preAllocateSpaceBestEffort(uint64_t expectedSize) //throw FileError

-{

-    const FileHandle fh = getHandle();

-    //don't use potentially inefficient ::posix_fallocate!

-    const int rv = ::fallocate(fh,            //int fd,

-                               0,             //int mode,

-                               0,             //off_t offset

-                               expectedSize); //off_t len

-    if (rv != 0)

-        return; //may fail with EOPNOTSUPP, unlike posix_fallocate

-

-}

+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "file_io.h"
+#include "file_access.h"
+
+    #include <sys/stat.h>
+    #include <fcntl.h>  //open, close
+    #include <unistd.h> //read, write
+
+using namespace zen;
+
+
+namespace
+{
+//- "filePath" could be a named pipe which *blocks* forever for open()!
+//- open() with O_NONBLOCK avoids the block, but opens successfully
+//- create sample pipe: "sudo mkfifo named_pipe"
+void checkForUnsupportedType(const Zstring& filePath) //throw FileError
+{
+    struct ::stat fileInfo = {};
+    if (::stat(filePath.c_str(), &fileInfo) != 0) //follows symlinks
+        return; //let the caller handle errors like "not existing"
+
+    if (!S_ISREG(fileInfo.st_mode) &&
+        !S_ISLNK(fileInfo.st_mode) &&
+        !S_ISDIR(fileInfo.st_mode))
+    {
+        auto getTypeName = [](mode_t m) -> std::wstring
+        {
+            const wchar_t* name =
+            S_ISCHR (m) ? L"character device":
+            S_ISBLK (m) ? L"block device" :
+            S_ISFIFO(m) ? L"FIFO, named pipe" :
+            S_ISSOCK(m) ? L"socket" : nullptr;
+            const std::wstring numFmt = printNumber<std::wstring>(L"0%06o", m & S_IFMT);
+            return name ? numFmt + L", " + name : numFmt;
+        };
+        throw FileError(replaceCpy(_("Type of item %x is not supported:"), L"%x", fmtPath(filePath)) + L" " + getTypeName(fileInfo.st_mode));
+    }
+}
+}
+
+
+    const FileBase::FileHandle FileBase::invalidHandleValue = -1;
+
+
+FileBase::~FileBase()
+{
+    if (fileHandle_ != invalidHandleValue)
+        try
+        {
+            close(); //throw FileError
+        }
+        catch (FileError&) { assert(false); }
+}
+
+
+void FileBase::close() //throw FileError
+{
+    if (fileHandle_ == invalidHandleValue)
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"Contract error: close() called more than once.");
+    ZEN_ON_SCOPE_EXIT(fileHandle_ = invalidHandleValue);
+
+    //no need to clean-up on failure here (just like there is no clean on FileOutput::write failure!) => FileOutput is not transactional!
+
+    if (::close(fileHandle_) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"close");
+}
+
+//----------------------------------------------------------------------------------------------------
+
+namespace
+{
+FileBase::FileHandle openHandleForRead(const Zstring& filePath) //throw FileError, ErrorFileLocked
+{
+    checkForUnsupportedType(filePath); //throw FileError; opening a named pipe would block forever!
+
+    //don't use O_DIRECT: http://yarchive.net/comp/linux/o_direct.html
+    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY);
+    if (fileHandle == -1) //don't check "< 0" -> docu seems to allow "-2" to be a valid file handle
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open file %x."), L"%x", fmtPath(filePath)), L"open");
+    return fileHandle; //pass ownership
+}
+}
+
+
+FileInput::FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
+
+
+FileInput::FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(openHandleForRead(filePath), filePath), //throw FileError, ErrorFileLocked
+    notifyUnbufferedIO_(notifyUnbufferedIO)
+{
+    //optimize read-ahead on input file:
+    if (::posix_fadvise(getHandle(), 0, 0, POSIX_FADV_SEQUENTIAL) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(filePath)), L"posix_fadvise");
+
+}
+
+
+size_t FileInput::tryRead(void* buffer, size_t bytesToRead) //throw FileError; may return short, only 0 means EOF!
+{
+    if (bytesToRead == 0) //"read() with a count of 0 returns zero" => indistinguishable from end of file! => check!
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+    assert(bytesToRead == getBlockSize());
+
+    ssize_t bytesRead = 0;
+    do
+    {
+        bytesRead = ::read(getHandle(), buffer, bytesToRead);
+    }
+    while (bytesRead < 0 && errno == EINTR); //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz
+
+    if (bytesRead < 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"read");
+    if (static_cast<size_t>(bytesRead) > bytesToRead) //better safe than sorry
+        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"ReadFile: buffer overflow."); //user should never see this
+
+    //if ::read is interrupted (EINTR) right in the middle, it will return successfully with "bytesRead < bytesToRead"
+
+    return bytesRead; //"zero indicates end of file"
+}
+
+
+size_t FileInput::read(void* buffer, size_t bytesToRead) //throw FileError, X; return "bytesToRead" bytes unless end of stream!
+{
+    const size_t blockSize = getBlockSize();
+
+    while (memBuf_.size() < bytesToRead)
+    {
+        memBuf_.resize(memBuf_.size() + blockSize);
+        const size_t bytesRead = tryRead(&*(memBuf_.end() - blockSize), blockSize); //throw FileError; may return short, only 0 means EOF! => CONTRACT: bytesToRead > 0
+        memBuf_.resize(memBuf_.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
+
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesRead); //throw X
+
+        if (bytesRead == 0) //end of file
+            bytesToRead = std::min(bytesToRead, memBuf_.size());
+    }
+
+    std::copy(memBuf_.begin(), memBuf_.begin() + bytesToRead, static_cast<char*>(buffer));
+    memBuf_.erase(memBuf_.begin(), memBuf_.begin() + bytesToRead);
+    return bytesToRead;
+}
+
+//----------------------------------------------------------------------------------------------------
+
+namespace
+{
+FileBase::FileHandle openHandleForWrite(const Zstring& filePath, FileOutput::AccessFlag access) //throw FileError, ErrorTargetExisting
+{
+    //checkForUnsupportedType(filePath); -> not needed, open() + O_WRONLY should fail fast
+
+    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC),
+                                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); //0666
+    if (fileHandle == -1)
+    {
+        const int ec = errno; //copy before making other system calls!
+        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(filePath));
+        const std::wstring errorDescr = formatSystemError(L"open", ec);
+
+        if (ec == EEXIST)
+            throw ErrorTargetExisting(errorMsg, errorDescr);
+        //if (ec == ENOENT) throw ErrorTargetPathMissing(errorMsg, errorDescr);
+
+        throw FileError(errorMsg, errorDescr);
+    }
+    return fileHandle; //pass ownership
+}
+}
+
+
+FileOutput::FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
+
+
+FileOutput::FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO) :
+    FileBase(openHandleForWrite(filePath, access), filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {} //throw FileError, ErrorTargetExisting
+
+
+FileOutput::~FileOutput()
+{
+    notifyUnbufferedIO_ = nullptr; //no call-backs during destruction!!!
+    try
+    {
+        flushBuffers(); //throw FileError, (X)
+    }
+    catch (...) { assert(false); }
+}
+
+
+size_t FileOutput::tryWrite(const void* buffer, size_t bytesToWrite) //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+{
+    if (bytesToWrite == 0)
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+    assert(bytesToWrite <= getBlockSize());
+
+    ssize_t bytesWritten = 0;
+    do
+    {
+        bytesWritten = ::write(getHandle(), buffer, bytesToWrite);
+    }
+    while (bytesWritten < 0 && errno == EINTR);
+
+    if (bytesWritten <= 0)
+    {
+        if (bytesWritten == 0) //comment in safe-read.c suggests to treat this as an error due to buggy drivers
+            errno = ENOSPC;
+
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write");
+    }
+    if (bytesWritten > static_cast<ssize_t>(bytesToWrite)) //better safe than sorry
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write: buffer overflow."); //user should never see this
+
+    //if ::write() is interrupted (EINTR) right in the middle, it will return successfully with "bytesWritten < bytesToWrite"!
+    return bytesWritten;
+}
+
+
+void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileError, X
+{
+    auto bufFirst = static_cast<const char*>(buffer);
+    memBuf_.insert(memBuf_.end(), bufFirst, bufFirst + bytesToWrite);
+
+    const size_t blockSize = getBlockSize();
+    size_t bytesRemaining = memBuf_.size();
+    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
+    while (bytesRemaining >= blockSize)
+    {
+        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), blockSize); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+        bytesRemaining -= bytesWritten;
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
+    }
+}
+
+
+void FileOutput::flushBuffers() //throw FileError, X
+{
+    size_t bytesRemaining = memBuf_.size();
+    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
+    while (bytesRemaining > 0)
+    {
+        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), bytesRemaining); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+        bytesRemaining -= bytesWritten;
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
+    }
+}
+
+
+void FileOutput::finalize() //throw FileError, X
+{
+    flushBuffers(); //throw FileError, X
+    //~FileBase() calls this one, too, but we want to propagate errors if any:
+    close(); //throw FileError
+}
+
+
+void FileOutput::preAllocateSpaceBestEffort(uint64_t expectedSize) //throw FileError
+{
+    const FileHandle fh = getHandle();
+    //don't use potentially inefficient ::posix_fallocate!
+    const int rv = ::fallocate(fh,            //int fd,
+                               0,             //int mode,
+                               0,             //off_t offset
+                               expectedSize); //off_t len
+    if (rv != 0)
+        return; //may fail with EOPNOTSUPP, unlike posix_fallocate
+
+}