ChrString _Bitsxstr(istream& Is_, Subscript Num_) { Boolean Changed_ = FALSE; ChrString Str_('\0', Num_); if (Num_ == PTRDIFFT_MAX) --Num_; if (_Ipfx(Is_)) { int ch; while (0 < Num_ && (ch = Is_.rdbuf()->sbumpc()) != EOF) if (ch != '0' && ch != '1') { Is_.rdbuf()->sputbackc(ch); break; } else { Str_ += ch; Changed_ = TRUE; --Num_; } } if (!Changed_) Is_.clear(ios::failbit); if (!_Ipfx(Is_)) THROW (FallibleBase::IOFailureErr()); return Str_; }
void zipios::ZipFileTest::compareStreams(const std::string& entryName, istream &is1, istream &is2) { OutputStringStream buf1, buf2; buf1 << is1.rdbuf(); buf2 << is2.rdbuf(); CPPUNIT_ASSERT_MESSAGE("Streams differ for entry '"+entryName+"'", buf1.str() == buf2.str()); }
void copy( T &s, const istream &is ) { std::stringstream ss; std::streamsize at = is.rdbuf()->pubseekoff(0,is.cur); ss << is.rdbuf(); is.rdbuf()->pubseekpos(at); auto x = ss.str(); s.assign( x.begin(), x.end() ); }
/** * Adds signature to the container. * * @param signature signature, which is added to the container. * @throws ContainerException throws exception if there are no documents in container. */ void DDoc::addAdESSignature(istream &sigdata) { #if USE_SIGFROMMEMORY stringstream ofs; ofs << sigdata.rdbuf(); ofs.flush(); int err = d->lib->f_ddocAddSignatureFromMemory(d->doc, d->filename.c_str(), ofs.str().c_str(), ofs.str().size()); d->throwCodeError(err, "Failed to sign document", __LINE__); d->loadSignatures(); #else string fileName = File::tempFileName(); ofstream ofs(File::encodeName(fileName).c_str()); ofs << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n"; ofs << "<SignedDoc format=\"DIGIDOC-XML\" version=\"1.3\" xmlns=\"http://www.sk.ee/DigiDoc/v1.3.0#\">\n"; ofs << sigdata.rdbuf(); ofs << "</SignedDoc>"; ofs.flush(); ofs.close(); SignedDoc *sigDoc = nullptr; int err = d->lib->f_ddocSaxReadSignedDocFromFile( &sigDoc, fileName.c_str(), 0, 0 ); d->throwCodeError(err, "Failed to sign document", __LINE__); SignatureInfo **signatures = (SignatureInfo**)realloc( d->doc->pSignatures, (d->doc->nSignatures + sigDoc->nSignatures) * sizeof(SignatureInfo*)); if( !signatures ) { d->lib->f_SignedDoc_free( sigDoc ); d->throwError("Failed to sign document", __LINE__); return; } d->doc->pSignatures = signatures; for( int i = 0; i < sigDoc->nSignatures; ++i ) { d->doc->pSignatures[d->doc->nSignatures + i] = sigDoc->pSignatures[i]; // take ownership sigDoc->pSignatures[i] = nullptr; // from ddocReadNewSignaturesFromDdoc ((char*)d->doc->pSignatures[d->doc->nSignatures + i]->pDocs[0]->szDigest)[0] = 0x0A; } d->doc->nSignatures += sigDoc->nSignatures; sigDoc->nSignatures = 0; d->lib->f_SignedDoc_free( sigDoc ); #endif //Force reload save(fileName); load(fileName); }
static bool createJobFile(istream &src, const string &destFile, const Args &args) { Log::debug("Create job file %s", destFile.c_str()); ofstream dest(destFile, ios::binary | ios::trunc); dest << "\033CUPS_BOOMAGA\n"; dest << "JOB=" << escapeString(args.jobID) << "\n"; dest << "USER="******"\n"; dest << "TITLE=" << escapeString(args.title) << "\n"; dest << "COUNT=" << args.count << "\n"; dest << "OPTIONS=" << escapeString(args.options) << "\n"; dest << "CUPS_BOOMAGA_DATA\n"; dest << src.rdbuf(); dest.close(); if (src.bad() || !dest.good()) { Log::debug("Delete file %s", destFile.c_str()); unlink(destFile.c_str()); Log::error("Can't create job file: %s", strerror(errno)); return false; } if (chown(destFile.c_str(), args.pwd->pw_uid, -1) != 0) { Log::error("Can't change owner on directory %s: %s", destFile.c_str(), std::strerror(errno)); return false; } return true; }
void safeGetline(istream& is, string& t) { t.clear(); std::istream::sentry se(is, true); std::streambuf* sb = is.rdbuf(); while (true) { int c = sb->sbumpc(); switch (c) { case '\n': return; case '\r': if (sb->sgetc() == '\n') sb->sbumpc(); return; case EOF: if (t.empty()) is.setstate(std::ios::eofbit); return; default: t += (char)c; } } }
template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream) { string temp; char_traits<char>::int_type c; while(true){ c = stream.rdbuf()->sgetc(); if(c != char_traits<char>::eof() && isspace(c) == false){ stream.rdbuf()->sbumpc(); temp.append(1, char_traits<char>::to_char_type(c)); }else{ break; } } if (temp.size() == 0) stream.setstate(ios_base::eofbit|ios_base::failbit); return temp; }
short _Ipfx(istream& Is_, int noskip) { if (Is_.good()) { if (Is_.tie() != 0) Is_.tie()->flush(); if (!noskip && Is_.flags() & ios::skipws) { int ch; while (isspace(ch = Is_.rdbuf()->sbumpc())) ; if (ch != EOF) Is_.rdbuf()->sputbackc(ch); } if (Is_.good()) return 1; } Is_.clear(ios::failbit); return 0; }
void zipios::ZipOutputStreamTest::entryToFile(const string &ent_name, istream &is, const string &outfile, bool cerr_report) { ofstream ofs( outfile.c_str(), ios::out | ios::binary ) ; ofs << is.rdbuf() ; if ( cerr_report ) { cerr << "writing " << ent_name << " to " << outfile << endl ; cerr << "Stream state: " ; cerr << "good() = " << is.good() << ",\t" ; cerr << "fail() = " << is.fail() << ",\t" ; cerr << "bad() = " << is.bad() << ",\t" ; cerr << "eof() = " << is.eof() << endl << endl; } ofs.close() ; }
bool ios_base::sync_with_stdio(bool sync) { static ios_base::Init __make_sure_streams_are_constructed; static bool previous_sync = true; bool result = previous_sync; previous_sync = sync; cin.rdbuf()->pubsetbuf(0, !sync); cout.rdbuf()->pubsetbuf(0, !sync); clog.rdbuf()->pubsetbuf(0, !sync); cerr.rdbuf()->pubsetbuf(0, !sync); #ifndef _EWL_NO_WCHART_CPP_SUPPORT wcin.rdbuf()->pubsetbuf(0, !sync); wcout.rdbuf()->pubsetbuf(0, !sync); wclog.rdbuf()->pubsetbuf(0, !sync); wcerr.rdbuf()->pubsetbuf(0, !sync); #endif // _EWL_NO_WCHART_CPP_SUPPORT return result; }
//ring buffer ring_buffer::ring_buffer(const istream& fin_) :fin(fin_.rdbuf()) { has_loaded_EOF=false; has_read_EOF=false; length_read=0; length_loaded=0; n_nodes=1; ring_buffer_node* new_node=new ring_buffer_node(); new_node->next=new_node; new_node->previous=new_node; start_node=new_node; end_node=new_node; empty_node=new_node; add_nodes(2000); load_data(); }
void CommandFoeWrite::loadFoeData( ec_ioctl_slave_foe_t *data, const istream &in ) { stringstream err; ostringstream tmp; tmp << in.rdbuf(); string const &contents = tmp.str(); if (getVerbosity() == Verbose) { cerr << "Read " << contents.size() << " bytes of FoE data." << endl; } data->buffer_size = contents.size(); if (data->buffer_size) { // allocate buffer and read file into buffer data->buffer = new uint8_t[data->buffer_size]; contents.copy((char *) data->buffer, contents.size()); } }
/* * Clears an istream object if unusuable characters are entered. Copied from MSDN. */ void clear_error(istream& in) { streambuf* sbpThis; char szTempBuf[20]; std::streamsize nCount; in.clear(); // Clear error flags sbpThis = in.rdbuf(); // Get streambuf pointer nCount = sbpThis->in_avail(); // Number of characters in buffer while (nCount) // Extract them to szTempBuf { if (nCount > 20) { sbpThis->sgetn(szTempBuf, 20); nCount -= 20; } else { sbpThis->sgetn(szTempBuf, nCount); nCount = 0; } } }
/** * * @param path * @throws SignatureException */ SignatureBES::SignatureBES(istream &sigdata, BDoc *bdoc) : signature(nullptr) , asicsignature(nullptr) , bdoc(bdoc) { try { stringstream is; is << sigdata.rdbuf(); sigdata_ = is.str(); Properties properties; properties.schema_location(XADES_NAMESPACE, File::fullPathUrl(Conf::instance()->xsdPath() + "/XAdES.xsd")); properties.schema_location(XADESv141_NAMESPACE, File::fullPathUrl(Conf::instance()->xsdPath() + "/XAdESv141.xsd")); properties.schema_location(URI_ID_DSIG, File::fullPathUrl(Conf::instance()->xsdPath() + "/xmldsig-core-schema.xsd")); properties.schema_location(ASIC_NAMESPACE, File::fullPathUrl(Conf::instance()->xsdPath() + "/ts_102918v010201.xsd")); asicsignature = xAdESSignatures(is, Flags::dont_initialize, properties).release(); if(asicsignature->signature().size() > 1) THROW("More than one signature in signatures.xml file is unsupported"); if(asicsignature->signature().empty()) THROW("Failed to parse signature XML"); signature = &asicsignature->signature()[0]; } catch(const Parsing& e) { stringstream s; s << e; THROW("Failed to parse signature XML: %s", s.str().c_str()); } catch(const xsd::cxx::exception& e) { THROW("Failed to parse signature XML: %s", e.what()); } #if 0 for(const ReferenceType &ref: signature->signedInfo().reference()) if(ref.transforms().present()) THROW("Transforms are not supported"); #endif const QualifyingPropertiesType::SignedPropertiesOptional &sp = qualifyingProperties().signedProperties(); if(sp.present()) { const SignedPropertiesType::SignedDataObjectPropertiesOptional &sdop = sp->signedDataObjectProperties(); if(sdop.present()) { if(!sdop->commitmentTypeIndication().empty()) THROW("CommitmentTypeIndicationType is not supported"); if(!sdop->allDataObjectsTimeStamp().empty()) THROW("AllDataObjectsTimeStamp is not supported"); if(!sdop->individualDataObjectsTimeStamp().empty()) THROW("IndividualDataObjectsTimeStampType is not supported"); } } const QualifyingPropertiesType::UnsignedPropertiesOptional &up = qualifyingProperties().unsignedProperties(); if(up.present()) { if(up->unsignedDataObjectProperties().present()) THROW("UnsignedDataObjectProperties are not supported"); const UnsignedPropertiesType::UnsignedSignaturePropertiesOptional &usp = up->unsignedSignatureProperties(); if(usp.present()) { if(!usp->counterSignature().empty()) THROW("CounterSignature is not supported"); if(!usp->completeCertificateRefs().empty()) THROW("CompleteCertificateRefs are not supported"); if(!usp->completeRevocationRefs().empty()) THROW("CompleteRevocationRefs are not supported"); if(!usp->attributeCertificateRefs().empty()) THROW("AttributeCertificateRefs are not supported"); if(!usp->attributeRevocationRefs().empty()) THROW("AttributeRevocationRefs are not supported"); if(!usp->sigAndRefsTimeStamp().empty()) THROW("SigAndRefsTimeStamp is not supported"); if(!usp->refsOnlyTimeStamp().empty()) THROW("RefsOnlyTimeStamp is not supported"); if(!usp->attrAuthoritiesCertValues().empty()) THROW("AttrAuthoritiesCertValues are not supported"); if(!usp->attributeRevocationValues().empty()) THROW("AttributeRevocationValues are not supported"); if(!usp->archiveTimeStamp().empty()) THROW("ArchiveTimeStamp is not supported"); if(!usp->timeStampValidationData().empty()) THROW("TimeStampValidationData is not supported"); } } // Base class has verified the signature to be valid according to XML-DSig. // Now perform additional checks here and throw if this signature is // ill-formed according to BDoc. getSignedSignatureProperties(); // assumed to throw in case this block doesn't exist signingCertificate(); // assumed to throw in case this block doesn't exist if(id().empty()) THROW("Signature element mandatory attribute 'Id' is missing"); }
ios::iostate __getaline( istream &istrm, char *buf, int len, /***************************************************************/ char delim, int is_get, int &chars_read ) { // Read characters into buffer "buf". // At most "len - 1" characters are read, and a 0 is added at the end. // If "delim" is encountered, it is left in the stream and the read is // terminated (and the NULLCHAR is added). // Used by: // get( char *buf, int len, char delim ) // getline( char *buf, int len, char delim ) // // NOTE: Borland sets eofbit only. A full buffer just stops reading. // If something has been read, set eofbit anyway. // // The proposed standard says to set failbit if the buffer is filled // without finding the delimiter (if doing a "getline"), or if a read // fails and no characters are extracted. It says nothing about eofbit. // // Currently we set eofbit only if eof occurs on first character read. // failbit is set if no characters were read. // // Failbit was being set (prior to Nov15,95) when len-1 characters were // read in the buffer. At that time we discerned that no one else // was setting failbit in that case, so we stopped doing it. int c; int offset; ios::iostate state = 0; streambuf *sb; offset = 0; __lock_it( istrm.__i_lock ); if( len > 1 && istrm.ipfx( 1 ) ) { sb = istrm.rdbuf(); __lock_it( sb->__b_lock ); len--; // leave a space for the NULLCHAR while( offset < len ) { c = sb->speekc(); if( c == EOF ) { if( offset == 0 ) { state |= ios::eofbit; } break; } if( c == delim ) { if( !is_get ) { sb->sbumpc(); } break; } buf[offset++] = (char)c; sb->sbumpc(); } istrm.isfx(); } buf[offset] = '\0'; chars_read = offset; // the draft standard says that no characters is an // error if using get() or getline(). // the IOStreams Handbook suggests that no characters is not // an error if the delim was seen, this seems to be what our // competitors do. if( (offset == 0) && (c != delim) ) { state |= ios::failbit; } // the draft standard says that len-1 characters is an // error if using getline() // our competitors don't agree with the draft, we won't follow the // draft either #if 0 if( offset == len && !is_get ) { state |= ios::failbit; } #endif return( state ); }
static string slurpStream(istream& in) { stringstream sstr; sstr << in.rdbuf(); string result = sstr.str(); return result; }
void Redirect( istream& from, istream& to ) { CheckInit(); from.rdbuf( to.rdbuf() ); }
string slurpStream(istream& in) { stringstream sstr; sstr << in.rdbuf(); return sstr.str(); }
Text parse(bool cli, istream& is) { // some initialization int line = 0; ifstream file; std::streambuf *backup = is.rdbuf(); // if text is not from files if (cli) { bool invalid = true; string dir; do { line = headline(); cout << "\n\n\n\n"; if (dir == "") cout << "\n\n"; else cout << " You can't break this, " << "I'm handling errors properly!\n\n"; cout << " Please insert the directory " << "of a text file for analysis.\n"; cout << " The file should be pre-formatted " << "like this:\n\n"; cout << " <Title>\n"; cout << " <Author>\n\n"; cout << " <text to analyze>\n\n"; cout << " or pipe an input stream before " << "executing.\n"; for (int i = line += 9 + 7; i<25 - 1; i++) cout << "\n"; cout << "Directory: "; if (getline(is, dir)) { (file.open(dir.c_str(), ifstream::in)); if (file) invalid = false; else { cout << "file could not be opened\n"; // exit(69); } } } while (invalid); is.rdbuf(file.rdbuf()); cout << "istream mapped to cin.\n"; } // check how many paragraphs are there string paragraph; int no_of_pars = 0; vector<string> pars; while (getline(is, paragraph)) { if (paragraph != "") { ++no_of_pars; pars.push_back(paragraph); } } // invalid format if (no_of_pars < 2) { is.rdbuf(backup); file.close(); line = headline(); cout << "\n\n\n\n\n\n\n Invalid format!" << "\n Error: " << "file has less than 2 lines." << "\n\n Try again maybe?"; for (int i = line + 11; i < 24; i++) cout << "\n"; if (!cli) { //cout << "piped, quitting"; exit(1); } cout << "Press Enter to try again."; is.ignore(); return parse(cli, is); } // new text object, having all word pairs Text text(pars[0], pars[1]); text.paragraphs = no_of_pars - 2; // count words and split vector<string> words; // word vector int no_of_sentences = 0; for (auto iter = pars.begin() + 2; iter != pars.end(); ++iter) { no_of_sentences += split(*iter, words); } text.sentences = no_of_sentences; text.words = words.size(); // sorting word sort(words.begin(), words.end()); // reusing variable paragraph for temp read word paragraph = ""; int times_appeared = 0; for (auto iter = words.begin(); iter != words.end(); ++iter) { if (!iter->compare(paragraph)) { ++times_appeared; } else { if (times_appeared != 0) text.wordMap.insert(pair<string, int>(paragraph, times_appeared)); cout << "pushed in " << paragraph << " " << times_appeared << "\n"; times_appeared = 1; } paragraph = *iter; } // the last one never got included, so we have to manually add it text.wordMap.insert(pair<string, int>(paragraph, times_appeared)); cout << "pushed in " << paragraph << " " << times_appeared << "\n"; cout << "pushed all in, size " << text.wordMap.size() << "\n"; // return cin rdbuf if (cli) { is.rdbuf(backup); cout << "istream (cin) reverted.\n"; file.close(); cout << "Opened file closed.\n"; } cout << "Parse successful.\n"; return text; }