bool FileRetriever::retrieve(Url* url, Config* config, Message* message, Resolver* resolver) { guessType(url); int id = 0; url->m_statusText = "KO"; resolver->getOrAdd(url->getUrlString(), &id); // create the parser associated with this type of content m_parser = Parser::getParserByContent(url, resolver, message, url->m_contentType); if (m_parser != 0) { if (url->m_contentType.substr(0, 6) == "image/") { std::ifstream fis(url->m_urlPath.c_str()); if (fis != 0) { char* buffer; size_t size; fis.seekg (0, std::ios_base::end); size = fis.tellg(); fis.seekg (0, std::ios_base::beg); buffer = new char [size]; fis.read(buffer, size); fis.close(); m_parser->processData(config, (const unsigned char*) buffer, size); delete [] buffer; url->m_statusText = "OK"; } } else { std::ifstream fis(url->m_urlPath.c_str()); if (fis != 0) { while (!fis.eof()) { std::string test; std::getline(fis, test); m_parser->processData(config, (const unsigned char*) test.c_str(), test.length()); } url->m_statusText = "OK"; } } if (url->m_statusText != "OK") { message->addMessage("Could not open file " + url->m_urlPath, 1); url->m_statusText = "Not Found"; return false; } } else { // so message of no handler gets printed url->m_statusText = "OK"; } return true; }
inline void from_buffer(I3Frame &element, const char *buffer, std::size_t size) { boost::iostreams::array_source src(buffer, size); boost::iostreams::filtering_istream fis(src); element.load(fis); }
int main() { #ifndef ONLINE_JUDGE std::ifstream fis("AverageSpeed.in"); std::cin.rdbuf(fis.rdbuf()); #endif std::string line; double currentSpeed = 0.0; size_t lastTime = 0; size_t totalTimeTraveled = 0; double distance = 0.0; while (std::getline(std::cin, line)) { std::istringstream iss(line); std::string time; std::string speed; iss >> time >> speed; size_t seconds = toSeconds(time); size_t delta = seconds - lastTime; lastTime = seconds; totalTimeTraveled += delta; distance += static_cast<double>(delta) * currentSpeed; if (!speed.empty()) { currentSpeed = std::stod(speed) / 3600.00; } else { std::cout << toTime(totalTimeTraveled) << ' ' << std::fixed << std::setprecision(2) << distance << " km" << std::endl; } } return 0; }
bool unpackNow() { wxFFileInputStream fis(version + ".tgz"); wxZlibInputStream zlis(fis); wxTarInputStream tis(zlis); if (!tis.CanRead()) { return false; } std::auto_ptr<wxTarEntry> entry; while (entry.reset(tis.GetNextEntry()), entry.get() != NULL) { // access meta-data wxString name = entry->GetName(); printf("%s\n", name.c_str()); if (name == "Tibia/Tibia.pic" || name == "Tibia\\Tibia.pic") { castEvent(10); unpackEntry(tis, "Tibia.pic"); } else if (name == "Tibia/Tibia.dat" || name == "Tibia\\Tibia.dat") { castEvent(11); unpackEntry(tis, "Tibia.dat"); } else if (name == "Tibia/Tibia.spr" || name == "Tibia\\Tibia.spr") { castEvent(12); unpackEntry(tis, "Tibia.spr"); } else { printf("Name unrecognized\n"); castEvent(9); } } return true; }
bool FileCache::loadByPath(const std::string &path, std::ostream &os) { std::ifstream fis(path.c_str(), std::ios_base::binary); if(!fis.good()){ verbosestream<<"FileCache: File not found in cache: " <<path<<std::endl; return false; } bool bad = false; for(;;){ char buf[1024]; fis.read(buf, 1024); std::streamsize len = fis.gcount(); os.write(buf, len); if(fis.eof()) break; if(!fis.good()){ bad = true; break; } } if(bad){ errorstream<<"FileCache: Failed to read file from cache: \"" <<path<<"\""<<std::endl; } return !bad; }
int main(int argc, char **argv) { if (argc != 5) die_printf("Usage: %s <file> <prefix> <new-uri> <outfile>\n", argv[0]); try { std::string file = argv[1]; std::string prefix = argv[2]; std::string uri = argv[3]; std::string outfile = argv[4]; std::cout << "Replacing all matching prefixes " << prefix << " with uri " << uri << std::endl; io::FileInputStream fis( file ); xml::lite::MinidomParser parser; parser.parse(fis); xml::lite::Element* topLevel = parser.getDocument()->getRootElement(); topLevel->setNamespaceURI( prefix, uri ); io::FileOutputStream fos( outfile ); topLevel->prettyPrint( fos ); } catch (except::Throwable& anything) { std::cout << "Caught throwable: " << anything.getType() << " " << anything.toString() << std::endl; } }
int main() { #ifndef ONLINE_JUDGE std::ifstream fis("3n+1.in"); std::cin.rdbuf(fis.rdbuf()); #endif const int MAX = 1000000; std::vector<long> cycleLengths(MAX, 0); for (int i = 1; i < MAX; i++) { cycleLengths[i] = getCycleLength(i, cycleLengths); } std::string line; while (std::getline(std::cin, line)) { std::istringstream ss(line); int i, j; ss >> i >> j; int ii = i, jj = j; if (i > j) { std::swap(ii, jj); } long max = 0; for (int k = ii; k <= jj; k++) { max = std::max(max, cycleLengths[k]); } std::cout << i << ' ' << j << ' ' << max << std::endl; } return 0; }
bool CollectForOutput::collectDocument() { QFileInfo fi = QFileInfo(m_outputDirectory); newName = m_outputDirectory; if (!fi.exists()) return false; if (!fi.isDir() || !fi.isWritable()) return false; if ((m_Doc->hasName) && (!m_Doc->isConverted)) { QFileInfo fis(m_Doc->DocName); newName += fis.fileName(); } else newName += m_Doc->DocName+".sla"; m_Doc->hasName = true; if (m_compressDoc) { if (!newName.endsWith(".gz")) newName += ".gz"; } else { if (newName.endsWith(".gz")) newName = newName.remove(".gz"); } if (!overwrite(ScCore->primaryMainWindow(), newName)) return false; if (!ScCore->primaryMainWindow()->DoFileSave(newName)) return false; return true; }
void DeepScanner::processFile(FIFile* pFile) { Error error; class SkipFile {}; try { Path path = pFile->getAbsolutePath(error, m_db.m_root); if (error) throw SkipFile(); m_fProgress = Real64(m_iCurItem) / Real64(m_db.m_pFIFiles.size()); progressReport(path); FileInputStream fis(error, path); if (error) throw SkipFile(); FIIndex* pIndex = vivFileIndex(error, fis); if (error) throw SkipFile(); pFile->setFIIndex(pIndex); pIndex->addFIFile(pFile); } catch (SkipFile&) { UTF16 sErrorMessage = (error ? UTF16(error) : L"Unknown Error"); skipWarning(pFile->getPath(), error); } }
void func_a_rm_not_op(func_t *f, func_is_t *fis) { int i; if(f==NULL) return; for(i=0; i<func_asize(f); i++){ if(!fis(func_aget(f,i))){ func_adel(f,i); } } func_a_rm_null(f); }
void XmlMapHandler::Load(std::istream& file, Map& map) { wxXmlDocument doc; wxFInputStream fis(file); if (!doc.Load(dynamic_cast<wxInputStream&>(fis))) throw "Could not open XML file"; wxXmlNode* child = doc.GetRoot()->GetChildren(); if (child != NULL && child->GetName() != "Properties") throw "Properties must be the first node in the XML file"; ReadProperties(child, map); while ((child = child->GetNext())) { std::string name = child->GetName().ToStdString(); VerboseLog("%s Got node %s", __func__, name.c_str()); if (name == "Layer") ReadLayer(child, map); else if (name == "Background") ReadBackground(child, map); else if (name == "Collision") ReadCollision(child, map); else if (name == "Animation") ReadAnimation(child, map); else throw "Unknown element found in file " + name; } }
bool wxAnimationCtrl::LoadFile(const wxString &filename, wxAnimationType type) { wxFileInputStream fis(filename); if (!fis.IsOk()) return false; return Load(fis, type); }
int main(int argc, char** argv) { Poco::JSON::Object::Ptr obj; std::string dir = Poco::Environment::get("POCO_BASE") + "/JSON/samples/Benchmark/"; Poco::Path filePath(dir, "input"); std::ostringstream ostr; if ( filePath.isFile() ) { Poco::File inputFile(filePath); if ( inputFile.exists() ) { Poco::FileInputStream fis(filePath.toString()); Poco::StreamCopier::copyStream(fis, ostr); } else { std::cout << filePath.toString() << " doesn't exist!" << std::endl; return 1; } } std::cout << std::setw(25) << "POCO JSON"; std::string jsonStr = ostr.str(); try { Poco::JSON::DefaultHandler handler; Poco::JSON::Parser parser; parser.setHandler(&handler); Poco::Timestamp time1; parser.parse(jsonStr); Poco::DynamicAny result = handler.result(); Poco::Timestamp time2; printTimeDiff(time1, time2); if ( result.type() == typeid(Poco::JSON::Object::Ptr) ) { obj = result.extract<Poco::JSON::Object::Ptr>(); } //Serialize to string std::ostringstream out; Poco::Timestamp time3; obj->stringify(out); Poco::Timestamp time4; printTimeDiff(time3, time4); std::cout << std::endl; } catch(Poco::JSON::JSONException jsone) { std::cout << jsone.message() << std::endl; } return 0; }
int func_a_has_op(func_t *f, func_is_t *fis) { int i; for(i=0; i<func_asize(f); i++){ if(fis(func_aget(f,i))){ return 1; } } return 0; }
int func_a_has_op_pow1(func_t *f, func_is_t *fis) { int value=0,i; for(i=0; i<func_asize(f); i++){ if(fis(func_aget(f,i)) && func_has_power(func_aget(f,i)) && func_power(func_aget(f,i))==1){ value=1; } } return value; }
inline void from_buffer(T &element, const char *buffer, std::size_t size) { boost::iostreams::array_source src(buffer, size); boost::iostreams::filtering_istream fis(src); boost::archive::portable_binary_iarchive pia(fis); pia >> element; }
void SMTPChannel::log(const Message& msg) { try { MailMessage message; message.setSender(_sender); message.addRecipient(MailRecipient(MailRecipient::PRIMARY_RECIPIENT, _recipient)); message.setSubject("Log Message from " + _sender); std::stringstream content; content << "Log Message\r\n" << "===========\r\n\r\n" << "Host: " << Environment::nodeName() << "\r\n" << "Logger: " << msg.getSource() << "\r\n"; if (_local) { DateTime dt(msg.getTime()); content << "Timestamp: " << DateTimeFormatter::format(LocalDateTime(dt), DateTimeFormat::RFC822_FORMAT) << "\r\n"; } else content << "Timestamp: " << DateTimeFormatter::format(msg.getTime(), DateTimeFormat::RFC822_FORMAT) << "\r\n"; content << "Priority: " << NumberFormatter::format(msg.getPriority()) << "\r\n" << "Process ID: " << NumberFormatter::format(msg.getPid()) << "\r\n" << "Thread: " << msg.getThread() << " (ID: " << msg.getTid() << ")\r\n" << "Message text: " << msg.getText() << "\r\n\r\n"; message.addContent(new StringPartSource(content.str())); if (!_attachment.empty()) { { Poco::FileInputStream fis(_attachment, std::ios::in | std::ios::binary | std::ios::ate); if (fis.good()) { int size = fis.tellg(); char* pMem = new char [size]; fis.seekg(std::ios::beg); fis.read(pMem, size); message.addAttachment(_attachment, new StringPartSource(std::string(pMem, size), _type, _attachment)); delete [] pMem; } } if (_delete) File(_attachment).remove(); } SMTPClientSession session(_mailHost); session.login(); session.sendMessage(message); session.close(); } catch (Exception&) { if (_throw) throw; } }
void Server::sendRequestedMedia(u16 peer_id, const std::vector<std::string> &tosend) { DSTACK(FUNCTION_NAME); verbosestream<<"Server::sendRequestedMedia(): " <<"Sending files to client"<<std::endl; /* Read files */ // TODO: optimize MediaData media_data; u32 size = 0; for(auto i = tosend.begin(); i != tosend.end(); ++i) { const std::string &name = *i; if(m_media.find(name) == m_media.end()) { errorstream<<"Server::sendRequestedMedia(): Client asked for " <<"unknown file \""<<(name)<<"\""<<std::endl; continue; } //TODO get path + name std::string tpath = m_media[name].path; // Read data std::ifstream fis(tpath.c_str(), std::ios_base::binary); if(fis.good() == false){ errorstream<<"Server::sendRequestedMedia(): Could not open \"" <<tpath<<"\" for reading"<<std::endl; continue; } std::string contents; fis.seekg(0, std::ios::end); contents.resize(fis.tellg()); fis.seekg(0, std::ios::beg); fis.read(&contents[0], contents.size()); media_data.push_back(std::make_pair(name, contents)); size += contents.size(); if (size > 0xffff) { MSGPACK_PACKET_INIT(TOCLIENT_MEDIA, 1); PACK(TOCLIENT_MEDIA_MEDIA, media_data); m_clients.send(peer_id, 2, buffer, true); media_data.clear(); size = 0; } } if (!media_data.empty()) { MSGPACK_PACKET_INIT(TOCLIENT_MEDIA, 1); PACK(TOCLIENT_MEDIA_MEDIA, media_data); m_clients.send(peer_id, 2, buffer, true); } }
int main() { #ifndef ONLINE_JUDGE std::ifstream fis("11150.Cola.in"); std::cin.rdbuf(fis.rdbuf()); #endif std::string line; while (std::getline(std::cin, line)) { std::cout << cola(std::stoi(line), 0, 0) << std::endl; } return 0; }
LuceneObjectPtr FieldInfos::clone(LuceneObjectPtr other) { SyncLock syncLock(this); FieldInfosPtr fis(newLucene<FieldInfos>()); for (Collection<FieldInfoPtr>::iterator field = byNumber.begin(); field != byNumber.end(); ++field) { FieldInfoPtr fi(boost::dynamic_pointer_cast<FieldInfo>((*field)->clone())); fis->byNumber.add(fi); fis->byName.put(fi->name, fi); } return fis; }
void copy(JFile from, JFile to) { try { JFileInputStream fis(from.getPath()); JFileOutputStream fos(to.getPath()); JBlock buf(32768, 0); for (;;) { fis >> buf; fos << buf; } } catch (JException* e) { delete e; } }
void ConfirmDialog::ResetGridMetadata() { wxString equipment_id; m_buttonLaunch->Enable(m_choiceProject->GetSelection()!=0) ; if(m_gridMetadata->GetNumberRows()>0) { equipment_id = m_gridMetadata->GetCellValue (1, 0); m_gridMetadata->DeleteRows (0, m_gridMetadata->GetNumberRows()); } m_gridMetadata->InsertRows (0, 5) ; m_gridMetadata->SetRowLabelValue (0, wxT("session.datetime")); m_gridMetadata->SetRowLabelValue (1, wxT("session.equipment.id")); m_gridMetadata->SetRowLabelValue (2, wxT("session.project.id")); m_gridMetadata->SetRowLabelValue (3, wxT("session.project.name")); m_gridMetadata->SetRowLabelValue (4, wxT("session.project.leader")); m_gridMetadata->SetReadOnly (0, 0); m_gridMetadata->SetReadOnly (1, 0); m_gridMetadata->SetReadOnly (2, 0); m_gridMetadata->SetReadOnly (3, 0); m_gridMetadata->SetReadOnly (4, 0); m_gridMetadata->SetCellTextColour(0, 0, wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT)); m_gridMetadata->SetCellTextColour(1, 0, wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT)); m_gridMetadata->SetCellTextColour(2, 0, wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT)); m_gridMetadata->SetCellTextColour(3, 0, wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT)); m_gridMetadata->SetCellTextColour(4, 0, wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT)); m_gridMetadata->SetCellValue (0, 0, wxDateTime::Now().FormatISOCombined()); m_gridMetadata->SetCellValue (1, 0, equipment_id); // load project metadata wxFileName projectINI(wxT("projects"), m_choiceProject->GetStringSelection(), wxT("ini")) ; // Set the tips as project name if(projectINI.FileExists()) { wxFileInputStream fis(projectINI.GetFullPath()) ; wxFileConfig metadata_config(fis); metadata_config.SetStyle( metadata_config.GetStyle() | wxCONFIG_USE_NO_ESCAPE_CHARACTERS ) ; m_gridMetadata->SetCellValue (2, 0, m_choiceProject->GetStringSelection() ); m_gridMetadata->SetCellValue (3, 0, metadata_config.Read(wxT("project/project.name"))); m_gridMetadata->SetCellValue (4, 0, metadata_config.Read(wxT("project/project.owner"))); } }
void func_add_args(func_t *f, func_is_t *fis, func_is_t *fin) { int i,j; if(!func_is_add(f)){ FUNC_ERROR_ARG1("func_add_args",f); } for(i=0; i<func_asize(f); i++){ for(j=0; fis(func_aget(f,i)) && j<func_asize(f); j++){ if(i!=j && fin(func_aget(f,j))){ func_aset(f,i,func_add(FR(func_aget(f,i)),FR(func_aget(f,j)))); func_adel(f,j); } } } func_a_rm_null(f); }
void Converter::loadFontList( const string_t& fileName, std::set<string_t>& cnt ) { /// fonts Poco::FileInputStream fis(fileName); while (!fis.eof()) { string_t fontName; std::getline(fis, fontName); fontName = Poco::trim(fontName); if (fontName.empty()) continue; cnt.insert( fontName ); } }
main() { char s[20] = "xxxxxxxxxxxxxxxxxxx"; ifstream fis("text.txt"); ofstream fos("text.txt"); clrscr(); fis.putback('s'); fis.getline(s, 15); fos.write(s, strlen(s)); cout<<s; getch(); return 0; }
void Converter::loadKnownAsciiFonts( const string_t& languageDir, const string_t& language) { string_t fontsKnow = languageDir + "font-known-ascii.txt"; string_t charDefMapping = languageDir + "char-mapping-default.txt"; tCharMappingSp defMapping(new CharMapping(charDefMapping)); defMapping->setLanguage(language); /// open known fonts file and create mapping for each font Poco::FileInputStream fis(fontsKnow); while (!fis.eof()) { string_t sl; string_t fontName; string_t customMapFile; std::getline(fis, sl); /// check if there is custom mapping file specified current font string_t::size_type p = sl.find('|'); fontName = sl.substr(0, p); sl = Poco::trim(sl); if (p != string_t::npos) customMapFile = sl.substr(p + 1); fontName = Poco::trimRight(fontName); customMapFile = Poco::trimLeft(customMapFile); if (fontName.empty()) continue; if (customMapFile.empty()) { fontCharMaps_.insert( std::make_pair(fontName, defMapping) ); } else { tCharMappingSp cm(new CharMapping); *cm = *defMapping; cm->updateCharMapping(languageDir + customMapFile); fontCharMaps_[fontName] = cm; } } }
bool CUpdate::loadConfig(const wxString& key, wxString* values, wxString fileName) { if(fileName.IsEmpty()) { fileName = m_configFile; } wxString realFileName = m_skinDir +fileName; wxFileInputStream fis(realFileName); if (!fis.Ok()) { assert("Config file not found."); return false; } wxFileConfig *conf = new wxFileConfig(fis); bool result = conf->Read(key, values); delete conf; return result; }
int main() { #ifndef ONLINE_JUDGE std::ifstream fis("TheSnail.in"); std::cin.rdbuf(fis.rdbuf()); #endif int h, u, d, f; while (std::cin >> h >> u >> d >> f && h) { int day = simulateSnail(h, u, d, f); if (day < 0) { std::cout << "failure on day " << (-day) << std::endl; } else { std::cout << "success on day " << day << std::endl; } } return 0; }
void FileRequestHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response) { setContentType(request, response); std::ostream& ostr = response.send(); try { Poco::Path basedir = Poco::Util::Application::instance().config().getString("application.dir"); basedir.append("web"); basedir.append(request.getURI()); Poco::FileInputStream fis(basedir.toString()); Poco::StreamCopier::copyStream(fis, ostr); response.setStatus(Poco::Net::HTTPResponse::HTTPStatus::HTTP_OK); } catch (Poco::Exception& ex) { response.setStatus(Poco::Net::HTTPResponse::HTTPStatus::HTTP_NOT_FOUND); ostr << ex.displayText(); _logger.error("Request failed: %s: %s", request.getURI(), ex.displayText()); } }
bool Upgrade::loadIDMap(std::string mapFileName, StringUnsignedMap* outIdMap) { const char* logContext = "Load IP map file"; std::ifstream fis(mapFileName.c_str() ); if(!fis.is_open() || fis.fail() ) { LogContext(logContext).logErr("Failed to open ID-map-file: " + System::getErrString() ); return false; } bool retVal = true; char line[STORAGETK_FILE_MAX_LINE_LENGTH]; while(!fis.eof() && !fis.fail() ) { fis.getline(line, STORAGETK_FILE_MAX_LINE_LENGTH); std::string trimmedLine = StringTk::trim(line); if(trimmedLine.length() && (trimmedLine[0] != STORAGETK_FILE_COMMENT_CHAR) ) { unsigned numID; char stringID[513]; int scanRes = sscanf(trimmedLine.c_str(), "%48s %u", stringID, &numID); if (scanRes == ID_MAP_FILE_COLUMS) outIdMap->insert(StringUnsignedMapVal(stringID, numID) ); else { LogContext(logContext).logErr("Invalid line in map file (" + mapFileName + ")" + std::string(" Line: ") + line); break; retVal = false; } } } fis.close(); return retVal; }