std::shared_ptr<Response> request(const std::string& request_type, const std::string& path, std::iostream& content, const std::map<std::string, std::string>& header = std::map<std::string, std::string>()) { std::string corrected_path = path; if (corrected_path == "") corrected_path = "/"; content.seekp(0, std::ios::end); auto content_length = content.tellp(); content.seekp(0, std::ios::beg); boost::asio::streambuf write_buffer; std::ostream write_stream(&write_buffer); write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n"; write_stream << "Host: " << host << "\r\n"; for (auto& h : header) { write_stream << h.first << ": " << h.second << "\r\n"; } if (content_length>0) write_stream << "Content-Length: " << content_length << "\r\n"; write_stream << "\r\n"; if (content_length>0) write_stream << content.rdbuf(); try { connect(); boost::asio::write(*socket, write_buffer); } catch (const std::exception& e) { socket_error = true; throw std::invalid_argument(e.what()); } return request_read(); }
void Client::setResponseContentLength(Transaction& trans, std::iostream& os) { os.seekg(0, std::ios::end); int os_length = os.tellg(); os_length--; os.seekg(0, std::ios::beg); trans.getResponse().getHeaders().setValue("CONTENT-LENGTH", inttostr(os_length)); }
void SkillLevelEvent::save( std::iostream& ios ) { Event::save(ios); // Save bonus ios.write( (char*) &bonus, sizeof( bonus ) ); // Save skill ios.write( (char*) &skill, sizeof( skill ) ); }
SkillLevelEvent::SkillLevelEvent( std::iostream& ios ) : Event(ios) { // Read bonus ios.read( (char*) &bonus, sizeof( bonus ) ); // Read skill ios.read( (char*) &skill, sizeof( skill ) ); }
void Ammo::toFile( std::iostream& outFile ) { // Write Item base information: Item::toFile( outFile ); // Write char form outFile.write( (char*) &form, sizeof(form) ); // Write bool fired outFile.write( (char*) &fired, sizeof(fired) ); }
Ammo::Ammo( std::iostream& inFile, TargetValue* TVP ) // Read Item base information: : Item (inFile, TVP) { // Read char form inFile.read( (char*) &form, sizeof(form) ); // Read bool fired inFile.read( (char*) &fired, sizeof(fired) ); }
void FillStream(std::iostream& strm, RawData& expression) { static const std::string s_smallExpression("0123456789abcdefghijklmnopqrstuvwxyz"); static const int iterationsCount = 10; for (int i = 0; i < iterationsCount; ++i) { strm << s_smallExpression; } size_t expressionSize = iterationsCount * s_smallExpression.size(); expression.resize(expressionSize); strm.read(reinterpret_cast<char*>(&expression[0]), expressionSize); strm.seekg(0); }
gzstream::gzstream( std::iostream & strm, unsigned int buffer_size ) : std::iostream( static_cast< std::streambuf * >( 0 ) ) , M_gzstreambuf( *(strm.rdbuf()), buffer_size ) { this->init( &M_gzstreambuf ); }
Event::Event( std::iostream& ios ) { ios.read( (char*) &time, sizeof(time) ); Timeline::add( this ); }
void _serialize(std::iostream &fs, serialization_context &context) { assert(target > 0); assert(context.ss.objects.count(target) > 0); fs << target << " "; target = 0; assert(fs.good()); context.is_leaf = false; }
void grab_content(const char* file_name, std::iostream& in) { parser p(file_name); interpreter_DAG ipt(p.get_problem_representation(), in); if (!in.good()) error("unexpected error"); }
Fluid::Fluid( std::iostream& inFile, TargetValue* TVP ) // Read Item base information: : Item (inFile, TVP) { // Read materialClass f_material inFile.read( (char*) &f_material, sizeof(f_material) ); }
void readExactly(size_t toread, std::iostream& result) { size_t hasread = 0; while(toread > hasread && std::cin.good()) { char a[1]; std::cin.read(a,1); result.write(a,1); hasread++; } }
void Fluid::toFile( std::iostream& outFile ) { // Write Item base information: Item::toFile( outFile ); // Write materialClass f_material outFile.write( (char*) &f_material, sizeof(f_material) ); }
/*! */ gzfilterstream::gzfilterstream( std::iostream & strm, int level, std::size_t buf_size ) : std::iostream( static_cast< std::streambuf* >( 0 ) ) , M_filter_buf( *(strm.rdbuf()), level, buf_size ) { // std::basic_ios::init( basic_streambuf<charT,traits>* sb ); this->init( &M_filter_buf ); }
void _deserialize(std::iostream &fs, serialization_context &context) { assert(target == 0); ss = &context.ss; fs >> target; assert(fs.good()); assert(context.ss.objects.count(target) > 0); // We just created a new reference to this object and // invalidated the on-disk reference, so the total refcount // stays the same. }
void ActionEvent::save( std::iostream& ios ) { Event::save(ios); // Save target ios << target; // Save actor ios.write( (char*) &action, sizeof( action ) ); }
ActionEvent::ActionEvent( std::iostream& ios ) : Event(ios) { // Read target ios >> target; // Read actor ios.read( (char*) &action, sizeof( action ) ); }
void ResourceManager::loadFile(const std::string& fileName, std::iostream& out) { out.clear(std::ios::goodbit); if(m_hasSearchPath) { std::string fullPath = resolvePath(fileName); PHYSFS_file* file = PHYSFS_openRead(fullPath.c_str()); if(!file) { out.clear(std::ios::failbit); stdext::throw_exception(stdext::format("failed to load file '%s': %s", fullPath.c_str(), PHYSFS_getLastError())); } else { int fileSize = PHYSFS_fileLength(file); if(fileSize > 0) { std::vector<char> buffer(fileSize); PHYSFS_read(file, (void*)&buffer[0], 1, fileSize); out.write(&buffer[0], fileSize); } else out.clear(std::ios::eofbit); PHYSFS_close(file); out.seekg(0, std::ios::beg); } } else { std::ifstream fin(fileName); if(!fin) { out.clear(std::ios::failbit); stdext::throw_exception(stdext::format("failed to load file '%s': %s", fileName.c_str(), PHYSFS_getLastError())); } else { out << fin.rdbuf(); } } }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRLookUpLight::Save(std::iostream stream) { // Check_Object(this); Check_Object(stream); MLRInfiniteLight::Save(stream); *stream << mapOrigin; *stream << mapZoneCountX << mapZoneCountZ; *stream << zoneSizeX << zoneSizeZ; *stream << mapName; for (size_t i = 0; i < mapZoneCountX * mapZoneCountZ; i++) { stream->WriteBytes(maps[i], 256 * 256); } }
std::string StringUtilities::GetAsString(std::iostream& i_stream) { int length; char* p_buffer; // get length of file: i_stream.seekg (0, std::iostream::end); length = static_cast<int>(i_stream.tellg()); i_stream.seekg (0, std::iostream::beg); // allocate memory: p_buffer = new char [length]; //write file int pos = 0; while(i_stream.good()) { p_buffer[pos] = i_stream.get(); ++pos; } std::string out(p_buffer, pos); delete[] p_buffer; return out; }
template<class Key, class Value> void serialize(std::iostream &fs, serialization_context &context, std::map<Key, Value> &mp) { fs << "map " << mp.size() << " {" << std::endl; assert(fs.good()); for (auto it = mp.begin(); it != mp.end(); ++it) { fs << " "; serialize(fs, context, it->first); fs << " -> "; serialize(fs, context, it->second); fs << std::endl; } fs << "}" << std::endl; }
void FilePiece::print(int64_t from, int64_t to, std::iostream &outStream) { if (fileData) { const int64_t BUFFSIZE = 8192; int64_t targetLength; uint8_t buffer[BUFFSIZE]; for (int64_t i = from; i <= to; i += targetLength) { targetLength = MIN(BUFFSIZE, to - i + 1); cs.read(buffer, i, targetLength); outStream.write((const char *)buffer, targetLength); } } else { if (signature == SIG_CDFH || signature == SIG_DD) { FilePiece* fileDataPiece = (FilePiece*)extraBuffer; if (fileDataPiece->cs.reachedOffset < (fileDataPiece->length - 1)) { uint8_t tmp; fileDataPiece->cs.read(&tmp, fileDataPiece->length - 1, 1); } if (fileDataPiece->cs.reachedOffset < (int64_t)(fileDataPiece->length - 1)) //safety measure: insufficient crc abort(); if (signature == SIG_CDFH) ((CDFH*)buffer)->CRC32 = fileDataPiece->cs.crc.GetCRC32(); else if (signature == SIG_DD) ((DD*)buffer)->CRC32 = fileDataPiece->cs.crc.GetCRC32(); } outStream.write((const char *)buffer + from, to - from + 1); } }
bool ResourceManager::saveFile(const std::string& fileName, std::iostream& in) { std::streampos oldPos = in.tellg(); in.seekg(0, std::ios::end); std::streampos size = in.tellg(); in.seekg(0, std::ios::beg); std::vector<char> buffer(size); in.read(&buffer[0], size); bool ret = saveFile(fileName, (const uchar*)&buffer[0], size); in.seekg(oldPos, std::ios::beg); return ret; }
template<class Key, class Value> void deserialize(std::iostream &fs, serialization_context &context, std::map<Key, Value> &mp) { std::string dummy; int size = 0; fs >> dummy >> size >> dummy; assert(fs.good()); for (int i = 0; i < size; i++) { Key k; Value v; deserialize(fs, context, k); fs >> dummy; deserialize(fs, context, v); mp[k] = v; } fs >> dummy; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRLookUpLight::MLRLookUpLight(std::iostream stream, uint32_t version) : MLRInfiniteLight(DefaultData, stream, version) { Check_Object(stream); // _ASSERT(gos_GetCurrentHeap() == Heap); *stream >> mapOrigin; *stream >> mapZoneCountX >> mapZoneCountZ; *stream >> zoneSizeX >> zoneSizeZ; *stream >> mapName; one_Over_zoneSizeX = 1.0f / zoneSizeX; one_Over_zoneSizeZ = 1.0f / zoneSizeZ; maps = new puint8_t[mapZoneCountX * mapZoneCountZ]; Check_Pointer(maps); for (size_t i = 0; i < mapZoneCountX * mapZoneCountZ; i++) { maps[i] = new uint8_t[256 * 256]; Check_Pointer(maps[i]); stream->ReadBytes(maps[i], 256 * 256); } }
void on_connected(socket& /*socket*/, std::iostream& stream) { for (std::size_t keep_alive_count = config_.maximum_keep_alive_requests; keep_alive_count != 0; --keep_alive_count) { stream.exceptions(std::ios_base::badbit); if (stream.peek() == EOF) { stream.clear(); break; } stream.exceptions(std::ios_base::eofbit | std::ios_base::failbit | std::ios_base::badbit); http_server_context context(stream, config_); http_request& req = context.request(); http_response& res = context.response(); bool head = false; bool keep_alive = false; try { context.read_headers(); switch (req.get_method()) { case http_method::head: head = true; break; case http_method::get: case http_method::post: break; default: BOOST_THROW_EXCEPTION(http_exception(http_status_code::method_not_allowed)); } if (req.is_connection_keep_alive()) { res.set_keep_alive_requests(keep_alive_count); keep_alive = true; } context.validate_headers(); if (config_.logger) config_.logger->http_server_request(req); try { switch (req.get_method()) { case http_method::head: case http_method::get: derived().on_get(context, head); break; case http_method::post: derived().on_post(context); break; default: BOOST_THROW_EXCEPTION(http_exception(http_status_code::method_not_allowed)); } } catch(http_exception&) { throw; } catch (interrupted_exception&) { throw; } catch (std::exception&) { BOOST_THROW_EXCEPTION(http_exception(http_status_code::internal_service_error)); } } catch (http_exception& e) { if (config_.logger) config_.logger->exception(); res.set_status_code(e.status_code()); try { auto it = config_.error_document.find(e.status_code()); if (it != config_.error_document.end()) BOOST_THROW_EXCEPTION(http_exception(http_status_code::not_found)); req.set_path(it->second); derived().on_get(context, head); } catch (http_exception&) { null_content().on_get(context, head); } } context.finish_write(); if (!keep_alive) break; } }
void Event::save( std::iostream& ios ) { ios.write( (char*) &time, sizeof(time) ); }
bool test_seekable_in_chars(std::iostream& io) { int i; // old 'for' scope workaround. // Test seeking with ios::cur for (i = 0; i < data_reps; ++i) { int j; for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); io.seekp(-chunk_size, BOOST_IOS::cur); for (j = 0; j < chunk_size; ++j) if (io.get() != narrow_data()[j]) return false; io.seekp(-chunk_size, BOOST_IOS::cur); for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); } // Test seeking with ios::beg std::streamoff off = 0; io.seekp(0, BOOST_IOS::beg); for (i = 0; i < data_reps; ++i, off += chunk_size) { int j; for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); io.seekp(off, BOOST_IOS::beg); for (j = 0; j < chunk_size; ++j) if (io.get() != narrow_data()[j]) return false; io.seekp(off, BOOST_IOS::beg); for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); } // Test seeking with ios::end io.seekp(0, BOOST_IOS::end); off = io.tellp(); io.seekp(-off, BOOST_IOS::end); for (i = 0; i < data_reps; ++i, off -= chunk_size) { int j; for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); io.seekp(-off, BOOST_IOS::end); for (j = 0; j < chunk_size; ++j) if (io.get() != narrow_data()[j]) return false; io.seekp(-off, BOOST_IOS::end); for (j = 0; j < chunk_size; ++j) io.put(narrow_data()[j]); } return true; }
bool test_seekable_in_chunks(std::iostream& io) { int i; // old 'for' scope workaround. // Test seeking with ios::cur for (i = 0; i < data_reps; ++i) { io.write(narrow_data(), chunk_size); io.seekp(-chunk_size, BOOST_IOS::cur); char buf[chunk_size]; io.read(buf, chunk_size); if (strncmp(buf, narrow_data(), chunk_size) != 0) return false; io.seekp(-chunk_size, BOOST_IOS::cur); io.write(narrow_data(), chunk_size); } // Test seeking with ios::beg std::streamoff off = 0; io.seekp(0, BOOST_IOS::beg); for (i = 0; i < data_reps; ++i, off += chunk_size) { io.write(narrow_data(), chunk_size); io.seekp(off, BOOST_IOS::beg); char buf[chunk_size]; io.read(buf, chunk_size); if (strncmp(buf, narrow_data(), chunk_size) != 0) return false; io.seekp(off, BOOST_IOS::beg); io.write(narrow_data(), chunk_size); } // Test seeking with ios::end io.seekp(0, BOOST_IOS::end); off = io.tellp(); io.seekp(-off, BOOST_IOS::end); for (i = 0; i < data_reps; ++i, off -= chunk_size) { io.write(narrow_data(), chunk_size); io.seekp(-off, BOOST_IOS::end); char buf[chunk_size]; io.read(buf, chunk_size); if (strncmp(buf, narrow_data(), chunk_size) != 0) return false; io.seekp(-off, BOOST_IOS::end); io.write(narrow_data(), chunk_size); } return true; }