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());
}