#include "BasicExcel.hpp"
namespace YCompoundFiles
{
/********************************** Start of Class Block *************************************/
// PURPOSE: Manage a file by treating it as blocks of data of a certain size.
Block::Block() :
blockSize_(512), fileSize_(0), indexEnd_(0),
filename_(0) {}
bool Block::Create(const wchar_t* filename)
// PURPOSE: Create a new block file and open it.
// PURPOSE: If file is present, truncate it and then open it.
// PROMISE: Return true if file is successfully created and opened, false if otherwise.
{
// Create new file
size_t filenameLength = wcslen(filename);
char* name = new char[filenameLength+1];
wcstombs(name, filename, filenameLength);
name[filenameLength] = 0;
file_.open(name, ios_base::out | ios_base::trunc);
file_.close();
file_.clear();
// Open the file
bool ret = this->Open(filename);
delete[] name;
return ret;
}
bool Block::Open(const wchar_t* filename, ios_base::openmode mode)
// PURPOSE: Open an existing block file.
// PROMISE: Return true if file is successfully opened, false if otherwise.
{
// Open existing file for reading or writing or both
size_t filenameLength = wcslen(filename);
filename_.resize(filenameLength+1, 0);
wcstombs(&*(filename_.begin()), filename, filenameLength);
file_.open(&*(filename_.begin()), mode | ios_base::binary);
if (!file_.is_open()) return false;
mode_ = mode;
// Calculate filesize
if (mode & ios_base::in)
{
file_.seekg(0, ios_base::end);
fileSize_ = file_.tellg();
}
else if (mode & ios_base::out)
{
file_.seekp(0, ios_base::end);
fileSize_ = file_.tellp();
}
else
{
this->Close();
return false;
}
// Calculate last index + 1
indexEnd_ = fileSize_/blockSize_ + (fileSize_ % blockSize_ ? 1 : 0);
return true;
}
bool Block::Close()
// PURPOSE: Close the opened block file.
// PROMISE: Return true if file is successfully closed, false if otherwise.
{
file_.close();
file_.clear();
filename_.clear();
fileSize_ = 0;
indexEnd_ = 0;
blockSize_ = 512;
return !file_.is_open();
}
bool Block::IsOpen()
// PURPOSE: Check if the block file is still opened.
// PROMISE: Return true if file is still opened, false if otherwise.
{
return file_.is_open();
}
bool Block::Read(size_t index, char* block)
// PURPOSE: Read a block of data from the opened file at the index position.
// EXPLAIN: index is from [0..].
// PROMISE: Return true if data are successfully read, false if otherwise.
{
if (!(mode_ & ios_base::in)) return false;
if (index < indexEnd_)
{
file_.seekg(index * blockSize_);
file_.read(block, blockSize_);
return !file_.fail();
}
else return false;
}
bool Block::Write(size_t index, const char* block)
// PURPOSE: Write a block of data to the opened file at the index position.
// EXPLAIN: index is from [0..].
// PROMISE: Return true if data are successfully written, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
file_.seekp(index * blockSize_);
file_.write(block, blockSize_);
if (indexEnd_ <= index)
{
indexEnd_ = index + 1;
fileSize_ += blockSize_;
}
file_.close();
file_.clear();
file_.open(&*(filename_.begin()), mode_ | ios_base::binary);
return file_.is_open();
}
bool Block::Swap(size_t index1, size_t index2)
// PURPOSE: Swap two blocks of data in the opened file at the index positions.
// EXPLAIN: index1 and index2 are from [0..].
// PROMISE: Return true if data are successfully swapped, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
if (index1 < indexEnd_ && index2 < indexEnd_)
{
if (index1 == index2) return true;
char* block1 = new char[blockSize_];
if (!this->Read(index1, block1)) return false;
char* block2 = new char[blockSize_];
if (!this->Read(index2, block2)) return false;
if (!this->Write(index1, block2)) return false;
if (!this->Write(index2, block1)) return false;
delete[] block1;
delete[] block2;
return true;
}
else return false;
}
bool Block::Move(size_t from, size_t to)
// PURPOSE: Move a block of data in the opened file from an index position to another index position.
// EXPLAIN: from and to are from [0..].
// PROMISE: Return true if data are successfully moved, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
if (from < indexEnd_ && to < indexEnd_)
{
if (to > from)
{
for (size_t i=from; i!=to; ++i)
{
if (!this->Swap(i, i+1)) return false;
}
}
else
{
for (size_t i=from; i!=to; --i)
{
if (!this->Swap(i, i-1)) return false;
}
}
return true;
}
else return false;
}
bool Block::Insert(size_t index, const char* block)
// PURPOSE: Insert a new block of data in the opened file at the index position.
// EXPLAIN: index is from [0..].
// PROMISE: Return true if data are successfully inserted, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
if (index <= indexEnd_)
{
// Write block to end of file
if (!this->Write(indexEnd_, block)) return false;
// Move block to index if necessary
if (index < indexEnd_-1) return this->Move(indexEnd_-1, index);
else return true;
}
else
{
// Write block to index after end of file
return this->Write(index, block);
}
}
bool Block::Erase(size_t index)
// PURPOSE: Erase a block of data in the opened file at the index position.
// EXPLAIN: index is from [0..].
// PROMISE: Return true if data are successfully erased, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
if (index < indexEnd_)
{
fileSize_ -= blockSize_;
indexEnd_ -= 1;
// Read entire file except the block to be deleted into memory.
char* buffer = new char[fileSize_];
for (size_t i=0, j=0; i!=indexEnd_+1; ++i)
{
file_.seekg(i*blockSize_);
if (i != index)
{
file_.read(buffer+j*blockSize_, blockSize_);
++j;
}
}
file_.close();
file_.open(&*(filename_.begin()), ios_base::out | ios_base::trunc | ios_base::binary);
file_.write(buffer, fileSize_); // Write the new file.
file_.close();
file_.open(&*(filename_.begin()), mode_ | ios_base::binary);
delete[] buffer;
return true;
}
else return false;
}
bool Block::Erase(vector<size_t>& indices)
// PURPOSE: Erase blocks of data in the opened file at the index positions.
// EXPLAIN: Each index in indices is from [0..].
// PROMISE: Return true if data are successfully erased, false if otherwise.
{
if (!(mode_ & ios_base::out)) return false;
// Read entire file except the blocks to be deleted into memory.
size_t maxIndices = indices.size();
fileSize_ -= maxIndices*blockSize_;
char* buffer = new char[fileSize_];
for (size_t i=0, k=0; i!=indexEnd_; ++i)
{
file_.seekg(i*blockSize_);
bool toDelete = false;
for (size_t j=0; j<maxIndices; ++j)
{
if (i == indices[j])
{
toDelete = true;
break;
}
}
if (!toDelete)
{
file_.read(buffer+k*blockSize_, blockSize_);
++k;
}
}
indexEnd_ -= maxIndices;
file_.close();
file_.open(&*(filename_.begin()), ios_base::out | ios_base::trunc | ios_base::binary);
file_.write(buffer, fileSize_); // Write the new file.
file_.close();
file_.open(&*(filename_.begin()), mode_ | ios_base::binary);
delete[] buffer;
return true;
}
/********************************** End of Class Block ***************************************/
/********************************** Start of Class Header ************************************/
// PURPOSE: Read and write data to a compound file header.
CompoundFile::Header::Header() :
fileType_(0xE11AB1A1E011CFD0LL),
uk1_(0), uk2_(0), uk3_(0), uk4_(0), uk5_(0x003B), uk6_(0x0003), uk7_(-2),
log2BigBlockSize_(9), log2SmallBlockSize_(6),
uk8_(0), uk9_(0), uk10_(0), uk11_(0x00001000),
SBATStart_(-2), SBATCount_(0),
XBATStart_(-2),
评论1
最新资源