bool RINEX_NavigationMessage::Read(const bool withQZSS) { std::ifstream ifs; bool flag_gnss = false; bool flag_qzss = false; bool from_RTKconv = false; std::string fname = filename + "n"; ifs.open(fname.c_str()); if (!ifs.is_open()) { std::string fname = filename + ".nav"; ifs.open(fname.c_str()); if (!ifs.is_open()) { return flag_gnss; } else { from_RTKconv = true; } } else { // Do nothing } flag_gnss = _Read(ifs); ifs.close(); if (!from_RTKconv && withQZSS) { fname = filename + "q"; ifs.open(fname.c_str()); if (!ifs.is_open()) { return flag_gnss; } else { flag_qzss = _Read(ifs); } } else { return flag_gnss; } return (flag_gnss && flag_qzss); }
status_t BDebugEventInputStream::_GetData(size_t size) { if (fBufferSize >= size) return B_OK; if (size > fBufferCapacity) return B_BUFFER_OVERFLOW; // move remaining data to the start of the buffer if (fBufferSize > 0 && fBufferPosition > 0) memmove(fBuffer, fBuffer + fBufferPosition, fBufferSize); fStreamPosition += fBufferPosition; fBufferPosition = 0; // read more data if (fStream != NULL) { ssize_t bytesRead = _Read(fBuffer + fBufferSize, fBufferCapacity - fBufferSize); if (bytesRead < 0) return bytesRead; fBufferSize += bytesRead; } return fBufferSize >= size ? B_OK : B_BAD_DATA; }
/********************************************************************* * * I2C_Read * * Function description * Reads from a device on I2C. */ U8 I2C_Read(U32 I2CBaseAddr, U8 Addr, U8 * pData, U16 NumBytesToRead) { U8 r; SET_BASE_ADDR(I2CBaseAddr); r = _Read(Addr << 1, pData, NumBytesToRead, 0); return r; }
nOS_Error nOS_QueueRead (nOS_Queue *queue, void *block, nOS_TickCounter timeout) { nOS_Error err; nOS_StatusReg sr; nOS_Thread *thread; #if (NOS_CONFIG_SAFE > 0) if (queue == NULL) { err = NOS_E_INV_OBJ; } else if (block == NULL) { err = NOS_E_NULL; } else #endif { nOS_EnterCritical(sr); #if (NOS_CONFIG_SAFE > 0) if (queue->e.type != NOS_EVENT_QUEUE) { err = NOS_E_INV_OBJ; } else #endif { /* No chance a thread waiting to read from queue if count is higher than 0 */ if (queue->bcount > 0) { _Read(queue, block); /* Check if thread waiting to write in queue */ thread = nOS_SendEvent((nOS_Event*)queue, NOS_OK); if (thread != NULL) { /* Write thread's block in queue */ _Write(queue, thread->ext); #if (NOS_CONFIG_HIGHEST_THREAD_PRIO > 0) && (NOS_CONFIG_SCHED_PREEMPTIVE_ENABLE > 0) if ((thread->state == NOS_THREAD_READY) && (thread->prio > nOS_runningThread->prio)) { nOS_Schedule(); } #endif } err = NOS_OK; } else if (timeout == NOS_NO_WAIT) { err = NOS_E_EMPTY; } else if (nOS_isrNestingCounter > 0) { err = NOS_E_ISR; } #if (NOS_CONFIG_SCHED_LOCK_ENABLE > 0) else if (nOS_lockNestingCounter > 0) { err = NOS_E_LOCKED; } #endif else if (nOS_runningThread == &nOS_idleHandle) { err = NOS_E_IDLE; } else { nOS_runningThread->ext = block; err = nOS_WaitForEvent((nOS_Event*)queue, NOS_THREAD_READING_QUEUE, timeout); } } nOS_LeaveCritical(sr); } return err; }
INetPacket * INetPacket::ReadPacket(INetPacket* r) { NetPacketHeader Header; _Read( (uint8*)&Header,PACKET_HEADER_SIZE); Header.size = _BITSWAP32(Header.size ); Header.cmd = _BITSWAP32(Header.cmd); uint32 size = Header.size - PACKET_HEADER_SIZE; if (!r) { r = NEW_NETPACKET(size, Header.cmd); } else { r->SetOpcode(Header.cmd); } _Read(r->GetWriteBuffer(size), size); return r; };
SInt64 SFB::InputSource::Read(void *buffer, SInt64 byteCount) { if(!IsOpen() || nullptr == buffer || 0 > byteCount) { LOGGER_WARNING("org.sbooth.AudioEngine.InputSource", "Read() called on an InputSource that hasn't been opened"); return -1; } return _Read(buffer, byteCount); }
int DBObjData::Read(FILE *file) { int swap; DocsPTR->DeleteAll(); ArraysPTR->DeleteAll(); TablesPTR->DeleteAll(); if ((swap = DBDataHeader::Read(file)) == DBFault) return (DBFault); return (_Read(file, swap)); }
/********************************************************************* * * I2C_WriteRead * * Function description: * Writes and reads from a device on I2C. */ U8 I2C_WriteRead(U32 I2CBaseAddr, U8 Addr, U8 * pData, U16 NumBytesToWrite, U8 * pBuf, U16 NumBytesToRead) { U8 r; SET_BASE_ADDR(I2CBaseAddr); r = _Write(Addr << 1, pData, NumBytesToWrite, 1); if (r == I2C_CODE_OK) { r = _Read(Addr << 1, pBuf, NumBytesToRead, 1); } return r; }
nOS_Error nOS_QueueRead (nOS_Queue *queue, void *block, nOS_TickCounter timeout) { nOS_Error err; nOS_StatusReg sr; nOS_Thread *thread; #if (NOS_CONFIG_SAFE > 0) if (queue == NULL) { err = NOS_E_INV_OBJ; } else if (block == NULL) { err = NOS_E_NULL; } else #endif { nOS_EnterCritical(sr); #if (NOS_CONFIG_SAFE > 0) if (queue->e.type != NOS_EVENT_QUEUE) { err = NOS_E_INV_OBJ; } else #endif /* No chance a thread waiting to read from queue if count is higher than 0 */ if (queue->bcount > 0) { _Read(queue, block); /* Check if thread waiting to write in queue */ thread = nOS_SendEvent((nOS_Event*)queue, NOS_OK); if (thread != NULL) { /* Write thread's block in queue */ _Write(queue, thread->ext); #if (NOS_CONFIG_SCHED_PREEMPTIVE_ENABLE > 0) /* Verify if a highest prio thread is ready to run */ nOS_Schedule(); #endif } err = NOS_OK; } else if (timeout == NOS_NO_WAIT) { err = NOS_E_EMPTY; } else { nOS_runningThread->ext = block; err = nOS_WaitForEvent((nOS_Event*)queue, NOS_THREAD_READING_QUEUE #if (NOS_CONFIG_WAITING_TIMEOUT_ENABLE > 0) ,timeout #elif (NOS_CONFIG_SLEEP_ENABLE > 0) || (NOS_CONFIG_SLEEP_UNTIL_ENABLE > 0) ,NOS_WAIT_INFINITE #endif ); } nOS_LeaveCritical(sr); } return err; }
INetPacket * INetPacket::UnPackPacket() { NetPacketHeader Header; _Read( (uint8*)&Header,PACKET_HEADER_SIZE); //Header.size = BITSWAP16(Header.size ); Header.cmd = _BITSWAP16(Header.cmd ); //uint16 size = Header.size - PACKET_HEADER_SIZE; SetOpcode(Header.cmd); //_Read(r->GetWriteBuffer(size), size); return this; };
/********************************************************************* * * USBHID_Read * * Function description * Reads an input report from device. * * Return value: * On Error: -1, No valid device Id used or the report size does not match with device. * On success: Number of bytes that have be written. * */ int USBHID_Read(unsigned Id, void * pBuffer, unsigned NumBytes) { CONN_INFO * pConnInfo; pConnInfo = _apConnInfo[Id]; if (pConnInfo == NULL) { return -1; // Error device Id does not exist. } if (NumBytes != (pConnInfo->InputReportByteLength - 1)) { return -1; // Error report size does not match } return _Read(pConnInfo, pBuffer, NumBytes); }
void Read(KinBodyPtr& pbody, const std::vector<char>& data,const AttributesList& atts) { _ProcessAtts(atts); if( !pbody ) { pbody = RaveCreateKinBody(_penv,_bodytype); } pbody->SetName(_bodyname); Assimp::XFileParserOpenRAVE parser(data); _Read(pbody,parser.GetImportedData()); if( pbody->GetName().size() == 0 ) { pbody->SetName("body"); } }
void Cluster::Load(string filename) { //open and read file to memory if(_Read(filename) != 0) { cout <<"Error reading file"<<endl; exit; }; //parse term-doc count file _Parse(terms); //Weight by tf*idf, return total number of food items this->N = _Weight(); //normalize indices to unit vector _Norm(); set_lambda(0.5); }
status_t PackageReader::_ReadUnsignedLEB128(uint64& _value) { uint64 result = 0; int shift = 0; while (true) { uint8 byte; status_t error = _Read(byte); if (error != B_OK) return error; result |= uint64(byte & 0x7f) << shift; if ((byte & 0x80) == 0) break; shift += 7; } _value = result; return B_OK; }
void homepage(const char *host, const char *f_name){ myLog("Entered homepage func"); printf("host = %s\n", host); printf("f_name = %s\n", f_name); int fd, n; char line[MAXLINE]; fd = tcp_connect(host, SERV); n = snprintf(line, sizeof(line), GET_CMD, f_name); _Write_n(fd, line, n); for( ; ;){ n = _Read(fd, line, MAXLINE); if(n == 0) break; printf("read %d bytes of homepage\n", n); } printf("end-of-file on homepage\n"); close(fd); }
void Read(RobotBasePtr& probot, const std::vector<char>& data,const AttributesList& atts) { _ProcessAtts(atts); if( !probot ) { probot = RaveCreateRobot(_penv,_bodytype); } probot->SetName(_bodyname); Assimp::XFileParserOpenRAVE parser(data); _Read(probot,parser.GetImportedData()); if( probot->GetName().size() == 0 ) { probot->SetName("robot"); } // add manipulators FOREACH(itmanip,_listendeffectors) { RobotBase::ManipulatorInfo manipinfo; manipinfo._name = itmanip->first->_info._name; manipinfo._sEffectorLinkName = itmanip->first->GetName(); manipinfo._sBaseLinkName = probot->GetLinks().at(0)->GetName(); manipinfo._tLocalTool = itmanip->second; manipinfo._vdirection=Vector(1,0,0); probot->_vecManipulators.push_back(RobotBase::ManipulatorPtr(new RobotBase::Manipulator(probot,manipinfo))); }
bool UsdMtlxFileFormat::ReadFromString( const SdfLayerBasePtr& layerBase, const std::string& str) const { TRACE_FUNCTION(); SdfLayerHandle layer = TfDynamic_cast<SdfLayerHandle>(layerBase); if (!TF_VERIFY(layer)) { return false; } auto stage = UsdStage::CreateInMemory(); if (!_Read(stage, [&str](mx::DocumentPtr d) { mx::readFromXmlString(d, str); })) { return false; } layer->TransferContent(stage->GetRootLayer()); return true; }
Header::Header(int fd, uint64 lastBlock, uint32 blockSize) : fBlockSize(blockSize), fStatus(B_NO_INIT), fEntries(NULL) { // TODO: check the correctness of the protective MBR and warn if invalid // Read and check the partition table header fStatus = _Read(fd, (uint64)EFI_HEADER_LOCATION * blockSize, &fHeader, sizeof(efi_table_header)); if (fStatus == B_OK) { if (!_IsHeaderValid(fHeader, EFI_HEADER_LOCATION)) fStatus = B_BAD_DATA; } if (fStatus == B_OK && lastBlock != fHeader.AlternateBlock()) { dprintf("gpt: alternate header not in last block (%" B_PRIu64 " vs. %" B_PRIu64 ")\n", fHeader.AlternateBlock(), lastBlock); lastBlock = fHeader.AlternateBlock(); } // Read backup header, too status_t status = _Read(fd, lastBlock * blockSize, &fBackupHeader, sizeof(efi_table_header)); if (status == B_OK) { if (!_IsHeaderValid(fBackupHeader, lastBlock)) status = B_BAD_DATA; } // If both headers are invalid, bail out -- this is probably not a GPT disk if (status != B_OK && fStatus != B_OK) return; if (fStatus != B_OK) { // Recreate primary header from the backup fHeader = fBackupHeader; fHeader.SetAbsoluteBlock(EFI_HEADER_LOCATION); fHeader.SetEntriesBlock(EFI_PARTITION_ENTRIES_BLOCK); fHeader.SetAlternateBlock(lastBlock); } else if (status != B_OK) { // Recreate backup header from primary _SetBackupHeaderFromPrimary(lastBlock); } // allocate, read, and check partition entry array fEntries = new (std::nothrow) uint8[_EntryArraySize()]; if (fEntries == NULL) { // TODO: if there cannot be allocated enough (ie. the boot loader's // heap is limited), try a smaller size before failing fStatus = B_NO_MEMORY; return; } fStatus = _Read(fd, fHeader.EntriesBlock() * blockSize, fEntries, _EntryArraySize()); if (fStatus != B_OK || !_ValidateEntriesCRC()) { // Read backup entries instead fStatus = _Read(fd, fBackupHeader.EntriesBlock() * blockSize, fEntries, _EntryArraySize()); if (fStatus != B_OK) return; if (!_ValidateEntriesCRC()) { fStatus = B_BAD_DATA; return; } } // TODO: check overlapping or out of range partitions #ifdef TRACE_EFI_GPT _Dump(fHeader); _Dump(fBackupHeader); _DumpPartitions(); #endif fStatus = B_OK; }
status_t PackageReader::_ReadAttributeValue(uint8 type, uint8 encoding, AttributeValue& _value) { switch (type) { case B_HPKG_ATTRIBUTE_TYPE_INT: case B_HPKG_ATTRIBUTE_TYPE_UINT: { uint64 intValue; status_t error; switch (encoding) { case B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT: { uint8 value; error = _Read(value); intValue = value; break; } case B_HPKG_ATTRIBUTE_ENCODING_INT_16_BIT: { uint16 value; error = _Read(value); intValue = B_BENDIAN_TO_HOST_INT16(value); break; } case B_HPKG_ATTRIBUTE_ENCODING_INT_32_BIT: { uint32 value; error = _Read(value); intValue = B_BENDIAN_TO_HOST_INT32(value); break; } case B_HPKG_ATTRIBUTE_ENCODING_INT_64_BIT: { uint64 value; error = _Read(value); intValue = B_BENDIAN_TO_HOST_INT64(value); break; } default: { fErrorOutput->PrintError("Error: Invalid TOC section: " "invalid encoding %d for int value type %d\n", encoding, type); return B_BAD_VALUE; } } if (error != B_OK) return error; if (type == B_HPKG_ATTRIBUTE_TYPE_INT) _value.SetTo((int64)intValue); else _value.SetTo(intValue); return B_OK; } case B_HPKG_ATTRIBUTE_TYPE_STRING: { if (encoding == B_HPKG_ATTRIBUTE_ENCODING_STRING_TABLE) { uint64 index; status_t error = _ReadUnsignedLEB128(index); if (error != B_OK) return error; if (index > fTOCStringsCount) { fErrorOutput->PrintError("Error: Invalid TOC section: " "string reference out of bounds\n"); return B_BAD_DATA; } _value.SetTo(fStrings[index]); } else if (encoding == B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE) { const char* string; status_t error = _ReadString(string); if (error != B_OK) return error; _value.SetTo(string); } else { fErrorOutput->PrintError("Error: Invalid TOC section: invalid " "string encoding (%u)\n", encoding); return B_BAD_DATA; } return B_OK; } case B_HPKG_ATTRIBUTE_TYPE_RAW: { uint64 size; status_t error = _ReadUnsignedLEB128(size); if (error != B_OK) return error; if (encoding == B_HPKG_ATTRIBUTE_ENCODING_RAW_HEAP) { uint64 offset; error = _ReadUnsignedLEB128(offset); if (error != B_OK) return error; if (offset > fHeapSize || size > fHeapSize - offset) { fErrorOutput->PrintError("Error: Invalid TOC section: " "invalid data reference\n"); return B_BAD_DATA; } _value.SetToData(size, fHeapOffset + offset); } else if (encoding == B_HPKG_ATTRIBUTE_ENCODING_RAW_INLINE) { if (size > B_HPKG_MAX_INLINE_DATA_SIZE) { fErrorOutput->PrintError("Error: Invalid TOC section: " "inline data too long\n"); return B_BAD_DATA; } const void* buffer; error = _GetTOCBuffer(size, buffer); if (error != B_OK) return error; _value.SetToData(size, buffer); } else { fErrorOutput->PrintError("Error: Invalid TOC section: invalid " "raw encoding (%u)\n", encoding); return B_BAD_DATA; } return B_OK; } default: fErrorOutput->PrintError("Error: Invalid TOC section: invalid " "value type: %d\n", type); return B_BAD_DATA; } }
size_t GPFileStream::vRead(void* buffer, size_t size) { return _Read(mF, buffer, size); }
int read (int fd, void *buffer, long nbytes) { return _Read(fd, buffer, nbytes); }
int I2C::Read( uint8_t reg, void* buf, uint32_t len ) { return _Read( mAddr, reg, buf, len ); }