bvres_t update() override { if(!m_done_res.has_value()){ m_timer.reset(); } if(!m_done_res.has_value() || m_done_res.value() == BV_PENDING){ m_done_res.emplace(m_operation->update()); switch(auto op_status = m_done_res.value()){ case BV_ABORT: case BV_PENDING: { return op_status; } case BV_FAILURE: case BV_SUCCESS: { break; } default: { throw std::runtime_error(str_fflprintf(": Invalid node status: %d", op_status)); } } } if(m_timer.diff_msec() > m_slowdown){ return m_done_res.value(); }else{ return BV_PENDING; } }
void MemoryObjectStore::getAllRecords(const IDBKeyRangeData& keyRangeData, std::optional<uint32_t> count, IndexedDB::GetAllType type, IDBGetAllResult& result) const { result = { type }; uint32_t targetCount; if (count && count.value()) targetCount = count.value(); else targetCount = std::numeric_limits<uint32_t>::max(); IDBKeyRangeData range = keyRangeData; uint32_t currentCount = 0; while (currentCount < targetCount) { IDBKeyData key = lowestKeyWithRecordInRange(range); if (key.isNull()) return; range.lowerKey = key; range.lowerOpen = true; if (type == IndexedDB::GetAllType::Keys) result.addKey(WTFMove(key)); else result.addValue(valueForKey(key)); ++currentCount; } }
void WebSocketChannel::didReceiveSocketStreamData(SocketStreamHandle& handle, const char* data, std::optional<size_t> len) { if (len) LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received %zu bytes", this, len.value()); else LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received no bytes", this); Ref<WebSocketChannel> protectedThis(*this); // The client can close the channel, potentially removing the last reference. ASSERT(&handle == m_handle); if (!m_document) { return; } if (!len || !len.value()) { handle.disconnect(); return; } if (!m_client) { m_shouldDiscardReceivedData = true; handle.disconnect(); return; } if (m_shouldDiscardReceivedData) return; if (!appendToBuffer(data, len.value())) { m_shouldDiscardReceivedData = true; fail("Ran out of memory while receiving WebSocket data."); return; } while (!m_suspended && m_client && !m_buffer.isEmpty()) { if (!processBuffer()) break; } }
std::optional<NodeIndex_t> Model::FindFirstNode(char const* name, std::optional<NodeIndex_t> const& parentNodeIndex) const { // Children are guaranteed to come after their parents, so start looking after the parent index if one is provided. const NodeIndex_t startIndex = parentNodeIndex ? parentNodeIndex.value() + 1 : Pbr::RootNodeIndex; for (const Pbr::Node& node : m_nodes) { if ((!parentNodeIndex || node.ParentNodeIndex == parentNodeIndex.value()) && node.Name == name) { return node.Index; } } return {}; }
void CachedResource::setLoadPriority(const std::optional<ResourceLoadPriority>& loadPriority) { if (loadPriority) m_loadPriority = loadPriority.value(); else m_loadPriority = defaultPriorityForResourceType(type()); }
// Routine Description: // - Remaps all of the stored items to new coordinate positions // based on a bulk rearrangement of row IDs and potential row width resize. // Arguments: // - rowMap - A map of the old row IDs to the new row IDs. // - width - The width of the new row. Remove any items that are beyond the row width. // - Use nullopt if we're not resizing the width of the row, just renumbering the rows. void UnicodeStorage::Remap(const std::map<SHORT, SHORT>& rowMap, const std::optional<SHORT> width) { // Make a temporary map to hold all the new row positioning std::unordered_map<key_type, mapped_type> newMap; // Walk through every stored item. for (const auto& pair : _map) { // Extract the old coordinate position const auto oldCoord = pair.first; // Only try to short-circuit based on width if we were told it changed // by being given a new width value. if (width.has_value()) { // Get the column ID const auto oldColId = oldCoord.X; // If the column index is at/beyond the row width, don't bother copying it to the new map. if (oldColId >= width.value()) { continue; } } // Get the row ID from the position as that's what we need to remap const auto oldRowId = oldCoord.Y; // Use the mapping given to convert the old row ID to the new row ID const auto mapIter = rowMap.find(oldRowId); // If there's no mapping to a new row, don't bother copying it to the new map. The row is gone. if (mapIter == rowMap.end()) { continue; } const auto newRowId = mapIter->second; // Generate a new coordinate with the same X as the old one, but a new Y value. const auto newCoord = COORD{ oldCoord.X, newRowId }; // Put the adjusted coordinate into the map with the original value. newMap.emplace(newCoord, pair.second); } // Swap into the stored map, free the temporary when we exit. _map.swap(newMap); }
// Method Description: // - Open a new tab. This will create the TerminalControl hosting the // terminal, and add a new Tab to our list of tabs. The method can // optionally be provided a profile index, which will be used to create // a tab using the profile in that index. // If no index is provided, the default profile will be used. // Arguments: // - profileIndex: an optional index into the list of profiles to use to // initialize this tab up with. void App::_OpenNewTab(std::optional<int> profileIndex) { GUID profileGuid; if (profileIndex) { const auto realIndex = profileIndex.value(); const auto profiles = _settings->GetProfiles(); // If we don't have that many profiles, then do nothing. if (realIndex >= profiles.size()) { return; } const auto& selectedProfile = profiles[realIndex]; profileGuid = selectedProfile.GetGuid(); } else { // Getting Guid for default profile const auto globalSettings = _settings->GlobalSettings(); profileGuid = globalSettings.GetDefaultProfile(); } TerminalSettings settings = _settings->MakeSettings(profileGuid); _CreateNewTabFromSettings(profileGuid, settings); const int tabCount = static_cast<int>(_tabs.size()); TraceLoggingWrite( g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider "TabInformation", TraceLoggingDescription("Event emitted upon new tab creation in TerminalApp"), TraceLoggingInt32(tabCount, "TabCount", "Count of tabs curently opened in TerminalApp"), TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES), TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance)); }
bool Element::cursorIsOver(std::optional<Vector2i> cursorPosition) const { return cursorPosition && bounds.contains(cursorPosition.value()); }