RWConfig GameBase::buildConfig(const std::optional<RWArgConfigLayer> &args) { RWConfig config; if (args.has_value()) { config.setLayer(RWConfig::LAYER_ARGUMENT, *args); } auto defaultLayer = buildDefaultConfigLayer(); config.setLayer(RWConfig::LAYER_DEFAULT, defaultLayer); rwfs::path configPath; if (args.has_value() && args->configPath.has_value()) { configPath = *args->configPath; } else { configPath = RWConfigParser::getDefaultConfigPath() / "openrw.ini"; } if ((!args) || (args && !args->noconfig)) { RWConfigParser configParser{}; auto [configLayer, parseResult] = configParser.loadFile(configPath); if (!parseResult.isValid()) { log.error("Config", "Could not read configuation file at " + configPath.string()); throw std::runtime_error(parseResult.what()); } config.unknown = parseResult.getUnknownData(); config.setLayer(RWConfig::LAYER_CONFIGFILE, configLayer); }
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; } }
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; } }
// 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); }
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()); }
game_value remote_exec(const game_value ¶ms_, sqf_string_const_ref function_, std::variant<int, object, sqf_string_const_ref_wrapper, side, group, std::reference_wrapper<const std::vector<game_value>>> targets_, std::optional<std::variant<sqf_string_const_ref_wrapper, bool, object, group>> jip_) { game_value targets; game_value jip; switch (targets_.index()) { case 0: targets = static_cast<float>(std::get<int>(targets_)); break; case 1: targets = std::get<object>(targets_); break; case 2: targets = std::get<2>(targets_).get(); break; case 3: targets = std::get<side>(targets_); break; case 4: targets = std::get<group>(targets_); break; case 5: targets = std::move(auto_array<game_value>({ std::get<5>(targets_).get().begin(), std::get<5>(targets_).get().end() })); break; } if (jip_.has_value()) { switch ((*jip_).index()) { case 0: jip = std::get<0>(*jip_).get(); break; case 1: jip = std::get<bool>(*jip_); break; case 2: jip = std::get<object>(*jip_); break; case 3: jip = std::get<group>(*jip_); break; } } game_value params_right = game_value({ function_, targets, jip }); return host::functions.invoke_raw_binary(__sqf::binary__remoteexec__any__array__ret__any, params_, params_right); }
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; } }
static void make_vt_attributes(const FarColor& Attributes, string& Str, std::optional<FarColor> const& LastColor) { append(Str, L"\033["sv); if (Attributes.IsFg4Bit()) { append(Str, Attributes.ForegroundColor & FOREGROUND_INTENSITY? L'9' : L'3', vt_color_index(Attributes.ForegroundColor)); } else { const auto& c = Attributes.ForegroundRGBA; Str += format(L"38;2;{0};{1};{2}"sv, c.r, c.g, c.b); } Str += L';'; if (Attributes.IsBg4Bit()) { append(Str, Attributes.BackgroundColor & FOREGROUND_INTENSITY? L"10"sv : L"4"sv, vt_color_index(Attributes.BackgroundColor)); } else { const auto& c = Attributes.BackgroundRGBA; Str += format(L"48;2;{0};{1};{2}"sv, c.r, c.g, c.b); } if (Attributes.Flags & FCF_FG_UNDERLINE) { if (!LastColor.has_value() || !(LastColor->Flags & FCF_FG_UNDERLINE)) Str += L";4"sv; } else { if (LastColor.has_value() && LastColor->Flags & FCF_FG_UNDERLINE) Str += L";24"sv; } Str += L'm'; }
static void make_vt_sequence(span<const FAR_CHAR_INFO> Input, string& Str, std::optional<FarColor>& LastColor) { for (const auto& i: Input) { if (!LastColor.has_value() || i.Attributes != *LastColor) { make_vt_attributes(i.Attributes, Str, LastColor); LastColor = i.Attributes; } Str += ReplaceControlCharacter(i.Char); } }
SchedulerCPU::ProducedCommands SchedulerCPU::ExecuteNode(GraphicsTask& task, std::optional<ProducedCommands>& inherited, const FrameContextEx& context) { // Inherit command list, if available. std::unique_ptr<BasicCommandList> inheritedCommandList; std::unique_ptr<VolatileViewHeap> inheritedVheap; if (inherited) { inheritedCommandList = std::move(inherited->list); inheritedVheap = std::move(inherited->vheap); inherited.reset(); } // Execute given node. auto vheap = std::make_unique<VolatileViewHeap>(context.gxApi); RenderContext renderContext(context.memoryManager, context.textureSpace, context.shaderManager, context.gxApi, context.commandListPool, context.commandAllocatorPool, context.scratchSpacePool, std::move(inheritedCommandList), std::move(inheritedVheap)); renderContext.SetCommandListName(typeid(task).name()); task.Execute(renderContext); // Get inherited and current list, if any. std::unique_ptr<BasicCommandList> currentCommandList; std::unique_ptr<VolatileViewHeap> currentVheap; renderContext.Decompose(inheritedCommandList, currentCommandList, currentVheap); if (inheritedCommandList) { inherited = ProducedCommands{ std::move(inheritedCommandList), nullptr }; } else { inherited.reset(); } return { std::move(currentCommandList), std::move(currentVheap) }; }
ExceptionOr<int> CSSStyleSheet::addRule(const String& selector, const String& style, std::optional<unsigned> index) { StringBuilder text; text.append(selector); text.appendLiteral(" { "); text.append(style); if (!style.isEmpty()) text.append(' '); text.append('}'); auto insertRuleResult = insertRule(text.toString(), index.value_or(length())); if (insertRuleResult.hasException()) return insertRuleResult.releaseException(); // As per Microsoft documentation, always return -1. return -1; }
void FileBasedBenchmarkItemRunner::_parse_query_file( const std::filesystem::path& query_file_path, const std::optional<std::unordered_set<std::string>>& query_subset) { std::ifstream file(query_file_path); // The names of queries from, e.g., "queries/TPCH-7.sql" will be prefixed with "TPCH-7." const auto item_name_prefix = query_file_path.stem().string(); std::string content{std::istreambuf_iterator<char>(file), {}}; /** * A file can contain multiple SQL statements, and each statement may cover one or more lines. * We use the SQLParser to split up the content of the file into the individual SQL statements. */ hsql::SQLParserResult parse_result; hsql::SQLParser::parse(content, &parse_result); Assert(parse_result.isValid(), create_sql_parser_error_message(content, parse_result)); std::vector<Query> queries_in_file{parse_result.size()}; size_t sql_string_offset{0u}; for (auto statement_idx = size_t{0}; statement_idx < parse_result.size(); ++statement_idx) { const auto item_name = item_name_prefix + '.' + std::to_string(statement_idx); const auto statement_string_length = parse_result.getStatement(statement_idx)->stringLength; const auto statement_string = boost::trim_copy(content.substr(sql_string_offset, statement_string_length)); sql_string_offset += statement_string_length; queries_in_file[statement_idx] = {item_name, statement_string}; } // Remove ".0" from the end of the query name if there is only one file if (queries_in_file.size() == 1) { queries_in_file.front().name.erase(queries_in_file.front().name.end() - 2, queries_in_file.front().name.end()); } /** * Add queries to _queries and _item_names, if query_subset allows it */ for (const auto& query : queries_in_file) { if (!query_subset || query_subset->count(query.name)) { _queries.emplace_back(query); } } }
// 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)); }
RefPtr<CryptoKeyRSA> CryptoKeyRSA::importJwk(CryptoAlgorithmIdentifier algorithm, std::optional<CryptoAlgorithmIdentifier> hash, JsonWebKey&& keyData, bool extractable, CryptoKeyUsageBitmap usages) { if (keyData.kty != "RSA") return nullptr; if (keyData.usages && ((keyData.usages & usages) != usages)) return nullptr; if (keyData.ext && !keyData.ext.value() && extractable) return nullptr; if (!keyData.n || !keyData.e) return nullptr; Vector<uint8_t> modulus; if (!WTF::base64URLDecode(keyData.n.value(), modulus)) return nullptr; // Per RFC 7518 Section 6.3.1.1: https://tools.ietf.org/html/rfc7518#section-6.3.1.1 if (!modulus[0]) modulus.remove(0); Vector<uint8_t> exponent; if (!WTF::base64URLDecode(keyData.e.value(), exponent)) return nullptr; if (!keyData.d) { // import public key auto publicKeyComponents = CryptoKeyDataRSAComponents::createPublic(WTFMove(modulus), WTFMove(exponent)); // Notice: CryptoAlgorithmIdentifier::SHA_1 is just a placeholder. It should not have any effect if hash is std::nullopt. return CryptoKeyRSA::create(algorithm, hash.value_or(CryptoAlgorithmIdentifier::SHA_1), !!hash, *publicKeyComponents, extractable, usages); } // import private key Vector<uint8_t> privateExponent; if (!WTF::base64URLDecode(keyData.d.value(), privateExponent)) return nullptr; if (!keyData.p && !keyData.q && !keyData.dp && !keyData.dp && !keyData.qi) { auto privateKeyComponents = CryptoKeyDataRSAComponents::createPrivate(WTFMove(modulus), WTFMove(exponent), WTFMove(privateExponent)); // Notice: CryptoAlgorithmIdentifier::SHA_1 is just a placeholder. It should not have any effect if hash is std::nullopt. return CryptoKeyRSA::create(algorithm, hash.value_or(CryptoAlgorithmIdentifier::SHA_1), !!hash, *privateKeyComponents, extractable, usages); } if (!keyData.p || !keyData.q || !keyData.dp || !keyData.dq || !keyData.qi) return nullptr; CryptoKeyDataRSAComponents::PrimeInfo firstPrimeInfo; CryptoKeyDataRSAComponents::PrimeInfo secondPrimeInfo; if (!WTF::base64URLDecode(keyData.p.value(), firstPrimeInfo.primeFactor)) return nullptr; if (!WTF::base64URLDecode(keyData.dp.value(), firstPrimeInfo.factorCRTExponent)) return nullptr; if (!WTF::base64URLDecode(keyData.q.value(), secondPrimeInfo.primeFactor)) return nullptr; if (!WTF::base64URLDecode(keyData.dq.value(), secondPrimeInfo.factorCRTExponent)) return nullptr; if (!WTF::base64URLDecode(keyData.qi.value(), secondPrimeInfo.factorCRTCoefficient)) return nullptr; if (!keyData.oth) { auto privateKeyComponents = CryptoKeyDataRSAComponents::createPrivateWithAdditionalData(WTFMove(modulus), WTFMove(exponent), WTFMove(privateExponent), WTFMove(firstPrimeInfo), WTFMove(secondPrimeInfo), { }); // Notice: CryptoAlgorithmIdentifier::SHA_1 is just a placeholder. It should not have any effect if hash is std::nullopt. return CryptoKeyRSA::create(algorithm, hash.value_or(CryptoAlgorithmIdentifier::SHA_1), !!hash, *privateKeyComponents, extractable, usages); } Vector<CryptoKeyDataRSAComponents::PrimeInfo> otherPrimeInfos; for (auto value : keyData.oth.value()) { CryptoKeyDataRSAComponents::PrimeInfo info; if (!WTF::base64URLDecode(value.r, info.primeFactor)) return nullptr; if (!WTF::base64URLDecode(value.d, info.factorCRTExponent)) return nullptr; if (!WTF::base64URLDecode(value.t, info.factorCRTCoefficient)) return nullptr; otherPrimeInfos.append(info); } auto privateKeyComponents = CryptoKeyDataRSAComponents::createPrivateWithAdditionalData(WTFMove(modulus), WTFMove(exponent), WTFMove(privateExponent), WTFMove(firstPrimeInfo), WTFMove(secondPrimeInfo), WTFMove(otherPrimeInfos)); // Notice: CryptoAlgorithmIdentifier::SHA_1 is just a placeholder. It should not have any effect if hash is std::nullopt. return CryptoKeyRSA::create(algorithm, hash.value_or(CryptoAlgorithmIdentifier::SHA_1), !!hash, *privateKeyComponents, extractable, usages); }
task create_simple_task(const object &unit_, sqf_string_const_ref name_, std::optional<task> parent_task_) { game_value params_right(parent_task_.has_value() ? game_value{ name_, *parent_task_ } : game_value{ name_ }); return host::functions.invoke_raw_binary(__sqf::binary__createsimpletask__object__array__ret__task, unit_, params_right); }
void reset() override { m_done_res.reset(); m_operation->reset(); }
bool Element::cursorIsOver(std::optional<Vector2i> cursorPosition) const { return cursorPosition && bounds.contains(cursorPosition.value()); }