int write (const char* sourceBuffer, int numBytesToWrite, int timeOutMilliseconds) { int bytesWritten = -1; const uint32 timeoutEnd = getTimeoutEnd (timeOutMilliseconds); if (pipeOut == -1) { pipeOut = openPipe (createdPipe ? pipeOutName : pipeInName, O_WRONLY, timeoutEnd); if (pipeOut == -1) return -1; } bytesWritten = 0; while (bytesWritten < numBytesToWrite && ! hasExpired (timeoutEnd)) { const int bytesThisTime = numBytesToWrite - bytesWritten; const int numWritten = (int) ::write (pipeOut, sourceBuffer, bytesThisTime); if (numWritten <= 0) { bytesWritten = -1; break; } bytesWritten += numWritten; sourceBuffer += numWritten; } return bytesWritten; }
int write (const char* sourceBuffer, int numBytesToWrite, int timeOutMilliseconds) { const uint32 timeoutEnd = getTimeoutEnd (timeOutMilliseconds); if (pipeOut == -1) { //bob: added O_NONBLOCK to prevent deadlocks when no client is connected for reading before we kill the PIPE pipeOut = openPipe (createdPipe ? pipeOutName : pipeInName, O_WRONLY|O_NONBLOCK, timeoutEnd); if (pipeOut == -1) return -1; } int bytesWritten = 0; while (bytesWritten < numBytesToWrite && ! hasExpired (timeoutEnd)) { const int bytesThisTime = numBytesToWrite - bytesWritten; const int numWritten = (int) ::write (pipeOut, sourceBuffer, (size_t) bytesThisTime); if (numWritten <= 0) return -1; bytesWritten += numWritten; sourceBuffer += numWritten; } return bytesWritten; }
// MANIPULATORS bsl::shared_ptr<const Calendar> CalendarCache::getCalendar(const char *calendarName) { BSLS_ASSERT(calendarName); { bsls::BslLockGuard lockGuard(&d_lock); CacheIterator iter = d_cache.find(calendarName); if (iter != d_cache.end()) { if (!d_hasTimeOutFlag || !hasExpired(d_timeOut, iter->second.loadTime())) { return iter->second.get(); // RETURN } else { d_cache.erase(iter); } } } // Load calendar identified by 'calendarName'. PackedCalendar packedCalendar; // temporary, so use default allocator if (d_loader_p->load(&packedCalendar, calendarName)) { return bsl::shared_ptr<const Calendar>(); // RETURN } // Create out-of-place calendar that will be managed by 'bsl::shared_ptr'. Calendar *calendarPtr = new (*d_allocator_p) Calendar(packedCalendar, d_allocator_p); CalendarCache_Entry entry(calendarPtr, bsl::time(0), d_allocator_p); BSLS_ASSERT(static_cast<bsl::time_t>(-1) != entry.loadTime()); // Insert newly-loaded calendar into cache if another thread hasn't done so // already. bsls::BslLockGuard lockGuard(&d_lock); ConstCacheIterator iter = d_cache.find(calendarName); // Here, we assume that the time elapsed between the last check and the // loading of the calendar is insignificant compared to the timeout, so we // will simply return the entry in the cache if it has been inserted by // another thread. if (iter != d_cache.end()) { return iter->second.get(); // RETURN } d_cache[calendarName] = entry; return entry.get(); }
bool LLFrameTimer::checkExpirationAndReset(F32 expiration) { if (hasExpired()) { reset(expiration); return true; } return false; }
void Cooldown::wrap() { if (hasExpired()) { passed -= duration; } else { Log::err("Cooldown", "wrapping when not expired"); } }
static int openPipe (const String& name, int flags, const uint32 timeoutEnd) { for (;;) { const int p = ::open (name.toUTF8(), flags); if (p != -1 || hasExpired (timeoutEnd)) return p; Thread::sleep (2); } }
BOOL LLFrameTimer::checkExpirationAndReset(F32 expiration) { //llinfos << "LLFrameTimer::checkExpirationAndReset()" << llendl; //llinfos << " mStartTime:" << mStartTime << llendl; //llinfos << " sFrameTime:" << sFrameTime << llendl; //llinfos << " mExpiry: " << mExpiry << llendl; if(hasExpired()) { reset(); setTimerExpirySec(expiration); return TRUE; } return FALSE; }
void RenderObjectManager::renderObjectExpired( const Core::Index& idx ) { std::lock_guard<std::mutex> lock( m_doubleBufferMutex ); auto ro = m_renderObjects.at( idx ); m_renderObjects.remove( idx ); auto type = ro->getType(); m_renderObjectByType[(int)type].erase( idx ); ro->hasExpired(); ro.reset(); }
int read (char* destBuffer, int maxBytesToRead, int timeOutMilliseconds) { int bytesRead = -1; blocked = true; const uint32 timeoutEnd = getTimeoutEnd (timeOutMilliseconds); if (pipeIn == -1) { pipeIn = openPipe (createdPipe ? pipeInName : pipeOutName, O_RDWR | O_NONBLOCK, timeoutEnd); if (pipeIn == -1) { blocked = false; return -1; } } bytesRead = 0; while (bytesRead < maxBytesToRead) { const int bytesThisTime = maxBytesToRead - bytesRead; const int numRead = (int) ::read (pipeIn, destBuffer, bytesThisTime); if (numRead <= 0) { if (errno != EWOULDBLOCK || stopReadOperation || hasExpired (timeoutEnd)) { bytesRead = -1; break; } const int maxWaitingTime = 30; waitForInput (pipeIn, timeoutEnd == 0 ? maxWaitingTime : jmin (maxWaitingTime, (int) (timeoutEnd - Time::getMillisecondCounter()))); continue; } bytesRead += numRead; destBuffer += numRead; } blocked = false; return bytesRead; }
// ACCESSORS bsl::shared_ptr<const Calendar> CalendarCache::lookupCalendar(const char *calendarName) const { BSLS_ASSERT(calendarName); bsls::BslLockGuard lockGuard(&d_lock); CacheIterator iter = d_cache.find(calendarName); if (iter != d_cache.end()) { if (!d_hasTimeOutFlag || !hasExpired(d_timeOut, iter->second.loadTime())) { return iter->second.get(); // RETURN } else { d_cache.erase(iter); } } return bsl::shared_ptr<const Calendar>(); }
int BookInfo::update(const BookInfo *other) { qDebug() << Q_FUNC_INFO << "isbn" << other->isbn; int updateType = UPDATE_NONE; if(this == other) return updateType; dirty = true; if (title != other->title) { title = other->title; updateType |= UPDATE_METADATA; } if (isbn != other->isbn) { isbn = other->isbn; updateType |= UPDATE_METADATA; } qDebug() << Q_FUNC_INFO << "lastTimeRead1" << lastTimeRead; qDebug() << Q_FUNC_INFO << "other->lastTimeRead" << other->lastTimeRead; if (lastTimeRead != other->lastTimeRead) { lastTimeRead = other->lastTimeRead; updateType |= UPDATE_METADATA; } qDebug() << Q_FUNC_INFO << "readingStatus" << readingStatus; qDebug() << Q_FUNC_INFO << "other->readingStatus: " << other->readingStatus; if(readingStatus != other->readingStatus) { readingStatus = other->readingStatus; if(other->readingStatus == BookInfo::READ_BOOK || other->readingStatus == BookInfo::NO_READ_BOOK) updateType |= UPDATE_CLOSED; } if (path != other->path) { path = other->path; updateType |= UPDATE_METADATA; } if (author != other->author) { author = other->author; updateType |= UPDATE_METADATA; } if (thumbnail != other->thumbnail) { thumbnail = other->thumbnail; updateType |= UPDATE_METADATA; } if (coverUrl != other->coverUrl) { coverUrl = other->coverUrl; updateType |= UPDATE_METADATA; } if (publishTime != other->publishTime) { publishTime = other->publishTime; updateType |= UPDATE_METADATA; } if (size != other->size) { size = other->size; updateType |= UPDATE_METADATA; } downloadTime = other->downloadTime; if (markCount != other->markCount) { markCount = other->markCount; updateType |= UPDATE_READING_METADATA; } if (noteCount != other->noteCount) { noteCount = other->noteCount; updateType |= UPDATE_READING_METADATA; } if (hiliCount != other->hiliCount) { hiliCount = other->hiliCount; updateType |= UPDATE_READING_METADATA; } if (pageCount != other->pageCount) { pageCount = other->pageCount; updateType |= UPDATE_READING_METADATA; } if (lastReadLink != other->lastReadLink) { lastReadLink = other->lastReadLink; updateType |= UPDATE_READING_POSITION; } if (lastReadPage != other->lastReadPage) { lastReadPage = other->lastReadPage; updateType |= UPDATE_READING_POSITION; } if (fabs(readingProgress - other->readingProgress) > EPS) { readingProgress = other->readingProgress; updateType |= UPDATE_READING_POSITION; } if (fabs(readingPercentage != other->readingPercentage) > EPS) { readingPercentage = other->readingPercentage; updateType |= UPDATE_READING_POSITION; } if (readingPeriod != other->readingPeriod) readingPeriod = other->readingPeriod; if (percentageList != other->percentageList) percentageList = other->percentageList; if (fontSize != other->fontSize) { fontSize = other->fontSize; updateType |= UPDATE_READING_METADATA; } if (pageMode != other->pageMode) { pageMode = other->pageMode; updateType |= UPDATE_READING_METADATA; } if (orientation != other->orientation) { orientation = other->orientation; updateType |= UPDATE_READING_METADATA; } if (timestamp != other->timestamp) { timestamp = other->timestamp; updateType |= UPDATE_METADATA; } publisher = other->publisher; synopsis = other->synopsis; fileSize = other->fileSize; syncDate = other->syncDate; storePrice = other->storePrice; format = other->format; language = other->language; if (m_type != other->m_type) { m_type = other->m_type; updateType |= UPDATE_TYPE; } if (m_expirationDate != other->m_expirationDate) m_expirationDate = other->m_expirationDate; if(hasExpired()) updateType |= UPDATE_EXPIRATION; if(m_type == BOOKINFO_TYPE_SUBSCRIPTION) corrupted = true; else corrupted = other->corrupted; if (m_archived != other->m_archived) { m_archived = other->m_archived; updateType |= UPDATE_ARCHIVED; } if(isDRMFile != other->isDRMFile) isDRMFile = other->isDRMFile; m_collections = other->m_collections; m_cssFileList = other->m_cssFileList; totalReadingTime = other->totalReadingTime; if(locationsHasChanged(other->m_locations)) { qDebug() << Q_FUNC_INFO << "locations has changed"; updateType |= UPDATE_READING_METADATA; setLocations(other->m_locations); } return updateType; }
Datum Timer::getValue() { return Datum(hasExpired()); }