411 lines
16 KiB
C++
411 lines
16 KiB
C++
// Filename: virtualFileMount.cxx
|
|
// Created by: drose (03Aug02)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// PANDA 3D SOFTWARE
|
|
// Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
//
|
|
// All use of this software is subject to the terms of the revised BSD
|
|
// license. You should have received a copy of this license along
|
|
// with this source code in a file named "LICENSE."
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#include "virtualFileMount.h"
|
|
#include "virtualFileSimple.h"
|
|
#include "virtualFileSystem.h"
|
|
#include "zStream.h"
|
|
|
|
TypeHandle VirtualFileMount::_type_handle;
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::Destructor
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
VirtualFileMount::
|
|
~VirtualFileMount() {
|
|
nassertv(_file_system == NULL);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::make_virtual_file
|
|
// Access: Public, Virtual
|
|
// Description: Constructs and returns a new VirtualFile instance
|
|
// that corresponds to the indicated filename within
|
|
// this mount point. The returned VirtualFile object
|
|
// does not imply that the given file actually exists;
|
|
// but if the file does exist, then the handle can be
|
|
// used to read it.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(VirtualFile) VirtualFileMount::
|
|
make_virtual_file(const Filename &local_filename,
|
|
const Filename &original_filename, bool implicit_pz_file,
|
|
int open_flags) {
|
|
Filename local(local_filename);
|
|
if (original_filename.is_text()) {
|
|
local.set_text();
|
|
} else {
|
|
local.set_binary();
|
|
}
|
|
PT(VirtualFileSimple) file =
|
|
new VirtualFileSimple(this, local, implicit_pz_file, open_flags);
|
|
file->set_original_filename(original_filename);
|
|
|
|
if ((open_flags & VirtualFileSystem::OF_create_file) != 0) {
|
|
create_file(local);
|
|
} else if ((open_flags & VirtualFileSystem::OF_make_directory) != 0) {
|
|
make_directory(local);
|
|
}
|
|
|
|
return file.p();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::create_file
|
|
// Access: Public, Virtual
|
|
// Description: Attempts to create the indicated file within the
|
|
// mount, if it does not already exist. Returns true on
|
|
// success (or if the file already exists), or false if
|
|
// it cannot be created.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
create_file(const Filename &file) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::delete_file
|
|
// Access: Public, Virtual
|
|
// Description: Attempts to delete the indicated file or directory
|
|
// within the mount. This can remove a single file or
|
|
// an empty directory. It will not remove a nonempty
|
|
// directory. Returns true on success, false on
|
|
// failure.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
delete_file(const Filename &file) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::rename_file
|
|
// Access: Public
|
|
// Description: Attempts to rename the contents of the indicated file
|
|
// to the indicated file. Both filenames will be within
|
|
// the mount. Returns true on success, false on
|
|
// failure. If this returns false, this will be
|
|
// attempted again with a copy-and-delete operation.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
rename_file(const Filename &orig_filename, const Filename &new_filename) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::copy_file
|
|
// Access: Public
|
|
// Description: Attempts to copy the contents of the indicated file
|
|
// to the indicated file. Both filenames will be within
|
|
// the mount. Returns true on success, false on
|
|
// failure. If this returns false, the copy will be
|
|
// performed by explicit read-and-write operations.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
copy_file(const Filename &orig_filename, const Filename &new_filename) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::make_directory
|
|
// Access: Public, Virtual
|
|
// Description: Attempts to create the indicated file within the
|
|
// mount, if it does not already exist. Returns true on
|
|
// success, or false if it cannot be created. If the
|
|
// directory already existed prior to this call, may
|
|
// return either true or false.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
make_directory(const Filename &file) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::is_writable
|
|
// Access: Public, Virtual
|
|
// Description: Returns true if the named file or directory may be
|
|
// written to, false otherwise.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
is_writable(const Filename &file) const {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::read_file
|
|
// Access: Public, Virtual
|
|
// Description: Fills up the indicated pvector with the contents of
|
|
// the file, if it is a regular file. Returns true on
|
|
// success, false otherwise.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
read_file(const Filename &file, bool do_uncompress,
|
|
pvector<unsigned char> &result) const {
|
|
result.clear();
|
|
|
|
istream *in = open_read_file(file, do_uncompress);
|
|
if (in == (istream *)NULL) {
|
|
express_cat.info()
|
|
<< "Unable to read " << file << "\n";
|
|
return false;
|
|
}
|
|
|
|
streamsize file_size = get_file_size(file, in);
|
|
if (file_size > 0) {
|
|
result.reserve((size_t)file_size);
|
|
}
|
|
|
|
bool okflag = VirtualFile::simple_read_file(in, result);
|
|
|
|
close_read_file(in);
|
|
|
|
if (!okflag) {
|
|
express_cat.info()
|
|
<< "Error while reading " << file << "\n";
|
|
}
|
|
return okflag;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::write_file
|
|
// Access: Public, Virtual
|
|
// Description: Writes the indicated data to the file, if it is a
|
|
// writable file. Returns true on success, false
|
|
// otherwise.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
write_file(const Filename &file, bool do_compress,
|
|
const unsigned char *data, size_t data_size) {
|
|
ostream *out = open_write_file(file, do_compress, true);
|
|
if (out == (ostream *)NULL) {
|
|
express_cat.info()
|
|
<< "Unable to write " << file << "\n";
|
|
return false;
|
|
}
|
|
|
|
out->write((const char *)data, data_size);
|
|
bool okflag = (!out->fail());
|
|
close_write_file(out);
|
|
|
|
if (!okflag) {
|
|
express_cat.info()
|
|
<< "Error while writing " << file << "\n";
|
|
}
|
|
return okflag;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_read_file
|
|
// Access: Published, Virtual
|
|
// Description: Opens the file for reading. Returns a newly
|
|
// allocated istream on success (which you should
|
|
// eventually delete when you are done reading).
|
|
// Returns NULL on failure.
|
|
//
|
|
// If do_uncompress is true, the file is also
|
|
// decompressed on-the-fly using zlib.
|
|
////////////////////////////////////////////////////////////////////
|
|
istream *VirtualFileMount::
|
|
open_read_file(const Filename &file, bool do_uncompress) const {
|
|
istream *result = open_read_file(file);
|
|
|
|
#ifdef HAVE_ZLIB
|
|
if (result != (istream *)NULL && do_uncompress) {
|
|
// We have to slip in a layer to decompress the file on the fly.
|
|
IDecompressStream *wrapper = new IDecompressStream(result, true);
|
|
result = wrapper;
|
|
}
|
|
#endif // HAVE_ZLIB
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::close_read_file
|
|
// Access: Public, Virtual
|
|
// Description: Closes a file opened by a previous call to
|
|
// open_read_file(). This really just deletes the
|
|
// istream pointer, but it is recommended to use this
|
|
// interface instead of deleting it explicitly, to help
|
|
// work around compiler issues.
|
|
////////////////////////////////////////////////////////////////////
|
|
void VirtualFileMount::
|
|
close_read_file(istream *stream) const {
|
|
VirtualFileSystem::close_read_file(stream);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_write_file
|
|
// Access: Published, Virtual
|
|
// Description: Opens the file for writing. Returns a newly
|
|
// allocated ostream on success (which you should
|
|
// eventually delete when you are done writing).
|
|
// Returns NULL on failure.
|
|
////////////////////////////////////////////////////////////////////
|
|
ostream *VirtualFileMount::
|
|
open_write_file(const Filename &file, bool truncate) {
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_write_file
|
|
// Access: Published
|
|
// Description: Opens the file for writing. Returns a newly
|
|
// allocated ostream on success (which you should
|
|
// eventually delete when you are done writing).
|
|
// Returns NULL on failure.
|
|
//
|
|
// If do_compress is true, the file is also
|
|
// compressed on-the-fly using zlib.
|
|
////////////////////////////////////////////////////////////////////
|
|
ostream *VirtualFileMount::
|
|
open_write_file(const Filename &file, bool do_compress, bool truncate) {
|
|
ostream *result = open_write_file(file, truncate);
|
|
|
|
#ifdef HAVE_ZLIB
|
|
if (result != (ostream *)NULL && do_compress) {
|
|
// We have to slip in a layer to compress the file on the fly.
|
|
OCompressStream *wrapper = new OCompressStream(result, true);
|
|
result = wrapper;
|
|
}
|
|
#endif // HAVE_ZLIB
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_append_file
|
|
// Access: Published, Virtual
|
|
// Description: Works like open_write_file(), but the file is opened
|
|
// in append mode. Like open_write_file, the returned
|
|
// pointer should eventually be passed to
|
|
// close_write_file().
|
|
////////////////////////////////////////////////////////////////////
|
|
ostream *VirtualFileMount::
|
|
open_append_file(const Filename &file) {
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::close_write_file
|
|
// Access: Public, Virtual
|
|
// Description: Closes a file opened by a previous call to
|
|
// open_write_file(). This really just deletes the
|
|
// ostream pointer, but it is recommended to use this
|
|
// interface instead of deleting it explicitly, to help
|
|
// work around compiler issues.
|
|
////////////////////////////////////////////////////////////////////
|
|
void VirtualFileMount::
|
|
close_write_file(ostream *stream) {
|
|
VirtualFileSystem::close_write_file(stream);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_read_write_file
|
|
// Access: Published, Virtual
|
|
// Description: Opens the file for writing. Returns a newly
|
|
// allocated iostream on success (which you should
|
|
// eventually delete when you are done writing).
|
|
// Returns NULL on failure.
|
|
////////////////////////////////////////////////////////////////////
|
|
iostream *VirtualFileMount::
|
|
open_read_write_file(const Filename &file, bool truncate) {
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::open_read_append_file
|
|
// Access: Published, Virtual
|
|
// Description: Works like open_read_write_file(), but the file is opened
|
|
// in append mode. Like open_read_write_file, the returned
|
|
// pointer should eventually be passed to
|
|
// close_read_write_file().
|
|
////////////////////////////////////////////////////////////////////
|
|
iostream *VirtualFileMount::
|
|
open_read_append_file(const Filename &file) {
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::close_read_write_file
|
|
// Access: Public, Virtual
|
|
// Description: Closes a file opened by a previous call to
|
|
// open_read_write_file(). This really just deletes the
|
|
// iostream pointer, but it is recommended to use this
|
|
// interface instead of deleting it explicitly, to help
|
|
// work around compiler issues.
|
|
////////////////////////////////////////////////////////////////////
|
|
void VirtualFileMount::
|
|
close_read_write_file(iostream *stream) {
|
|
VirtualFileSystem::close_read_write_file(stream);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::get_system_info
|
|
// Access: Public, Virtual
|
|
// Description: Populates the SubfileInfo structure with the data
|
|
// representing where the file actually resides on disk,
|
|
// if this is knowable. Returns true if the file might
|
|
// reside on disk, and the info is populated, or false
|
|
// if it does not (or it is not known where the file
|
|
// resides), in which case the info is meaningless.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
get_system_info(const Filename &file, SubfileInfo &info) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::atomic_compare_and_exchange_contents
|
|
// Access: Public, Virtual
|
|
// Description: See Filename::atomic_compare_and_exchange_contents().
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
atomic_compare_and_exchange_contents(const Filename &file, string &orig_contents,
|
|
const string &old_contents,
|
|
const string &new_contents) {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::atomic_read_contents
|
|
// Access: Public, Virtual
|
|
// Description: See Filename::atomic_read_contents().
|
|
////////////////////////////////////////////////////////////////////
|
|
bool VirtualFileMount::
|
|
atomic_read_contents(const Filename &file, string &contents) const {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::output
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
void VirtualFileMount::
|
|
output(ostream &out) const {
|
|
out << get_type();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: VirtualFileMount::write
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
void VirtualFileMount::
|
|
write(ostream &out) const {
|
|
out << *this << " on /" << get_mount_point() << "\n";
|
|
}
|