int BCTest::ReadOidRanges(const OidRanges_t& v, uint32_t* hits, uint32_t* miss)
{
blockCacheClient bc(BRP);
uint8_t inBuff[8192];
int32_t readBlocks=0;
int32_t missBlocks=0;
for(uint32_t i=0; i<v.ranges.size(); i++)
{
FileBuffer fb(-1, -1);
const InlineLBIDRange r={v.ranges[i].start, v.ranges[i].size};
for(int j=r.start; readBlocks<fCacheSz && j<r.start+r.size; j++)
{
FileBuffer* ptr =bc.getBlockPtr(j, 0);
if (ptr) {
readBlocks++;
memcpy(inBuff, ptr->getData(), 8192);
}
else
missBlocks++;
}
*hits+=readBlocks;
*miss+=missBlocks;
missBlocks=0;
readBlocks=0;
//cout << " -- Read range idx: " << i << " hits: " << readBlocks << " miss: " << missBlocks << " hwm: " << v.hwm << endl;
}
return *hits;
} // ReadRange
FileBuffer* FileBuffer::forkInput(FileBuffer *stp_file,
vector<FileOffsetSet> &used_offsets)
{
if (stp_file->getSize() > strlen("Valid"))
{
if (!strncmp(stp_file->buf, "Valid", 5))
{
return NULL;
}
}
else
{
return NULL;
}
FileBuffer* res;
try
{
res = new FileBuffer(*this);
}
catch (const char*)
{
return NULL;
}
catch (std::bad_alloc)
{
LOG(Logger::ERROR, strerror(errno));
return NULL;
}
if (res->applySTPSolution(stp_file->buf, used_offsets) < 0)
{
return NULL;
}
return res;
}
void Controller::loadFile()
{
cout << "loadFile" << endl;
// get last directory
QSettings settings;
QString lastdir;
if (settings.contains("file/opendir")) {
lastdir = settings.value("file/opendir").toString();
}
// get the filename
QString filename = QFileDialog::getOpenFileName(0, tr("Open File"), lastdir);
if (filename.length() == 0)
return;
QFileInfo fi(filename);
QString filepath = fi.filePath();
settings.setValue("file/opendir", filepath);
addRecentFiles(filename);
FileBuffer source;
source.loadFromFile(filename);
_model->loadBinary(source);
_model->getSurface()->clearSelection();
// TODO clear selected flowlines
// TODO clear selected markers
_model->setFilenameSet(true);
// stop asking for file version
_model->setFileChanged(false);
emit modelLoaded();
}
FileBuffer::FileBuffer(const FileBuffer& other)
{
name = other.getName();
size = other.getSize();
if ((buf = (char*) malloc (size + 1)) == NULL)
{
LOG(Logger::ERROR, strerror(errno));
throw "malloc";
}
for (int i = 0; i < size; i ++)
{
buf[i] = other.buf[i];
}
buf[size] = '\0';
}
Source::Source(Language *sourceLanguage, const path &sourceFilePath) throw(SourceException)
{
//variables
ifstream sourceFile;
FileBuffer *sourceBuffer = nullptr;
size_t sourceFileSize = 0;
//vérification de l'existence du fichier
if (!exists(sourceFilePath))
{
throw SourceException(tr("Le fichier source \"%0\" n'existe pas.", sourceFilePath.native()));
}
//taille du fichier
sourceFileSize = file_size(sourceFilePath);
//ouverture du fichier
sourceFile.open(sourceFilePath.c_str(), ios::in);
if (sourceFile.is_open())
{
//allocation d'un buffer
sourceBuffer = new FileBuffer(sourceFileSize);
//récupération des données dans le fichier source
sourceFile.read(sourceBuffer->getBufferPtr(), sourceBuffer->getBufferSize());
if (sourceFile.bad())
{
throw SourceException(tr("La lecture du fichier source \"%0\" a échoué.", sourceFilePath.native()));
}
//fermeture du fichier
sourceFile.close();
//parsage des données
_sourceParser.parseSource(sourceFilePath.native(), sourceBuffer, sourceLanguage);
//déallocation du buffer
delete sourceBuffer;
}
else
{
//traitement des erreurs
throw SourceException(tr("La lecture du fichier source \"%0\" a échoué.", sourceFilePath.native()));
}
}
bool StdFileManager::GetUTF8BOMFileString(const str_type::string &fileName, str_type::string &out)
{
FileBuffer buffer;
if (GetFileBuffer(fileName, buffer))
{
// TODO optimize it
str_type::stringstream ss;
unsigned char *adr = buffer->GetAddress();
for (unsigned long t = 3; t < buffer->GetBufferSize(); t++)
{
ss << static_cast<char>(adr[t]);
}
out = ss.str();
return true;
}
else
{
return false;
}
}
ImageSet * LoadFromFile( const std::string &filename )
{
//Load the file.
FILE *pFile = fopen(filename.c_str(),"rb");
if(!pFile)
throw DdsFileNotFoundException(filename);
fseek(pFile, 0, SEEK_END);
long int fileSize = ftell(pFile);
fseek(pFile, 0, SEEK_SET);
FileBuffer fileData;
fileData.reserve(fileSize);
fileData.resize(fileSize);
fread(&fileData[0], fileSize, 1, pFile);
fclose(pFile);
return ProcessDDSData(fileData, filename);
}
FileBuffer::FileBuffer(const FileBuffer& rhs) {
if (this==NULL || this==&rhs)
return;
fLbid = rhs.fLbid;
fVerid = rhs.fVerid;
setData(rhs.fByteData, rhs.fDataLen);
fListLoc=rhs.listLoc();
fDataLen=rhs.fDataLen;
}
bool StdFileManager::GetAnsiFileString(const str_type::string &fileName, str_type::string &out)
{
FileBuffer buffer;
if (GetFileBuffer(fileName, buffer))
{
// TODO optimize it
str_type::stringstream ss;
unsigned char *adr = buffer->GetAddress();
for (unsigned long t = 0; t < buffer->GetBufferSize(); t++)
{
const char c = static_cast<char>(adr[t]);
if (c != 0x0D) // remove all carriage return
ss << c;
}
out = ss.str();
return true;
}
else
{
return false;
}
}
int TestFD()
{
CString filename("C:\\TEMP\\mpbuffer.txt");
FILE* fp = nullptr;
char buffer[4004];
CString contenttype("multipart/form-data boundary=\"------WebKitFormBoundaryBFCjeYoxVSC92Luo\"");
fopen_s(&fp, filename, "rb");
if (fp)
{
fread(buffer, 1, 4000, fp);
buffer[2063] = 0;
FileBuffer fb;
// fb.AddBuffer((uchar*)buffer, 2063);
fb.SetBuffer((uchar*) buffer, 2063);
MultiPartBuffer mpb(FD_UNKNOWN);
mpb.ParseBuffer(contenttype, &fb);
printf("Number of parts: %d\n",(int) mpb.GetParts());
}
return 0;
}
int QueryTable::Load(FileBuffer& buffer, int printLog)
{
int rtn = 0;
int cnt = 0;
size_t len = 0;
buffer.GetNextData(len);
for (size_t i = 0; i < len; ++i)
{
if (buffer.Eof())
return -1;
double key, value;
rtn = buffer.GetNextData(key);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(value);
CHECK_RTN(rtn);
mQueryTable.push_back(make_pair(key, value));
++cnt;
}
sort(mQueryTable.begin(), mQueryTable.end());
if (printLog != SILENT)
clog << "Total Load " << cnt << " querytable instances" << endl;
return 0;
}
int Instance::Load(FileBuffer &buffer)
{
if (buffer.Eof())
return -1;
mFeatures.clear();
mLabels.clear();
int numFeature;
buffer.GetNextData(numFeature);
if (buffer.Eof())
return -1;
for (int i = 0; i < numFeature; ++i)
{
if (buffer.Eof())
{
cerr << "Error: Load Instance error,FileBuffer empty unexpected!" << endl;
return -1;
}
int key;
double value;
buffer.GetNextData(key);
buffer.GetNextData(value);
mFeatures[key] = value;
}
int numLabel;
buffer.GetNextData(numLabel);
for (int i = 0; i < numLabel; ++i)
{
if (buffer.Eof())
{
cerr << "Error: Load Instance error,FileBuffer empty unexpected!" << endl;
return -1;
}
int labelId;
buffer.GetNextData(labelId);
mLabels.insert(labelId);
}
return 0;
}
bool ZipFileManager::GetFileBuffer(const str_type::string &fileName, FileBuffer &out)
{
if (!IsLoaded())
return false;
str_type::string fixedPath = fileName;
FixSlashesForUnix(fixedPath);
zip_file *file = zip_fopen(m_archive, fixedPath.c_str(), 0);
if (file == NULL)
return false;
struct zip_stat stat;
zip_stat(m_archive, fixedPath.c_str(), 0, &stat);
out = FileBuffer(new _FileBuffer<unsigned char>(static_cast<unsigned long>(stat.size)));
zip_fread(file, out->GetAddress(), stat.size);
zip_fclose(file);
return true;
}
bool StdFileManager::GetFileBuffer(const str_type::string &fileName, FileBuffer &out)
{
#if _MSC_VER >= 1500
FILE *f = 0;
_wfopen_s(&f, fileName.c_str(), GS_L("rb"));
#else
FILE *f = _wfopen(fileName.c_str(), GS_L("rb"));
#endif
if (!f)
{
return false;
}
fseek(f, 0, SEEK_END);
const std::size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
out = FileBuffer(new _FileBuffer<unsigned char>(len));
fread(out->GetAddress(), len, 1, f);
fclose(f);
return true;
}
void MapTile::save()
{
FileBuffer buffer;
// MVER
writeChunkHeader(buffer, "MVER", sizeof(MVER));
buffer.write(&mver, sizeof(MVER));
// MHDR
writeChunkHeader(buffer, "MHDR", sizeof(MHDR));
FileBuffer::DataPtr<MHDR> mhdrPtr = buffer.ptr<MHDR>();
buffer.write(&mhdr, sizeof(MHDR));
// MCIN
mhdrPtr->mcin = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MCIN", sizeof(MCIN));
FileBuffer::DataPtr<ENTRY_MCIN> mcinPtr = buffer.ptr<ENTRY_MCIN>();
buffer.write(&mhdr, sizeof(MCIN));
// MTEX
mhdrPtr->mtex = buffer.tell() - 0x14;
{
FileBuffer texBuffer;
for(auto it = mtex.begin(); it != mtex.end(); ++it)
{
texBuffer.write((char*)it->c_str(), it->size() + 1);
}
writeChunkHeader(buffer, "MTEX", texBuffer.size());
buffer.write(&texBuffer);
}
//MMDX
mhdrPtr->mmdx = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MMDX", mmdx.size());
buffer.write(&mmdx);
//MMID
mhdrPtr->mmid = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MMID", mmid.size());
buffer.write(&mmid);
//MWMO
mhdrPtr->mwmo = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MWMO", mwmo.size());
buffer.write(&mwmo);
//MWID
mhdrPtr->mwid = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MWID", mwid.size());
buffer.write(&mwid);
//MDDF
mhdrPtr->mddf = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MDDF", mddf.size());
buffer.write(&mddf);
//MODF
mhdrPtr->modf = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MODF", modf.size());
buffer.write(&modf);
//MH2O
if(mh2o.size())
{
mhdrPtr->mh2o = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MH2O", mh2o.size());
buffer.write(&mh2o);
}
else
{
mhdrPtr->mh2o = 0;
}
//chunks
for (auto it = chunks.begin(); it != chunks.end(); ++it)
{
FileBuffer chunk = (*it)->write();
mcinPtr->offset = buffer.tell();
mcinPtr->size = chunk.size();
mcinPtr->asyncID = 32;
mcinPtr->flags = 32;
buffer.write(&chunk);
mcinPtr++;
}
//MFBO
if(mfbo.size())
{
mhdrPtr->mfbo = buffer.tell() - 0x14;
mhdrPtr->flags |= 1;
writeChunkHeader(buffer, "MFBO", mfbo.size());
buffer.write(&mfbo);
}
else
{
mhdrPtr->mfbo = 0;
mhdrPtr->flags &= ~1;
}
//MTFX
if(mtfx.size())
{
mhdrPtr->mtfx = buffer.tell() - 0x14;
writeChunkHeader(buffer, "MTFX", mtfx.size());
buffer.write(&mtfx);
}
else
{
mhdrPtr->mtfx = 0;
}
File file(filename.toStdString(), File::write);
file.write_from(&buffer);
}
int main(int argc, char* argv[])
{
mozilla::ScopedDeletePtr<SzipAction> action;
char **firstArg;
bool compress = true;
size_t chunkSize = 0;
SeekableZStream::FilterId filter = SzipCompress::DEFAULT_FILTER;
size_t dictSize = (size_t) 0;
for (firstArg = &argv[1]; argc > 2; argc--, firstArg++) {
if (!firstArg[0] || firstArg[0][0] != '-')
break;
if (strcmp(firstArg[0], "-d") == 0) {
compress = false;
} else if (strcmp(firstArg[0], "-c") == 0) {
firstArg++;
argc--;
if (!firstArg[0])
break;
if (!GetSize(firstArg[0], &chunkSize) || !chunkSize ||
(chunkSize % 4096) || (chunkSize > maxChunkSize)) {
log("Invalid chunk size");
return 1;
}
} else if (strcmp(firstArg[0], "-f") == 0) {
firstArg++;
argc--;
if (!firstArg[0])
break;
bool matched = false;
for (int i = 0; i < sizeof(filterName) / sizeof(char *); ++i) {
if (strcmp(firstArg[0], filterName[i]) == 0) {
filter = static_cast<SeekableZStream::FilterId>(i);
matched = true;
break;
}
}
if (!matched) {
log("Invalid filter");
return 1;
}
} else if (strcmp(firstArg[0], "-D") == 0) {
firstArg++;
argc--;
if (!firstArg[0])
break;
if (strcmp(firstArg[0], "auto") == 0) {
dictSize = -1;
} else if (!GetSize(firstArg[0], &dictSize) || (dictSize >= 1 << 16)) {
log("Invalid dictionary size");
return 1;
}
}
}
if (argc != 2 || !firstArg[0]) {
log("usage: %s [-d] [-c CHUNKSIZE] [-f FILTER] [-D DICTSIZE] file",
argv[0]);
return 1;
}
if (compress) {
action = new SzipCompress(chunkSize, filter, dictSize);
} else {
if (chunkSize) {
log("-c is incompatible with -d");
return 1;
}
if (dictSize) {
log("-D is incompatible with -d");
return 1;
}
action = new SzipDecompress();
}
std::stringstream tmpOutStream;
tmpOutStream << firstArg[0] << ".sz." << getpid();
std::string tmpOut(tmpOutStream.str());
int ret;
struct stat st;
{
FileBuffer origBuf;
if (!origBuf.Init(firstArg[0])) {
log("Couldn't open %s: %s", firstArg[0], strerror(errno));
return 1;
}
ret = fstat(origBuf.getFd(), &st);
if (ret == -1) {
log("Couldn't stat %s: %s", firstArg[0], strerror(errno));
return 1;
}
size_t origSize = st.st_size;
/* Mmap the original file */
if (!origBuf.Resize(origSize)) {
log("Couldn't mmap %s: %s", firstArg[0], strerror(errno));
return 1;
}
/* Create the compressed file */
FileBuffer outBuf;
if (!outBuf.Init(tmpOut.c_str(), true)) {
log("Couldn't open %s: %s", tmpOut.c_str(), strerror(errno));
return 1;
}
ret = action->run(firstArg[0], origBuf, tmpOut.c_str(), outBuf);
if ((ret == 0) && (fstat(outBuf.getFd(), &st) == -1)) {
st.st_size = 0;
}
}
if ((ret == 0) && st.st_size) {
rename(tmpOut.c_str(), firstArg[0]);
} else {
unlink(tmpOut.c_str());
}
return ret;
}
int MeshInfoSet::Load(FileBuffer& buffer, int printLog)
{
if (buffer.Eof())
return -1;
int rtn = 0;
rtn = buffer.GetNextData(mTotalCitationNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mUniqueMeshNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mUniqueMeshPairNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mSumMeshOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mMeshOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mMeshPairOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mTitleMeshEntryOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mTitleMeshEntryPairOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mAbstractMeshEntryOcurNum);
CHECK_RTN(rtn);
rtn = buffer.GetNextData(mAbstractMeshEntryPairOcurNum);
CHECK_RTN(rtn);
rtn = InitializeMeshNeiboNum(mMeshPairOcurNum, mMeshNeiboNum);
CHECK_RTN(rtn);
if (printLog != SILENT)
clog << "MeshInfoSet load completed, loaded " << mTotalCitationNum << " citations" << endl;
return 0;
}
void ProjectSettings::loadBinary(FileBuffer& source, QImage* img)
{
clear();
source.load(_name);
source.load(_designer);
source.load(_length);
source.load(_beam);
source.load(_draft);
source.load(_main_particulars_has_been_set);
source.load(_water_density);
source.load(_appendage_coefficient);
source.load(_shade_underwater_ship);
source.load(_underwater_color);
quint32 n;
source.load(n);
_units = static_cast<unit_type_t>(n);
source.load(_use_default_mainframe_location);
source.load(_mainframe_location);
source.load(_disable_model_check);
source.load(_comment);
source.load(_file_created_by);
_save_preview = true;
if (_owner->getFileVersion() >= fv210) {
source.load(n);
_hydrostatic_coefficients = static_cast<hydrostatic_coeff_t>(n);
source.load(_save_preview);
if (_save_preview) {
_preview_img = new JPEGImage();
source.load(*_preview_img);
}
if (_owner->getFileVersion() >= fv230) {
source.load(_simplify_intersections);
}
if (_owner->getFileVersion() >= fv250) {
source.load(_start_draft);
source.load(_end_draft);
source.load(_draft_step);
source.load(_trim);
source.load(n);
for (size_t i=0; i<n; i++) {
float f;
source.load(f);
_displacements.push_back(f);
}
source.load(_min_displacement);
source.load(_max_displacement);
source.load(_displ_increment);
source.load(_use_displ_increments);
source.load(n);
_angles.clear();
for (size_t i=0; i<n; i++) {
float f;
source.load(f);
_angles.push_back(f);
}
source.load(n);
_stab_trims.clear();
for (size_t i=0; i<n; i++) {
float f;
source.load(f);
_stab_trims.push_back(f);
}
source.load(_free_trim);
source.load(_fvcg);
}
}
}
void ProjectSettings::saveBinary(FileBuffer& dest)
{
if (_owner->getFileVersion() >= fv120) {
dest.add(_name);
dest.add(_designer);
dest.add(_length);
dest.add(_beam);
dest.add(_draft);
dest.add(_main_particulars_has_been_set);
dest.add(_water_density);
dest.add(_appendage_coefficient);
dest.add(_shade_underwater_ship);
dest.add(_underwater_color);
dest.add(static_cast<quint32>(_units));
if (_owner->getFileVersion() >= fv160) {
dest.add(_use_default_mainframe_location);
dest.add(_mainframe_location);
if (_owner->getFileVersion() >= fv165) {
dest.add(_disable_model_check);
}
}
dest.add(_comment);
dest.add(_file_created_by);
if (_owner->getFileVersion() >= fv210) {
dest.add(static_cast<quint8>(_hydrostatic_coefficients));
dest.add(_save_preview);
if (_save_preview) {
// save the jpg
}
if (_owner->getFileVersion() >= fv230) {
dest.add(_simplify_intersections);
}
if (_owner->getFileVersion() >= fv250) {
dest.add(_start_draft);
dest.add(_end_draft);
dest.add(_draft_step);
dest.add(_trim);
dest.add(_displacements.size());
for (size_t i=0; i<_displacements.size(); i++)
dest.add(_displacements[i]);
dest.add(_min_displacement);
dest.add(_max_displacement);
dest.add(_displ_increment);
dest.add(_use_displ_increments);
dest.add(_angles.size());
for (size_t i=0; i<_angles.size(); i++)
dest.add(_angles[i]);
dest.add(_stab_trims.size());
for (size_t i=0; i<_stab_trims.size(); i++)
dest.add(_stab_trims[i]);
dest.add(_free_trim);
dest.add(_fvcg);
}
}
}
}
