bool GLScene::load(string filename)//without extension { StreamFile str(filename+".glscene",true); if(!str.good())return false; readFromStream(str); return true; }
DataDictionary::DataDictionary( std::istream& stream ) throw( ConfigError ) : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ), m_checkFieldsHaveValues( true ), m_checkUserDefinedFields( true ) { readFromStream( stream ); }
void PhysicalInStream::skipInStream(size_t size) { // default implementation char* dummy = new char[size]; readFromStream(dummy, size); delete[] dummy; }
void RMTony::init() { RMRes tony(0); RMRes body(9999); // Tony is shown by default _bShow = _bShowShadow = true; // No action pending _bActionPending = false; _bAction = false; _bShepherdess = false; _bIsTalking = false; _bIsStaticTalk = false; // Opens the buffer Common::SeekableReadStream *ds = tony.getReadStream(); // Reads his details from the stream readFromStream(*ds, true); // Closes the buffer delete ds; // Reads Tony's body ds = body.getReadStream(); _body.readFromStream(*ds, true); delete ds; _body.setPattern(0); _nTimeLastStep = g_vm->getTime(); }
InputStream &InputStream::read(double &value) { assert(streamBuffer); readFromStream(*streamBuffer, value); return *this; }
InputStream &InputStream::read(signed int &value) { assert(streamBuffer); readFromStream(*streamBuffer, value); return *this; }
void Riff::readFromFile(QString fileName) { QFile file(m_fileName = fileName); file.open(QIODevice::ReadOnly); QDataStream ds(&file); readFromStream(&ds); file.close(); }
// Extract the next record from the stream leaving it in the cache for future read. // Always call resetPointerToBegin for the extracted CFRecord after using it CFRecordPtr CFStreamCacheReader::touchTheNextRecord() { if(readFromStream(1))// make sure something is in cache { return records_cache.front(); } return CFRecordPtr(); }
void RoNetPacket::tryReadFromStream(RoDataStream& stream) { roTRY readFromStream(stream); roCATCH_STD_EXCEPTION roLOG_CRIT << "Reading data for packet '" << mAction << "'... [FAILED]"; roEXIT_GAME; roCATCH_END }
// Check the next record type const CFRecordType::TypeId CFStreamCacheReader::getNextRecordType() { if(isEOF()) { return rt_NONE; } readFromStream(1); // I don't check the result of readFromStream() because it was done implicitly in isEOF() return records_cache.front()->getTypeId(); }
size_t Sample::read(const uint8_t* const sampleStream, const size_t playhead, Sample* const target) { const auto next = peekIndex(sampleStream, playhead); size_t newPlayhead = playhead + sizeof(Sample::Index); if (next.typeMask & Transform::Position) newPlayhead = readFromStream(sampleStream, newPlayhead, &target->position); if (next.typeMask & Transform::Scale) newPlayhead = readFromStream(sampleStream, newPlayhead, &target->scale); if (next.typeMask & Transform::Rotation) newPlayhead = readFromStream(sampleStream, newPlayhead, &target->rotation); if (next.typeMask & Transform::Shear) newPlayhead = readFromStream(sampleStream, newPlayhead, &target->shear); if (next.typeMask & Transform::Color) newPlayhead = readFromStream(sampleStream, newPlayhead, &target->color); return newPlayhead; }
var var::readFromStream (InputStream& input) { const int numBytes = input.readCompressedInt(); if (numBytes > 0) { switch (input.readByte()) { case varMarker_Int: return var (input.readInt()); case varMarker_Int64: return var (input.readInt64()); case varMarker_BoolTrue: return var (true); case varMarker_BoolFalse: return var (false); case varMarker_Double: return var (input.readDouble()); case varMarker_String: { MemoryOutputStream mo; mo.writeFromInputStream (input, numBytes - 1); return var (mo.toUTF8()); } case varMarker_Binary: { MemoryBlock mb (numBytes - 1); if (numBytes > 1) { const int numRead = input.read (mb.getData(), numBytes - 1); mb.setSize (numRead); } return var (mb); } case varMarker_Array: { var v; Array<var>* const destArray = v.convertToArray(); for (int i = input.readCompressedInt(); --i >= 0;) destArray->add (readFromStream (input)); return v; } default: input.skipNextBytes (numBytes - 1); break; } } return var::null; }
bool SerializerNew::deserializeFromStream(Variant& v, IDataStream* stream, SerializationFormat format) { if (stream == nullptr) return false; auto doc = getDocument(format); if (!doc->readFromStream(stream)) { return false; } return deserializeFromDocument(v, doc.get()); }
const bool CFStreamCacheReader::SeekToEOF() { while(readFromStream(1)) { if(rt_EOF == records_cache.front()->getTypeId()) { // records_cache.pop_front(); // Skip EOF break; } records_cache.pop_front(); // Skip non-EOF } return true; }
// Check if the next read record would be of desired type const bool CFStreamCacheReader::checkNextRecord(const CFRecordType::TypeId desirable_type, const size_t num_records_to_check) { readFromStream(num_records_to_check); // if we would get what was requested // ANY_TYPE is checked just to make the fake read from stream and get an error if the stream is ended for(std::list<CFRecordPtr>::const_iterator it = records_cache.begin(), itEnd = records_cache.end(); it != itEnd; ++it) { size_t type = (*it)->getTypeId(); if(desirable_type == (*it)->getTypeId() || desirable_type == CFRecordType::ANY_TYPE) { return true; } } return false; }
// Reads the next CFRecord from the CFStream and if its type is not the desired one, caches it for the next call CFRecordPtr CFStreamCacheReader::getNextRecord(const CFRecordType::TypeId desirable_type, const bool gen_except) { CFRecordType::TypeId what_we_actually_read = rt_NONE; while(readFromStream(1)) { CFRecordType::TypeString rec_name = records_cache.front()->getTypeString(); //Log::warning(rec_name); if (desirable_type == rt_MsoDrawingGroup) // объединяем rt_MsoDrawingGroup + rt_Continue в один блок { if (checkNextRecord(desirable_type, 1)) { readFromStream(2); for(std::list<CFRecordPtr>::iterator good = records_cache.begin(), it = ++records_cache.begin(); it != records_cache.end(); ++it, ++good) { while ((it != records_cache.end()) && (desirable_type == (*it)->getTypeId())) { (*good)->appendRawData(*it); records_cache.erase(it); if(!stream_->isEOF()) { records_cache.push_back(CFRecordPtr(new CFRecord(stream_, global_info_))); } it = good; ++it; } } } } if(0 == rec_name.length()) { Log::warning(L"The extracted record has obsoleted or unknown type(0x" + STR::int2hex_wstr(records_cache.front()->getTypeId(), sizeof(CFRecordType::TypeId)) + L")"); records_cache.pop_front(); continue; } if(skippable_records_names.end() != std::find(skippable_records_names.begin(), skippable_records_names.end(), rec_name)) { //Log::warning("The extracted record has been skipped (" + rec_name + ")"); records_cache.pop_front(); continue; } break; } if(0 != records_cache.size()) { what_we_actually_read = records_cache.front()->getTypeId(); // if we get what was requested if(desirable_type == what_we_actually_read || desirable_type == CFRecordType::ANY_TYPE) { CFRecordPtr ret = records_cache.front(); records_cache.pop_front(); return ret; } } if(gen_except) { // теги разные std::string inType = XLS::CFRecordType::getStringById(desirable_type); std::string outType = CFRecordType::getStringById(what_we_actually_read); Log::warning("The extracted record is not of requested type.\nRequested: \"" + XLS::CFRecordType::getStringById(desirable_type) + "\" Extracted: \"" + CFRecordType::getStringById(what_we_actually_read) + "\""); } return CFRecordPtr(); }
// ###################################################################### BitObject::BitObject(std::istream& is) { readFromStream(is); }
void SerialShell::update() { readFromStream(); if (_data[_len - 2] == '\n') { // full command received for (int i = 0; i < _functionCount; i++) { for (int c = 0; c < _len; c++) { if (_functions[i].command[c] == NULL && (_data[c] == ' ' || _data[c] == '\n')) { // match char* newData = NULL; int newDataLen = 0; int nlPos = 0; for (int cc = c + 1; cc < _len; cc++) { if (nlPos > 0) { newData[cc - nlPos - 1] = _data[cc]; } else if (_data[cc] == '\n') { if (cc < _len - 2) { // multiple commands nlPos = cc; newDataLen = _len - cc - 1; newData = new char[newDataLen + 1]; } _data[cc] = NULL; } } if (_data[c + 1] == NULL) { _functions[i].callback(_serial, NULL); } else { _functions[i].callback(_serial, _data + c + 1); } _len = 0; delete _data; _data = NULL; if (newData != NULL) { _data = newData; _len = newDataLen; } } else if (_data[c] == _functions[i].command[c]) { // ok, continue } else { // no match, go to next command break; } } } flushTrash(); } }
void MavlinkBridge::threadMain() { while (running) { readFromStream(); this_thread::sleep_for(chrono::milliseconds(10)); } }