void DBMS::openTable(queue<Token> params){ FileIO fileManager; string table_name; relation intoTable; //first token in string is name of table table_name=params.front().value; params.pop(); try{ intoTable = fileManager.readFromFile(table_name, 0); }catch(...){ cout<<"Error: Table "<<table_name<<" could not be found"<<endl; return; } //Table already in memory, delete it from queryResults and 6then push back the new one vector<relation>::iterator it; for (it= queryResults.begin(); it < queryResults.end(); it++){ if (it->name == table_name){ queryResults.erase(it); break; } } queryResults.push_back(intoTable); }
//---------------------------------------------------------------------------- bool Lattice::Load (FileIO& inFile) { int numBytes = (int)strlen(msHeader) + 1; char* buffer = new1<char>(numBytes); inFile.Read(sizeof(char), numBytes, buffer); buffer[numBytes-1] = 0; if (strncmp(buffer, msHeader, numBytes) != 0) { delete1(buffer); mNumDimensions = 0; mQuantity = 0; mBounds = 0; mOffsets = 0; return false; } delete1(buffer); inFile.Read(sizeof(int), &mNumDimensions); delete1(mBounds); mBounds = new1<int>(mNumDimensions); inFile.Read(sizeof(int), mNumDimensions, mBounds); delete1(mOffsets); mOffsets = new1<int>(mNumDimensions); ComputeQuantityAndOffsets(); return true; }
void * FileIO::threadFunction(void * ptr) { FileIO *me = (FileIO *)ptr; // printf("D: %d\n", me->mDuration); #ifdef DO_TIMING int sleepTime; struct timeval *meThen = &me->mThen; struct timeval *meNow = & me->mNow; #endif while (me->mIsPlaying) { // loop until turned off #ifdef DO_TIMING GET_TIME(meThen); #endif me->writeNextBuffer(); // get and write the next buffer #ifdef DO_TIMING GET_TIME(meNow); me->printTimeStatistics(meNow, meThen, & me->mThisSec, & me->mTimeSum, & me->mTimeVals); GET_TIME(meNow); sleepTime = me->mDuration - (((meNow->tv_sec - meThen->tv_sec) * 1000000) + (meNow->tv_usec - meThen->tv_usec)); // printf("S: %d\n", sleepTime); if (sleepTime > 0) csl::sleepUsec(sleepTime); #else csl::sleepUsec(me->mDuration); #endif } // do this to prevent a race condition me->mIsThreadRunning = false; logMsg("Stopping sound file output thread"); return 0; }
void SessionItem::handleDownloadedFirmware() { FileIO f; f.writeRawByFilename(getTmpPathForFirmware() + "/firmware.bin", m_firmware_fd->downloadedData()); emit firmwareDownloaded(); disconnect(m_firmware_fd, SIGNAL(downloaded()), this, SLOT(handleDownloadedFirmware())); }
Matrix* Picture::getPerspectiveTransform(char* fileName, int width, int height) { FileIO* inputFile = new FileIO(fileName, 1); //for reading //fov string line = inputFile->readLine(); //skip this line line = inputFile->readLine(); double fov = atof(line.c_str()); double angle = 3.1415927*fov/180.0; //get the angle in radians double xmax = tan(angle/2); //the width of the camera is determined by its fov double ymax = xmax*(height)/(width); //the height of the camera is determined by the aspect ratio of the panel upon which the image will be rendered //zmax line = inputFile->readLine(); //skip this line line = inputFile->readLine(); double zmax = atof(line.c_str()); //zmin line = inputFile->readLine(); //skip this line line = inputFile->readLine(); double zmin = atof(line.c_str()); Matrix* pn = AffineTransforms::perspectiveNorm(xmax, ymax, zmax, zmin); delete inputFile; return pn; }
void CDAccess_Image::ImageOpenBinary(const char *path, bool isIso) { NumTracks = FirstTrack = LastTrack = 1; total_sectors = 0; disc_type = DISC_TYPE_CDDA_OR_M1; auto &track = Tracks[1]; track = {}; FileIO fp; if(fp.open(path) != OK) { ErrnoHolder ene(errno); throw(MDFN_Error(ene.Errno(), _("Could not open file \"%s\": %s"), path, ene.StrError())); } track.fp = std::make_shared<FileIO>(std::move(fp)); track.FirstFileInstance = 1; track.DIFormat = DI_FORMAT_MODE1_RAW; if(isIso) { track.DIFormat = DI_FORMAT_MODE1; track.postgap = 150; total_sectors += track.postgap; } track.sectors = GetSectorCount(&track); total_sectors += track.sectors; }
int main(int argc, char *argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " inputfile outputfile" << std::endl; return 1; } FileIO fileIO; try { fileIO.loadFromFile(argv[1]); } catch(const std::runtime_error& e) { std::cerr << e.what() << std::endl; return 2; } std::cout << "Calibrating..." << std::endl; Eigen::Matrix3d calibrationMatrix = OdometryCalibration::calibrateOdometry(fileIO.measurements); std::cout << "Calibration finished. The calibration matrix is: " << std::endl; std::cout << calibrationMatrix << std::endl; std::vector<Odometry> calibratedOdometry; calibratedOdometry.reserve(fileIO.uncalibrated.size()); for (std::vector<Odometry>::const_iterator it = fileIO.uncalibrated.begin(); it != fileIO.uncalibrated.end(); ++it) { calibratedOdometry.push_back(OdometryCalibration::applyOdometryCorrection(*it, calibrationMatrix)); } try { fileIO.writeToFile(argv[2], calibratedOdometry); } catch(const std::runtime_error& e) { std::cerr << e.what() << std::endl; return 3; } return 0; }
//---------------------------------------------------------------------------- bool Lattice::Save (FileIO& outFile) const { outFile.Write(sizeof(char), (int)strlen(msHeader) + 1, msHeader); outFile.Write(sizeof(int), &mNumDimensions); outFile.Write(sizeof(int), mNumDimensions, mBounds); return true; }
int main() { cout<<"hello World"<<endl; FileIO f;// = new FileIO(); f.openFile("a.txt"); return 0; }
void SessionItem::handleDownloadedFirmware() { FileIO f; BossacWrapper bw; f.writeRawByFilename(bw.getTmpPathForFirmware() + "/firmware.bin", m_firmware_fd->downloadedData()); delete m_firmware_fd; m_firmware_fd = NULL; }
void HMMObservations::dump(std::string filename) { FILE* fp = fopen(filename.c_str(), "w"); assert(fp); FileIO fio; fio.writeUInt32(fp, nseq); fio.writeUInt32Array(fp, slen, nseq); fio.writeUInt32Array(fp, y, tot_len); fclose(fp); }
// --------------------------------------------------------------------------- // スナップショット保存 // bool WinCore::SaveShapshot(const char* filename) { LockObj lock(this); bool docomp = !!(config.flag2 & Config::compresssnapshot); uint size = devlist.GetStatusSize(); uint8* buf = new uint8[docomp ? size * 129 / 64 + 20 : size]; if (!buf) return false; memset(buf, 0, size); if (devlist.SaveStatus(buf)) { ulong esize = size * 129 / 64 + 20-4; if (docomp) { if (Z_OK != compress(buf+size+4, &esize, buf, size)) { delete[] buf; return false; } *(int32*) (buf+size) = -(long)esize; esize += 4; } SnapshotHeader ssh; memcpy(ssh.id, SNAPSHOT_ID, 16); ssh.major = ssmajor; ssh.minor = ssminor; ssh.datasize = size; ssh.basicmode = config.basicmode; ssh.clock = int16(config.clock); ssh.erambanks = uint16(config.erambanks); ssh.cpumode = int16(config.cpumode); ssh.mainsubratio = int16(config.mainsubratio); ssh.flags = config.flags | (esize < size ? 0x80000000 : 0); ssh.flag2 = config.flag2; for (uint i=0; i<2; i++) ssh.disk[i] = (int8) diskmgr->GetCurrentDisk(i); FileIO file; if (file.Open(filename, FileIO::create)) { file.Write(&ssh, sizeof(ssh)); if (esize < size) file.Write(buf+size, esize); else file.Write(buf, size); } } delete[] buf; return true; }
bool Delaunay<Real>::Save (FileIO& outFile) const { // Fixed-size members. int type = (int)mQueryType; outFile.Write(sizeof(int), &type); outFile.Write(sizeof(int), &mNumVertices); outFile.Write(sizeof(int), &mDimension); outFile.Write(sizeof(int), &mNumSimplices); outFile.Write(sizeof(Real), &mEpsilon); // The member mOwner is not streamed because on a Load call, this // object will allocate the vertices and own this memory. // Variable-size members. int numIndices; if (1 <= mDimension && mDimension <= 3) { numIndices = (mDimension+1)*mNumSimplices; outFile.Write(sizeof(int), &numIndices); outFile.Write(sizeof(int), numIndices, mIndices); outFile.Write(sizeof(int), numIndices, mAdjacencies); return true; } numIndices = 0; outFile.Write(sizeof(int), &numIndices); return mDimension == 0; }
TEST(OdometryCalibration, Calibration) { FileIO fileIO; std::string path = ros::package::getPath("odometry_calibration") + "/data/calib.dat"; try { fileIO.loadFromFile(path.c_str()); } catch(const std::runtime_error& e) { ASSERT_TRUE(false) << "Could not load calibration data file"; } Eigen::Matrix3d calibrationMatrix = OdometryCalibration::calibrateOdometry(fileIO.measurements); ASSERT_NEAR(-0.0754092, calibrationMatrix.determinant(), 1e-5); }
//---------------------------------------------------------------------------- void Visual::SaveVertexBuffer (FileIO& outFile) { int numElements = mVBuffer->GetNumElements(); int elementSize = mVBuffer->GetElementSize(); Buffer::Usage vbusage = mVBuffer->GetUsage(); int usage = (int)vbusage; outFile.Write(sizeof(int), &numElements); outFile.Write(sizeof(int), &elementSize); outFile.Write(sizeof(int), &usage); VertexBufferAccessor vba(mVFormat, mVBuffer); vba.Write(outFile); }
void HMM::save_parameters(std::string filename) { FileIO fio; FILE* fp = fopen(filename.c_str(), "w"); assert(fp); fio.writeUInt32(fp, hs); fio.writeUInt32(fp, os); fio.writeDoubleArray(fp, nu, hs); fio.writeDoubleArray(fp, Q, hs*hs); fio.writeDoubleArray(fp, g, hs*os); fclose(fp); }
bool Delaunay<Real>::Load (FileIO& inFile) { delete1(mIndices); delete1(mAdjacencies); // Fixed-size members. int type; inFile.Read(sizeof(int), &type); mQueryType = (Query::Type)type; inFile.Read(sizeof(int), &mNumVertices); inFile.Read(sizeof(int), &mDimension); inFile.Read(sizeof(int), &mNumSimplices); inFile.Read(sizeof(Real), &mEpsilon); // Variable-size members. int numIndices; inFile.Read(sizeof(int), &numIndices); if (1 <= mDimension && mDimension <= 3) { assertion(numIndices == (mDimension+1)*mNumSimplices, "Inconsistent index count\n"); mIndices = new1<int>(numIndices); mAdjacencies = new1<int>(numIndices); inFile.Read(sizeof(int), numIndices, mIndices); inFile.Read(sizeof(int), numIndices, mAdjacencies); return true; } mIndices = 0; mAdjacencies = 0; return mDimension == 0; }
bool FormatSniffer::wrap(FileIO& fin, bool caching) { char buf[caching?32768:100]; cache = ""; size_t bytes_read; if (caching) { while ((bytes_read=fin.fread(buf,1,sizeof(buf)))>0) { cache.append(buf,bytes_read); } } else { bytes_read = fin.fread(buf,1,sizeof(buf)); cache.append(buf,bytes_read); } return true; }
double soundReadSample24L_L(FileIO& soundfile) { unsigned char temp[3]; int32_t sample; soundfile.readLittleEndian(temp[2]); soundfile.readLittleEndian(temp[1]); soundfile.readLittleEndian(temp[0]); sample = temp[0]; sample = (sample << 8) | temp[1]; sample = (sample << 8) | temp[2]; if (temp[0] & 0x80) { sample = sample | 0xff000000; } return (double)sample / (int32_t)0x800000; }
void DBMS::writeTable(queue<Token> params){ FileIO fileManager; vector<relation>::iterator it; for (it= queryResults.begin(); it < queryResults.end(); it++){ if (it->name == params.front().value){ fileManager.printToFile(*it); break; } } if(it==queryResults.end()){ cout<<"Table "<<params.front().value<<" is not charged in memory."<<endl; return; } params.pop(); }
int main(){ FileIO * file = new FileIO("tube.txt"); vector<Station *> station_list = file->read_file_to_station_list(); vector<Station *> sorted_list = file->read_file_to_station_list(); std::sort(sorted_list.begin(), sorted_list.end(), sort_by_name); // print_all(sorted_list, station_list); // search_by_keyword(sorted_list, station_list); // mode_selection(sorted_list, station_list); //test section node<int> *_node = new node<int>(); // cout<<sorted_list[0]->get_station_index()<<endl; _node->data = sorted_list[0]->get_station_index(); AVL<int> *tree = new AVL<int>(_node); //new binary_tree<int>(_node); for(vector<Station *>::iterator it = sorted_list.begin() + 1;it != sorted_list.end();++it){ bool b_return = tree->insert((*it)->get_station_index()); // cout<<(*it)->get_station_index()<<" "<<b_return<<endl; } cout<<"done!"<<endl; // tree->traverse_inorder(tree->root); cout<<"Tree height is "<<tree->tree_height<<endl; node<int> *returned_node = tree->search(0); cout<<returned_node->data<<" "<<returned_node->height<<endl; node<int> *rhs = tree->root; // cout<<rhs->data<<" "<<rhs->height<<endl; rhs = rhs->rhs; node<int> min, max; // cout<<"d 1"<<endl; tree->find_min_from(rhs, min); // cout<<"d 2"<<endl; tree->find_max_from((tree->root)->lhs, max); cout<<"min in right branch is "<<min.data<<" "<<min.height<<endl; cout<<"max in left branch is "<<max.data<<" "<<max.height<<endl; cout<<"depth is "<<tree->find_depth(tree->root)<<endl; cout<<"left branch depth is "<<tree->find_depth((tree->root)->lhs)<<endl; cout<<"right branch depth is "<<tree->find_depth((tree->root)->rhs)<<endl; cout<<"balance factor is "<<tree->balance_factor(tree->root)<<endl; cout<<"tree is balanced? "<<tree->is_balanced(tree->root)<<endl; cout<<"tree root "<<(tree->root)->data<<endl; // delete[] tree->root; delete tree; return 0; }
//---------------------------------------------------------------------------- void VertexBufferAccessor::Write (FileIO& outFile) { assertion(mStride == mVBuffer->GetElementSize(), "Format stride and vertex size must match (for now).\n"); // 为VertexBuffer的顶点属性建立一张表。每个顶点的属性都有offset,属性元素字 // 节大小以及属性元素个数。举例来说,一个元素属性的offset为0,格式为AT_FLOAT3 // 具有的(offset,size,numComponents) = (0,4,3)。 Tuple<3, unsigned int> table[VertexFormat::AM_MAX_ATTRIBUTES]; const int numAttributes = mVFormat->GetNumAttributes(); unsigned int streamIndex, offset, index; VertexFormat::AttributeType type; VertexFormat::AttributeUsage usage; int j; for (j = 0; j < numAttributes; ++j) { mVFormat->GetAttribute(j, streamIndex, offset, type, usage, index); table[j][0] = offset; table[j][1] = VertexFormat::GetComponentSize(type); table[j][2] = VertexFormat::GetNumComponents(type); } // 将顶点持久化 const int numElements = mVBuffer->GetNumElements(); char* vertex = mData; for (int i = 0; i < numElements; ++i, vertex += mStride) { for (j = 0; j < numAttributes; ++j) { outFile.Write(table[j][1], table[j][2], vertex + table[j][0]); } } }
//---------------------------------------------------------------------------- void VertexBufferAccessor::Write (FileIO& outFile) { assertion(mStride == mVBuffer->GetElementSize(), "Format stride and vertex size must match (for now).\n"); // Build a table for the attributes of the vertex buffer. Each attribute // has an offset, a size for a component of the attribute, and the number // of components of that size. For example, an attribute with offset 0 // and type AT_FLOAT3 has (offset,size,numComponents) = (0,4,3). Tuple<3, unsigned int> table[VertexFormat::AM_MAX_ATTRIBUTES]; const int numAttributes = mVFormat->GetNumAttributes(); unsigned int streamIndex, offset, index; VertexFormat::AttributeType type; VertexFormat::AttributeUsage usage; int j; for (j = 0; j < numAttributes; ++j) { mVFormat->GetAttribute(j, streamIndex, offset, type, usage, index); table[j][0] = offset; table[j][1] = VertexFormat::GetComponentSize(type); table[j][2] = VertexFormat::GetNumComponents(type); } // Write vertices one at a time to allow for byte swapping (endianness). const int numElements = mVBuffer->GetNumElements(); char* vertex = mData; for (int i = 0; i < numElements; ++i, vertex += mStride) { for (j = 0; j < numAttributes; ++j) { outFile.Write(table[j][1], table[j][2], vertex + table[j][0]); } } }
/** * getZValues * Obtain the values for fov and zmax/zmin. * Preconditions: * The filename to read from. * The array to store the information. * Postconditions: * The array is filled: * 0 - fov * 1 - zmax * 2 - zmin */ void Picture::getZValues( char* fileName, double zs[] ) { FileIO* inputFile = new FileIO(fileName, 1); //for reading //eye vertex string line = inputFile->readLine(); //skip this line line = inputFile->readLine(); zs[0] = atof(line.c_str()); line = inputFile->readLine(); line = inputFile->readLine(); zs[1] = atof(line.c_str()); line = inputFile->readLine(); line = inputFile->readLine(); zs[2] = atof(line.c_str()); delete inputFile; }
GLuint Renderer::compileShaders(const char* code, GLenum shaderType){ GLuint ret = 0; ret = glCreateShader(shaderType); FileIO file; file; const char* adapt[1]; std::string temp(file.file2String(code)); adapt[0] = temp.c_str(); glShaderSource(ret, 1, adapt, 0); glCompileShader(ret); checkCompileStatuts(ret); return ret; }
//---------------------------------------------------------------------------- void Visual::SaveVertexFormat (FileIO& outFile) { int numAttributes = mVFormat->GetNumAttributes(); outFile.Write(sizeof(int), &numAttributes); for (int i = 0; i < numAttributes; ++i) { unsigned int streamIndex, offset, usageIndex; VertexFormat::AttributeType vftype; VertexFormat::AttributeUsage vfusage; mVFormat->GetAttribute(i, streamIndex, offset, vftype, vfusage, usageIndex); int type = (int)vftype; int usage = (int)vfusage; outFile.Write(sizeof(unsigned int), &streamIndex); outFile.Write(sizeof(unsigned int), &offset); outFile.Write(sizeof(int), &type); outFile.Write(sizeof(int), &usage); outFile.Write(sizeof(unsigned int), &usageIndex); } int stride = mVFormat->GetStride(); outFile.Write(sizeof(int), &stride); }
/** * Saves the board to a file * * @param fname * Name of file to save to * @return * True if board is successfully saved */ bool Board::Export(const string & fname) const { FileIO file; FILEIO_TABLE table; for (int i = 0; i < 9; ++i) { FILEIO_ROW row; for (int j = 0; j < 9; ++j) { char s[2]; // Because it needs to be added as a char* s[0] = m_board[j][i] + '0'; s[1] = '\0'; row.push_back(s); // Fill a row } table.push_back(row); // Add the row to the table w're going to save } file.SetFileName(fname); // Prepare FileIO object for saving. file.SetTable(table); return file.Save(); // Save returns true if all is successful. }
// --------------------------------------------------------------------------- // UpdateDrive // void DiskManager::UpdateDrive(Drive* drv) { if (!drv->holder || drv->sizechanged) return; CriticalSection::Lock lock(cs); int t; for (t=0; t<164 && !drv->modified[t]; t++) ; if (t < 164) { FileIO* fio = drv->holder->GetDisk(drv->index); if (fio) { for (; t<164; t++) { if (drv->modified[t]) { FloppyDisk::Sector* sec; int tracksize = 0; for (sec = drv->disk.GetFirstSector(t); sec; sec=sec->next) tracksize += sec->size + sizeof(SectorHeader); if (tracksize <= drv->tracksize[t]) { drv->modified[t] = false; fio->Seek(drv->trackpos[t], FileIO::begin); WriteTrackImage(fio, drv, t); } else { drv->sizechanged = true; break; } } } } } }
void HMM::load_parameters(std::string filename) { FileIO fio; FILE* fp = fopen(filename.c_str(), "r"); assert(fp); uint32_t hs_ {0}; fio.readUInt32(fp, &hs_); hs = (int)hs_; uint32_t os_ {0}; fio.readUInt32(fp, &os_); os = (int)os_; allocate_parameters(); fio.readDoubleArray(fp, nu, hs); fio.readDoubleArray(fp, Q, hs*hs); fio.readDoubleArray(fp, g, hs*os); update_log_parameters(); fclose(fp); }
//---------------------------------------------------------------------------- void Visual::SaveIndexBuffer (FileIO& outFile) { if (mIBuffer) { int numElements = mIBuffer->GetNumElements(); int elementSize = mIBuffer->GetElementSize(); Buffer::Usage ibusage = mIBuffer->GetUsage(); int usage = (int)ibusage; int offset = mIBuffer->GetOffset(); outFile.Write(sizeof(int), &numElements); outFile.Write(sizeof(int), &elementSize); outFile.Write(sizeof(int), &usage); outFile.Write(sizeof(int), &offset); outFile.Write(elementSize, mIBuffer->GetNumBytes()/elementSize, mIBuffer->GetData()); } else { int numElements = 0; outFile.Write(sizeof(int), &numElements); } }