//os2 type of a header static bool write_dibheader(int bit_depth) { dib_head dib; dib.headsz=12; dib.width=w; dib.height=h; dib.colplanes=1; dib.bitsperpix=bit_depth; fout.write((char *) &(dib.headsz), sizeof(char) * 4); if (!fout.good()) return 0; fout.write((char *) &(dib.width), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(dib.height), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(dib.colplanes), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(dib.bitsperpix), sizeof(char) * 2); if (!fout.good()) return 0; return 1; }
static bool write_fileheader(int clrtable_sz) { f_head head; head.bmid[0]='B'; head.bmid[1]='M'; head.sz=14+12+clrtable_sz+sz;//head size+dib_size+color_table size+bitmap_sz head.res1=0; head.res2=0; head.pixoffset=14+12+clrtable_sz; fout.write((char *) (head.bmid), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(head.sz), sizeof(char) * 4); if (!fout.good()) return 0; fout.write((char *) &(head.res1), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(head.res2), sizeof(char) * 2); if (!fout.good()) return 0; fout.write((char *) &(head.pixoffset), sizeof(char) * 4); if (!fout.good()) return 0; return 1; }
//==================================================================== // Save network to file //==================================================================== bool BPNet::save( ofstream &ost ) const { if ( !ost.good() ) return false; int numLayers = _nodeCount.size(); int numNodes = _nodes.size(); int numLinks = _links.size(); ost << numLayers << endl; // num layers for(int i = 0; i != numLayers; ++i) ost << _nodeCount[i] << endl; // number of nodes in each layer ost << numNodes << endl; // total number of nodes ost << numLinks << endl; // total number of links // save nodes data for(i = 0; i != numNodes; ++i) _nodes[i]->save(ost); // save links data for(i = 0; i != numLinks; ++i) _links[i]->save(ost); if (!ost.good()) return false; return true; }
bool DealWithMatch(const vector <string> &LineList, const boost::regex &RegExpress, const DataFile &TypeEntry, ofstream &TableStream, const size_t FilingIndex) // MAJOR robustness issues here! See notes in this function. { // cerr << "Going into DealWithMatch()\n"; bool IsSuccessful; const vector <string> Captures = ObtainCaptures(RegExpress, LineList[0], TypeEntry.PatternExplainCount() + 1); // cerr << "Got Captures\n"; const vector <string> Descriptors = GatherInfo(LineList, Captures, TypeEntry.GiveAllPatternExplains(), TypeEntry.GiveAllAssignExpressions(), IsSuccessful); // cerr << "Got Descriptors\n"; // May need to put in controls of some sort to determine whether something should be quoted or not. if (IsSuccessful) { TableStream << GiveDelimitedList(LineList, ',') << ',' << FilingIndex << ',' << GiveDelimitedList(Descriptors, ',') << "\n"; } // This above segment prints to the appropriate subcatalogue file the following info: // Filename, File Group number, Volume Name, FileSize, FilingIndex, and Date information for the file, and any other descriptor information. // there is always DateTime_Info for Descriptors[0] return(TableStream.good()); }
static bool writeFile(const wstring &res, ofstream &fs, bkplong pos) { static unsigned short magic = 0xFEFF; //write in Unicode16-LE if (!fs.good()) return false; if (pos >= 0) fs.seekp(pos, ios_base::beg); else fs.seekp(pos + 1, ios_base::end); fs.write((const char *)&magic, 2); u16string result; bkplong s = res.size(); bkplong s2 = s * sizeof(wchar_t) / sizeof(char16_t); result.resize(s2); #ifdef HAVE_CODECVT auto& f = use_facet<codecvt<wchar_t, char16_t, mbstate_t>>(locale()); mbstate_t mb = mbstate_t(); char16_t* from_next; const wchar_t* to_next; f.out(mb, &res[0], &res[s], to_next, &result[0], &result[s2], from_next); #else ucs4toutf16((uint16_t *)&result[0], (uint32_t *)&res[0], s); #endif fs.write((const char *)result.c_str(), 2 * result.length()); return true; }
void write_custom_header(ofstream &file){ // check input file is actually an open ofstream... if (!file.good()){ cerr << "ERROR - problem with file opening. Aborting..." << endl; exit(1); } // build variables string line; string header_content; ifstream conf(c_CUSTOM_HEADER_FILE.c_str()); if (!conf){ cerr << "ERROR: Unable to open configuration file..." << endl << "Aborting!" << endl; exit(1); } // read all of the file defined by c_CUSTOM_HEADER_FILE while(getline(conf,line)){ line.append("\n"); header_content = header_content.append(line); } // write to your new headerfile file << header_content; cout << "Loaded custom header details..." << endl; }
bool Serializer::writeChar(ofstream &outfile, char write) { outfile.put(write); if (!outfile.good()) return false; return true; }
/* Print the BFS tree from a particular vertex. */ void graph_using_AL::print_bfs_tree(string start_vertex, ofstream& fout) { /* Check if 'fout' is good. */ assert(fout.good()); /* Find the start vertex. */ map<string, set<string> >::iterator v_itr = find_vertex(start_vertex); if(v_itr == data.end()) { /* Vertex not found. */ cerr << "Start Vertex not found." << endl; return; } map<string, string> parent ; map<string, int> distance; /* Do the BFS traversal. * The 'parent' and the 'distance' containers will be populated by this function. */ BFS_visit(parent, distance, start_vertex); /* Printing the parent details. */ if(debug_flag) clog << "Parent array: " << endl; vector<pair<string, string> > vp; for(map<string, string>::iterator p_itr = parent.begin(); p_itr != parent.end(); p_itr++) { vp.push_back(pair<string, string>(p_itr->first, p_itr->second)); if(debug_flag) cout << p_itr->first << " <-- " << p_itr->second << endl; } print_tree_with_edges_colored(vp, "red", fout); return; }
void BitString::save(ofstream & out) const { assert(out.good()); out.write((char*)&length,sizeof(size_t)); out.write((char*)&uintLength,sizeof(size_t)); out.write((char*)data,uintLength*sizeof(uint)); }
void MapperCont::save(ofstream & out) const { assert(out.good()); uint wr = MAPPER_CONT_HDR; saveValue(out,wr); m->save(out); }
bool start_log(const char *filename) { event_log.open(filename); if(!event_log.good()) { std::cout << "Error!: Could not open log file" << endl; return false; } return true; }
//////////////////////////////////////////////////////////////////////////////// // output_read // // Output the given possibly corrected and/or trimmed // read according to the given options. //////////////////////////////////////////////////////////////////////////////// static void output_read(ofstream & reads_out, ofstream & corlog_out, int pe_code, string header, string ntseq, string mid, string strqual, string corseq, stats & tstats) { if(corseq.size() >= trim_t) { // check for changes bool corrected = false; for(int i = 0; i < corseq.size(); i++) { if(corseq[i] != ntseq[i]) { // log it if(corlog_out.good()) corlog_out << (strqual[i]-Read::quality_scale) << "\t" << (i+1) << "\t" << corseq[i] << "\t" << ntseq[i] << endl; // note it corrected = true; // set qual to crap strqual[i] = (char)(Read::quality_scale+2); } } if(corrected) tstats.corrected++; // update header if(!orig_headers) { if(corrected) header += " correct"; unsigned int trimlen = ntseq.size()-corseq.size(); if(trimlen > 0) { stringstream trim_inter; trim_inter << trimlen; header += " trim=" + trim_inter.str(); tstats.trimmed++; if(!corrected) tstats.trimmed_only++; } else { if(!corrected) tstats.validated++; } } // print if(contrail_out) reads_out << header << "\t" << corseq << endl; else reads_out << header << endl << corseq << endl << mid << endl << strqual.substr(0,corseq.size()) << endl; if(TESTING) cerr << header << "\t" << ntseq << "\t" << corseq << endl; } else { tstats.removed++; if(uncorrected_out || pe_code > 0) { // update header header += " error"; //print if(contrail_out) reads_out << header << "\t" << ntseq << endl; else reads_out << header << endl << ntseq << endl << mid << endl << strqual << endl; } if(TESTING) cerr << header << "\t" << ntseq << "\t-" << endl; // or . if it's only trimmed? } }
void costVec::WriteToFile(ofstream &fout) { assert(fout.is_open() && fout.good()); for(size_t cid = 0; cid < VEC_DIMENSION; cid++) { fout << ' ' << c[cid]; } }
void AbrirArchivoParaEscribir(ofstream &archivo) { cout << " Ingrese nombre de archivo: "; string opt; bool ok = false; getline(cin, opt); getline(cin, opt); archivo.open(opt.c_str()); ok = archivo.good(); while (!ok) { cout << " Valor incorrecto. Ingrese nombre de archivo: "; getline(cin, opt); archivo.open(opt.c_str()); ok = archivo.good(); } }
int openOfstream(ofstream & out, const char * filename) { out.open(filename); if(!out.good()){ std::cerr << "Cannot write to " << filename << std::endl; return -1; } return 0; }
static void InitFiles(ofstream& file_c, ofstream& file_h, const ExportParams& params) { std::string name = params.name; Chop(name); std::string name_cap = name; transform(name_cap.begin(), name_cap.end(), name_cap.begin(), (int(*)(int)) std::toupper); std::string filename_c = params.name + ".c"; std::string filename_h = params.name + ".h"; file_c.open(filename_c.c_str()); file_h.open(filename_h.c_str()); if (!file_c.good() || !file_h.good()) { printf("Could not open files for writing\n"); exit(EXIT_FAILURE); } }
bool openOutputStream(ofstream &stream, string fileName) { stream.open(fileName.c_str()); if (!stream.good()) { return false; } return true; }
void point::sauver(ofstream &fichier) { if (!fichier.is_open()) cout << " Erreur d'ouverture " << endl; else { fichier << x_<<endl; fichier << y_<<endl; if (!fichier.good()) cout << " Erreur d'écriture" << endl; //else cout << " Ecriture terminée " << endl; } }
void Framis::destroyClass() { cout<<"~Famis()"<<endl; if (outFile.good()) { outFile<<"~Famis()\n"; } size_t index = (this - pPool) / sizeof(Framis); s_data_map[index] = false; }
static bool write_coltable() { rgb_color white,black; white.blue=255; white.red=255; white.green=255; black.blue=0; black.red=0; black.green=0; fout.write((char *) &(white.blue), sizeof(char)); if (!fout.good()) return 0; fout.write((char *) &(white.green), sizeof(char)); if (!fout.good()) return 0; fout.write((char *) &(white.red), sizeof(char)); if (!fout.good()) return 0; fout.write((char *) &(black.blue), sizeof(char)); if (!fout.good()) return 0; fout.write((char *) &(black.green), sizeof(char)); if (!fout.good()) return 0; fout.write((char *) &(black.red), sizeof(char)); if (!fout.good()) return 0; //fout.write((char *) &(black.alpha), sizeof(char)); //if (!fout.good()) return 0; return 1; }
void Token::outputIntoFile(ofstream& outputFile){ // cout << token->m_lexem<<" "<<((TokenERROR*)(token))->m_errorBody<<" "<<token->m_location<<endl; if (outputFile.is_open()) { if(outputFile.good()) { outputFile<<this->m_lexem<<"\t"<<this->m_lexemCode<<"\t"<<this->m_location<<endl; } } }
int HTTPRequest::copyToFile(ofstream& ofs) { size_t contentLength = atoi(getHTTPHeader("Content-Length").c_str()); if (ofs.good()) { ofs.write(m_requestBody.c_str(), contentLength); } if (ofs.bad()) return -1; return 0; }
/* append P2P message data to CSV file */ static void write_p2p_data( AllData& alldata, ofstream& csvFile, const string& csvFileName ) { assert( csvFile.good() ); VerbosePrint( alldata, 2, false, " appending P2P message data to file: %s\n", csvFileName.c_str() ); static const string LINE_PREFIX= "P2P"; if ( 0 == alldata.myRank ) { /* write headline */ csvFile << endl << LINE_PREFIX << ';' << "Process;Send Invocations;Recv. Invocations;Send Bytes;Recv. Bytes;Duration (s)" << endl; } /* write P2P message data */ map< uint64_t, MessageData >::iterator it= alldata.messageMapPerRank.begin(); map< uint64_t, MessageData >::iterator itend= alldata.messageMapPerRank.end(); while ( itend != it ) { const uint64_t& proc_id= it->first; const uint64_t& count_send= it->second.count_send.cnt; const uint64_t& count_recv= it->second.count_recv.cnt; const uint64_t& bytes_send= it->second.bytes_send.sum; const uint64_t& bytes_recv= it->second.bytes_recv.sum; const double duration= it->second.duration_send.sum / alldata.timerResolution; const string& proc_name= alldata.processIdNameMap[ proc_id ]; assert( 0 != proc_name.length() ); csvFile << LINE_PREFIX << ';' << proc_name << ';' << count_send << ';' << count_recv << ';' << bytes_send << ';' << bytes_recv << ';' << duration << endl; it++; } }
/* append function data to CSV file */ static void write_func_data( AllData& alldata, ofstream& csvFile, const string& csvFileName ) { assert( csvFile.good() ); VerbosePrint( alldata, 2, false, " appending function data to file: %s\n", csvFileName.c_str() ); static const string LINE_PREFIX= "FUNCTION"; if ( 0 == alldata.myRank ) { /* write headline */ csvFile << LINE_PREFIX << ';' << "Process;Function;Invocations;Excl. Time (s);Incl. Time (s)" << endl; } /* write function data */ map< Pair, FunctionData, ltPair >::iterator it= alldata.functionMapPerRank.begin(); map< Pair, FunctionData, ltPair >::iterator itend= alldata.functionMapPerRank.end(); while ( itend != it ) { const uint64_t& proc_id= it->first.a; const uint64_t& func_id= it->first.b; const uint64_t& count= it->second.count.cnt; const double excl_time= it->second.excl_time.sum / alldata.timerResolution; const double incl_time= it->second.incl_time.sum / alldata.timerResolution; const string& proc_name= alldata.processIdNameMap[ proc_id ]; assert( 0 != proc_name.length() ); const string& func_name= alldata.functionIdNameMap[ func_id ]; assert( 0 != func_name.length() ); csvFile << LINE_PREFIX << ';' << proc_name << ';' << func_name << ';' << count << ';' << excl_time << ';' << incl_time << endl; it++; } }
int main(int argc, char * argv[]){ //Local variables for time functions double wall_time, cpu_time; //Open input file infile.open(argv[1]); if(!infile.good()){ cerr << "The input file name was not correct. Please try again." << endl; exit(0); } //Open output file outfile.open(argv[2]); if(!outfile.good()){ cerr << "The output file name was not correct. Please try again." << endl; exit(0); } //Init Semaphores sem_init(&Full,0, 0); sem_init(&Empty, 0, 10); sem_init(&Crit,0,1); //Timing start_timing(); cout << "Starting timing: " << endl; //Create Producer and Consumer pthread_t tProducer; pthread_t tConsumer; pthread_create(&tProducer, NULL, threadProducer,NULL); pthread_create(&tConsumer, NULL, threadConsumer,NULL); pthread_join(tProducer, NULL); pthread_join(tConsumer, NULL); stop_timing(); wall_time = get_wall_clock_diff(); cpu_time = get_CPU_time_diff(); cout << "The time it took as wall time is: " << wall_time << endl; cout << "The time it took as CPU time is: " << cpu_time << endl; //Close files, now finished infile.close(); outfile.close(); //Destory Semaphores sem_destroy(&Crit); sem_destroy(&Empty); sem_destroy(&Full); return(0); }
/* To print the graph into a file in 'dot' graph description language format. */ void graph_using_AL::print_to_file(ofstream& fout) { if(empty()) return; assert(fout.good()); string arrow = ((d_type == directed_graph) ? " -> " : " -- " ); string graph_type = ((d_type == directed_graph) ? "digraph " : "graph "); map<string, set<string> >::const_iterator map_itr; set<string> ::const_iterator set_itr; fout << graph_type << name << "{" << endl; graph_using_AL g_temp = *this; set<string> edges; ostringstream oss; for(map_itr = g_temp.data.begin(); map_itr != g_temp.data.end(); map_itr ++) { if(map_itr->second.begin() == map_itr->second.end()) { fout << "\t" << "\"" << map_itr->first << "\"" << ";\n"; } else { for(set_itr = map_itr->second.begin(); set_itr != map_itr->second.end(); set_itr ++) { fout << "\t" << "\"" << map_itr->first << "\"" << arrow << "\"" << *set_itr << "\""; /* For weighted graph, print the individual edge weights. */ if (w_type == weighted_graph) { fout << "[label=" << get_weight(map_itr->first, *set_itr) << "]"; } fout << "; \n"; /* Delete the corresponding reverse-edge in the undirected graph. */ if((d_type == undirected_graph) && (map_itr->first != *set_itr)) { set<string>::iterator itr_temp = g_temp.data.find(*set_itr)->second.find(map_itr->first); g_temp.data.find(*set_itr)->second.erase(itr_temp); } } } } fout << "}" << endl; return; }
bool saveSched(ofstream &outfile, char sched[][4], const int &SLOT, const int &DAY, string &pName, bool &isSaved){ char choice; bool isValid = false; if(pName == "Jeff"){ outfile.open("sched_J_001.dat"); } else if(pName == "Ann"){ outfile.open("sched_E_001.dat"); } cout << "WARNING! By choosing this option, your previous schedule profile will be overwritten.\n"; while(!isValid){ cout << "Save all changes(Y/N)? "; cin >> choice; switch(toupper(choice)){ case 'Y':{ for(int slotCT = 0; slotCT < SLOT; slotCT++){ for(int dayCT = 0; dayCT < DAY; dayCT++){ if(sched[slotCT][dayCT] != 'x') sched[slotCT][dayCT] = '.'; outfile << sched[slotCT][dayCT] << " "; } outfile << endl; } outfile.close(); if(outfile.good()){ cout << "File saved.\n"; isValid = true; return true; } } case 'N':{ cout << "Exit without saving(Y/N)? "; cin >> choice; if(toupper(choice) == 'Y') return true; else if(toupper(choice) == 'N'){ cout << "Invalid input! Please try again.\n"; isValid = false; break; } } default:{ cout << "Invalid input! Please try again.\n"; } } } }
bool openFile( const string fname, ofstream &fobj ) { // vars bool success = false; // clear and open fobj.clear(); fobj.open(fname.c_str()); // check for file opening success if( fobj.good() ) { success = true; } // return success state return success; }
bool Serializer::writeInt(ofstream &outfile, int write) { char *buf = new char[4]; bool negative = write < 0; buf[3] = (char)(write / ONE_SHIFT_ZERO); buf[2] = (char)(write / ONE_SHIFT_ONE); buf[1] = (char)(write / ONE_SHIFT_TWO); buf[0] = (char)(write / ONE_SHIFT_THREE); if (negative) buf[0] &= (char)0x80; outfile.write(buf, 4); if (!outfile.good()) return false; return true; }
void CollisionDetector::printCollisionsDebug( ofstream &ofs ) { assert( ofs.good() ); if( !collisions_.empty() ) { sort( collisions_.begin(), collisions_.end(), willCollideFirst ); for_each( collisions_.begin(), collisions_.end(), [&] ( CollisionInfo& collision ) { ofs << collision << endl; } ); ofs << endl; } }