/// This function reads data from file void readFile( std::string t_filepath ) { std::ifstream a_csvread( t_filepath.c_str() ); if(!a_csvread.is_open()) std::cout << "Error at opening file: " << t_filepath << std::endl; else { // file is available // read file header HeaderData a_header; readHeader( a_csvread, a_header ); std::cout << a_header.m_versionString << ": " << a_header.m_major << "." << a_header.m_minor << std::endl; std::cout << a_header.m_numberOfDataString << ": " << a_header.m_numberOfDataItems << std::endl; // read file data for( CenterPoint a_data; readData( a_csvread, a_data ); ) { // Nice for-loop std::cout << a_data.m_name << ", x=" << a_data.m_x << ", y=" << a_data.m_y << std::endl; } a_csvread.close(); } }
bool Foam::IOobject::headerOk() { bool ok = true; Istream* isPtr = objectStream(); // If the stream has failed return if (!isPtr) { if (objectRegistry::debug) { Info << "IOobject::headerOk() : " << "file " << objectPath() << " could not be opened" << endl; } ok = false; } else { // Try reading header if (!readHeader(*isPtr)) { if (objectRegistry::debug) { IOWarningIn("IOobject::headerOk()", (*isPtr)) << "failed to read header of file " << objectPath() << endl; } ok = false; } } delete isPtr; return ok; }
bool BasePersistenceManager::initLoad(const Common::String &filename) { if (DID_FAIL(readHeader(filename))) { cleanup(); return STATUS_FAILED; } _saving = false; if (_savedName == "" || scumm_stricmp(_savedName.c_str(), _gameRef->getName()) != 0) { debugC(kWintermuteDebugSaveGame, "ERROR: Saved game name doesn't match current game"); cleanup(); return STATUS_FAILED; } // if save is newer version than we are, fail if (_savedVerMajor > DCGF_VER_MAJOR || (_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor > DCGF_VER_MINOR) || (_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor == DCGF_VER_MINOR && _savedVerBuild > DCGF_VER_BUILD) ) { debugC(kWintermuteDebugSaveGame, "ERROR: Saved game version is newer than current game"); debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild); cleanup(); return STATUS_FAILED; } // if save is older than the minimal version we support if (_savedVerMajor < SAVEGAME_VER_MAJOR || (_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor < SAVEGAME_VER_MINOR) || (_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor == SAVEGAME_VER_MINOR && _savedVerBuild < SAVEGAME_VER_BUILD) ) { debugC(kWintermuteDebugSaveGame, "ERROR: Saved game is too old and cannot be used by this version of game engine"); debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild); cleanup(); return STATUS_FAILED; } return STATUS_OK; }
FfhReader::FfhReader(const std::string& filename) : HistogramReader(filename) { readHeader(); auto it = images.find("IntensityNormalisation"); if (it != images.end()) { intensity_normalisation = it->second; auto size = intensity_normalisation.size(); std::vector<int> dims = { 1, size.height, size.width }; intensity_normalisation = intensity_normalisation.reshape(0, 3, &dims[0]); // For old-style uncorrected (for #frames) normalisation maps, correct based on maximum if (intensity_normalisation.type() == CV_16U) { double mn, mx; cv::minMaxIdx(intensity_normalisation, &mn, &mx); intensity_normalisation.convertTo(intensity_normalisation, CV_32F, 1.0 / mx, 0); } } }
SaveStateList SaveFileManager::list(const Common::String &target) { Common::SaveFileManager *saveFileMan = g_system->getSavefileManager(); Common::StringArray files = saveFileMan->listSavefiles(target + ".###"); SaveStateList saveList; for (Common::StringArray::const_iterator fileName = files.begin(); fileName != files.end(); ++fileName) { Common::InSaveFile *saveFile = saveFileMan->openForLoading(*fileName); if (saveFile == nullptr || saveFile->err()) { continue; } BladeRunner::SaveFileHeader header; readHeader(*saveFile, header); int slotNum = atoi(fileName->c_str() + fileName->size() - 3); saveList.push_back(SaveStateDescriptor(slotNum, header._name)); } Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator()); return saveList; }
void Decoder::decode(std::string inFileName,std::string outFileName,bool mode) { //open input file std::string inName(inFileName); if (inName.rfind(".ebast",inName.size()-6) == std::string::npos) { std::cerr << "This isn't a ebast File" << std::endl; exit(1); } inFile.open(inFileName, std::ios::in | std::ios::binary); if (!inFile.is_open()) { std::cerr << "Unable to read File" << std::endl; exit(1); } //open output file std::string outName(outFileName); outName += ".txt"; if(std::ifstream(outName.c_str())) { std::cerr<<outName<<" already exists!"<<std::endl; exit(1); } outFile.open(outName.c_str(),std::ios::out | std::ios::binary); if (!outFile.is_open()) { std::cerr << "Unable to create File" << std::endl; exit(1); } //reading frequency table from file huffmanTree->setRoot(readHeader()); if (mode) { print(huffmanTree->getRoot()); } //make file makeFile(); }
int IfdMakerNote::read(const byte* buf, long len, long start, ByteOrder byteOrder, long shift) { // Remember the offset offset_ = start - shift; // Set byte order if none is set yet if (byteOrder_ == invalidByteOrder) byteOrder_ = byteOrder; // Read and check the header (and set offset adjustment) int rc = readHeader(buf + start, len - start, byteOrder); if (rc == 0) { rc = checkHeader(); } // Adjust shift long newShift = absShift_ ? shift + shift_ : start + shift_; // Read the makernote IFD if (rc == 0) { rc = ifd_.read(buf, len, start + start_, byteOrder_, newShift); } if (rc == 0) { // IfdMakerNote currently does not support multiple IFDs if (ifd_.next() != 0) { #ifndef SUPPRESS_WARNINGS std::cerr << "Warning: Makernote IFD has a next pointer != 0 (" << ifd_.next() << "). Ignored.\n"; #endif } } #ifdef DEBUG_MAKERNOTE hexdump(std::cerr, buf + start, len - start); if (rc == 0) ifd_.print(std::cerr); #endif return rc; } // IfdMakerNote::read
void GameApp::BuildLevel() { ifstream infile("tilemap.txt"); string line; while (getline(infile, line)) { if (line == "[header]") { if (!readHeader(infile)) { return; } } else if (line == "[layer]") { readLayerData(infile); } else if (line == "[Object Layer 1]") { readEntityData(infile); } } }
void ModelBinaryLoader::loadBinaryFile(std::string p_FilePath) { clearData(); std::ifstream input(p_FilePath, std::istream::in | std::istream::binary); if(!input) { throw std::runtime_error("File could not be opened: " + p_FilePath); } m_FileHeader = readHeader(&input); m_Material = readMaterial(m_FileHeader.m_NumMaterial,&input); if(m_FileHeader.m_Animated) { m_AnimationVertexBuffer = readVertexBufferAnimation(m_FileHeader.m_NumVertex, &input); calculateBoundingVolume(m_AnimationVertexBuffer); } else { m_VertexBuffer = readVertexBuffer(m_FileHeader.m_NumVertex, &input); calculateBoundingVolume(m_VertexBuffer); } m_MaterialBuffer = readMaterialBuffer(m_FileHeader.m_NumMaterialBuffer, &input); }
bool MP3Stream::seek(const Timestamp &where) { if (where == _length) { _state = MP3_STATE_EOS; return true; } else if (where > _length) { return false; } const uint32 time = where.msecs(); mad_timer_t destination; mad_timer_set(&destination, time / 1000, time % 1000, 1000); if (_state != MP3_STATE_READY || mad_timer_compare(destination, _totalTime) < 0) initStream(); while (mad_timer_compare(destination, _totalTime) > 0 && _state != MP3_STATE_EOS) readHeader(); decodeMP3Data(); return (_state != MP3_STATE_EOS); }
int recvFrom (Peer *peer, byte *headerBuf, byte *dataBuf) { int headerSize = readHeader(peer, headerBuf, HEADERSIZE); if(headerSize == 0 ) { printf("Non Header \n"); return 0; } int length = byteToInt(headerBuf, 8); int dataSize = readData(peer , dataBuf, length ); printf("[ from %s ] type : %d, redesc : %d length : %d data : %s \n", peer->ip, byteToInt(headerBuf,0), byteToInt(headerBuf, 4), byteToInt(headerBuf, 8), dataBuf); return (headerSize + dataSize); }
void decompress(InputStream& inputStream, OutputBuffer& output, header* pHeader) { header h; if (pHeader) { h = *pHeader; } else { readHeader(inputStream, h); } uint8* pInputBuffer = new uint8[h.fileSize]; uint8* pOutputBuffer = new uint8[h.fileSize]; ArithmeticDecoder decoder(inputStream); StructuredModel model(h.increments); model.decode(decoder, pInputBuffer, h.tempSize); iMTF(pInputBuffer, h.tempSize); iBWT(pInputBuffer, pOutputBuffer, h.tempSize, h.first); iRLE(pOutputBuffer, pInputBuffer, h.tempSize); output.setBuffer(pInputBuffer, h.fileSize); delete[] pOutputBuffer; }
int readFile (char *filename, int *rows, int *cols, PIXEL** bitmap) { int fd, ret; unsigned int start; if(filename) { if((fd = open(filename, O_RDONLY)) < 0) { perror("Can't open bmp file to read"); return -1; } } else fd = STDIN_FILENO; ret = readHeader (fd, rows, cols, &start); if(ret) return ret; *bitmap = (PIXEL*)malloc(sizeof(PIXEL)*(*rows)*(*cols)); ret = readBits (fd, *bitmap, *rows, *cols, start); if(ret) return ret; if(filename) close(fd); return 0; }
void MDNS::getResponses() { QueryHeader header = readHeader(buffer); if ((header.flags & 0x8000) == 0 && header.qdcount > 0) { uint8_t count = 0; while (count++ < header.qdcount && buffer->available() > 0) { Label * label = matcher->match(labels, buffer); if (buffer->available() >= 4) { uint16_t type = buffer->readUInt16(); uint16_t cls = buffer->readUInt16(); if (label != NULL) { label->matched(type, cls); } } else { status = "Buffer underflow at index " + buffer->getOffset(); } } } }
bool Table::rewind() { xmlTextReaderPtr reader = NULL; if ( (reader = xmlNewTextReaderFilename(getName().c_str())) == NULL) { cout<<endl<<"Essai d'ouvrir "<< getName() <<endl; cout << "erreur fatale " << endl; return (false); } xmlTextReaderRead(reader); // initialisation du xmlReader setXmlReader(reader); // Utilise readHeader() readHeader(); // le tuple courant est 0 currentTuple = 0; return (true); }
//--------------------------------------------------------------------- uint32 StreamSerialiser::peekNextChunkID() { checkStream(); if (eof()) return 0; // Have we figured out the endian mode yet? if (mReadWriteHeader) readHeader(); if (mEndian == ENDIAN_AUTO) OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Endian mode has not been determined, did you disable header without setting?", "StreamSerialiser::peekNextChunkID"); size_t homePos = mStream->tell(); uint32 ret; read(&ret); mStream->seek(homePos); return ret; }
static void readTemplate(template_t *t, tfile_t *tf) { int magic; readScalar(magic, tf); assert(magic == TMPL_MAGIC); /* Already checked by caller */ readHeader(t, tf); readScalar(t->tm_flags, tf); t->tm_flags |= TMPL_TF_IMPORTED; readScalar(t->tm_alignment, tf); readScalar(t->tm_minsize, tf); readTemplateRefs(t, tf); if (tf->tf_errors) { /* Failed to import all structs we ref. Bail out now. */ return; } readAttributes(t, tf); if (isRedirectTmpl(t)) { readTmplRedirection(t, tf); } readTmplFormat(t, tf); }
/* Write what is in the memPage to the pageNumth block. * The value of curPagePos was set to pageNum after writing. */ RC writeBlock (int pageNum, SM_FileHandle *fHandle, SM_PageHandle memPage) { FILE *fp; int totalNumPages; char *buff; if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND; fp = fopen(fHandle->fileName, "r+"); buff = (char*)malloc(sizeof(char)*PAGE_SIZE); if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR; //check if pageNum is valid if ((pageNum >= totalNumPages) || (pageNum < 0)) return RC_READ_NON_EXISTING_PAGE; //read till the (pageNum - 1)th page int i; for (i = 0; i < pageNum; i++) { fread(buff, sizeof(char)*PAGE_SIZE, 1, fp); } //write memPage to the pageNum if (fwrite(memPage, sizeof(char)*PAGE_SIZE, 1, fp) < 1) return RC_WRITE_FAILED; // printf("WRITED TO DISK (page-%i): %s\n", pageNum, memPage); // printf("#### Writed page (%d) to disk! ####\n", pageNum); fHandle->curPagePos = pageNum; free(buff); fclose(fp); return RC_OK; }
/* If the file has less than numberOfPages pages, then increase the size to numberOfPages. * The increasing is done by appending (numberOfPages - totalNumPages) empty blocks * at the end of file. */ RC ensureCapacity (int numberOfPages, SM_FileHandle *fHandle) { FILE *fp; int totalNumPages, i; char *buff; if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND; fp = fopen(fHandle->fileName, "r+"); buff = (char*)malloc(sizeof(char)*PAGE_SIZE); if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR; if (numberOfPages > totalNumPages) { for (i = 0; i < (numberOfPages - totalNumPages); i++) { appendEmptyBlock(fHandle); } } // log file info to console struct stat fileStat; if(stat(fHandle->fileName,&fileStat) < 0) return RC_FILE_R_W_ERROR; // printf("\n\n**ENSURE LOG**\n"); // printf("************************************\n"); // printf("File Name: \t\t%s\n",fHandle->fileName); // printf("File Size: \t\t%lld bytes\n",fileStat.st_size); // printf("Total # Pages: \t%d\n",fHandle->totalNumPages); free(buff); fclose(fp); return RC_OK; }
RecordStorage::RecordStorage(int32_t maxRecordSize, char* fileName, int32_t id_msb, int32_t id_lsb, Stream* debugStream) { closed = false; debug = debugStream; // if(debug != NULL) // { // debug->print("Record Storage: "); // debug->println(fileName); // debug->print("Record Size: "); // debug->println(maxRecordSize); // } file_name = fileName; error_code = 0; header = NULL; // magic = HEADER_MAGIC_NUMBER; if (SD.exists(fileName) ) { // if(debug != NULL) // { // debug->print("Record File Size: "); // debug->println(store.size()); // } readHeader(); if(header->maxRecordSize != maxRecordSize) { error_code = error_code | ERROR_ROW_SIZE_MISMATCH; } } else { header = (RecordHeader*) calloc(sizeof(RecordHeader), 1); header->magicNumber = HEADER_MAGIC_NUMBER; header->maxRecordSize = maxRecordSize; header->uploaded = 0; header->id_lsb = id_lsb; header->id_msb = id_msb; writeHeader(); } }
RlfAnimation::RlfAnimation(const Common::String &fileName, bool stream) : _stream(stream), _readStream(NULL), _lastFrameRead(0), _frameCount(0), _width(0), _height(0), _frameTime(0), _frames(0), _nextFrame(0), _frameBufferByteSize(0) { Common::File *_file = new Common::File; if (!_file->open(fileName)) { warning("RLF animation file %s could not be opened", fileName.c_str()); return; } _readStream = _file; if (!readHeader()) { warning("%s is not a RLF animation file. Wrong magic number", fileName.c_str()); return; } _currentFrameBuffer.create(_width, _height, Graphics::createPixelFormat<565>()); _frameBufferByteSize = _width * _height * sizeof(uint16); if (!stream) { _frames = new Frame[_frameCount]; // Read in each frame for (uint i = 0; i < _frameCount; ++i) { _frames[i] = readNextFrame(); } } }
G12Buffer* PPMLoader::g12BufferCreateFromPGM(const string& name, MetaData *meta) { // open file for reading in binary mode FILE *fp = fopen(name.c_str(), "rb"); if (fp == nullptr) return nullptr; // PPM headers variable declaration unsigned long h, w; uint8_t type; uint16_t maxval; if (!readHeader(fp, &h, &w, &maxval, &type, meta) || (type != 5 && type != 6)) { fclose(fp); return nullptr; } bool calcWhite = false; int white = 0; // if no metadata is present, create some // if metadata is null, don't if (meta != nullptr) { // create an alias to metadata MetaData &metadata = *meta; // get significant bit count if (metadata["bits"].empty()) { metadata["bits"].push_back(1); } while (maxval >> int(metadata["bits"][0])) { metadata["bits"][0]++; } if (metadata["white"].empty()) calcWhite = true; }
int main(int argc, char ** argv) { if(argc != 3) { printf("ERROR! There should be three input arguments, the object file, the input file and the output file"); return EXIT_FAILURE; } FILE * ftpr; ftpr = fopen(argv[1],"r"); if(ftpr == NULL) { printf("\n Error! The input file could not be opened"); return EXIT_FAILURE; } fclose(ftpr); HuffNode * Huffmannroot = NULL; int filetype = readHeader(argv[1]); if(filetype == 0) { Huffmannroot = create_Huffmanntree(argv[1]); } else { Huffmannroot = create_HufftreeBit(argv[1]); } FILE * ftpr2 = fopen(argv[2],"w"); if(ftpr2 == NULL) { printf("Error! The output filename argument could not be opened."); return EXIT_FAILURE; } Huff_postOrderPrint(Huffmannroot, ftpr2); tree_destroy(Huffmannroot); fclose(ftpr2); return EXIT_SUCCESS; }
bool CImageGIF:: readHeader(CFile *file, CImagePtr &image) { file->rewind(); try { CImageGIFHeader header; readHeader(file, image, &header); //------ image->setType(CFILE_TYPE_IMAGE_GIF); image->setSize(header.width, header.height); } catch (...) { CImage::errorMsg("Failed to read GIF file"); return false; } return true; }
int History::save(QString user, QDateTime date, QString* lpszData) { lmcSettings settings; QString path = historyFile(); QDir dir = QFileInfo(path).dir(); if(!dir.exists()) dir.mkpath(dir.absolutePath()); if(!QFile::exists(path)) create(path); QFile file(path); if(!file.open(QIODevice::ReadWrite)) return -1; QDataStream stream(&file); DBHeader header = readHeader(&stream); if(header.marker.compare(HC_DBMARKER) != 0) { file.close(); return -1; } qint64 dataPos = insertData(&stream, lpszData); qint64 newIndex = insertIndex(&stream, dataPos, user, date); updateIndex(&stream, header.last, newIndex); header.count++; header.first = (header.first == 0) ? newIndex : header.first; header.last = newIndex; writeHeader(&stream, &header); file.close(); return 0; }
int HttpClient::skipResponseHeaders() { isChunk = 0; header_line = ""; // Just keep reading until we finish reading the headers or time out unsigned long timeoutStart = millis(); // Whilst we haven't timed out & haven't reached the end of the headers while ((!endOfHeadersReached()) && ( (millis() - timeoutStart) < iHttpResponseTimeout )) { if (available()) { (void)readHeader(); // We read something, reset the timeout counter timeoutStart = millis(); } else { // We haven't got any data, so let's pause to allow some to // arrive delay(kHttpWaitForDataDelay); } } if (endOfHeadersReached()) { // Success return HTTP_SUCCESS; } else { // We must've timed out return HTTP_ERROR_TIMED_OUT; } }
QList<MsgInfo> History::getList(void) { QList<MsgInfo> list; lmcSettings settings; QString path = historyFile(); if(!QFile::exists(path)) return list; QFile file(path); if(!file.open(QIODevice::ReadOnly)) return list; QDataStream stream(&file); DBHeader header = readHeader(&stream); qint64 next = header.first; QString marker; qint64 offset; qint64 date; QString name; while(next != 0) { stream.device()->seek(next); MsgInfo info; stream >> marker; stream >> next; stream >> offset; stream >> date; stream >> name; list.append(MsgInfo(name, QDateTime::fromMSecsSinceEpoch(date), offset)); } return list; }
bool ProjectManagerXML::Open(const wxString &filename, const wxString &syslabels_path) { bool ret; wxXmlDocument xml_doc; ret = xml_doc.Load(filename); if (ret) { readHeader(xml_doc); readFileProperties(xml_doc); if (process->SetupSystemLabels()) { process->LoadSystemLabels(syslabels_path); } readDasmData(xml_doc); readCodeLine(xml_doc); readLabel(xml_doc, process->io_labels, SECTION_IOLABEL_STR); readLabel(xml_doc, process->var_labels, SECTION_VARLABEL_STR); readLabel(xml_doc, process->prog_labels, SECTION_PROGRAMLABEL_STR); readLabel(xml_doc, process->constant_labels, SECTION_CONSTANTLABEL_STR); } return ret; }
// Constructor STORAGE::Filesystem::Filesystem(const char* fname) : file(fname), shuttingDown(false) { resetStats(); MVCC = false; // Set up file directory if the backing file is new. if (file.isNew()) { logEvent(EVENT, "Backing file is new"); dir = new FileDirectory(); writeFileDirectory(dir); } else { logEvent(EVENT, "Backing file exists, populating lookup table"); dir = readFileDirectory(); std::ostringstream os; os << dir->numFiles; logEvent(EVENT, "Number of stored files is " + os.str()); // Populate lookup table for (File i = 0; i < dir->numFiles; ++i) { dir->headers[i] = readHeader(i); std::string name(dir->headers[i].name); lookup[name] = i; } } }
bool CGIFImage:: readHeader(CFile *file, CGenImage *image) { file->rewind(); try { CGIFImageHeader header; readHeader(file, image, &header); //------ image->setType(CFILE_TYPE_IMAGE_GIF); image->setSize(header.width, header.height); } catch (...) { CTHROW("Failed to read GIF file"); return false; } return true; }