void UUpdateManager::HotfixAvailabilityCheckComplete(EHotfixResult Result) { UE_LOG(LogHotfixManager, Display, TEXT("HotfixAvailabilityCheckComplete %d"), (int32)Result); auto CompletionDelegate = [this, Result]() { UE_LOG(LogHotfixManager, Display, TEXT("External HotfixAvailabilityCheckComplete %d"), (int32)Result); switch (Result) { case EHotfixResult::Success: CheckComplete(EUpdateCompletionStatus::UpdateSuccess); break; case EHotfixResult::SuccessNoChange: CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange); break; case EHotfixResult::Failed: CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck); break; default: ensure(0 && "No other result codes should reach here!"); CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck); break; } }; // Debug delay delegate firing DelayResponse(CompletionDelegate, HotfixAvailabilityCheckCompleteDelay); }
void UUpdateManager::PlatformEnvironmentCheck_OnLoginConsoleComplete(int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& Error) { if (bWasSuccessful) { bPlatformEnvironmentDetected = true; StartHotfixCheck(); } else { UE_LOG(LogHotfixManager, Warning, TEXT("Failed to detect online environment for the platform")); CheckComplete(EUpdateCompletionStatus::UpdateFailure_NotLoggedIn); } }
void UUpdateManager::PatchCheckComplete(EPatchCheckResult PatchResult) { LastPatchCheckResult = PatchResult; if (PatchResult == EPatchCheckResult::NoPatchRequired) { StartPlatformEnvironmentCheck(); } else if (PatchResult == EPatchCheckResult::NoLoggedInUser) { CheckComplete(EUpdateCompletionStatus::UpdateFailure_NotLoggedIn); } else { ensure(PatchResult == EPatchCheckResult::PatchCheckFailure || PatchResult == EPatchCheckResult::PatchRequired); // Skip hotfix check in error states, but still preload data as if there was nothing wrong StartInitialPreload(); } }
ssize_t decode(struct tcp_client *client, const char *buf, size_t len) { ssize_t n; size_t decode_size = 0; do { n = CheckComplete(buf + decode_size, len - decode_size); if (n < 0) { assert(0); return n; } if (n == 0) { // printf("len %zd but node complete\n", len - decode_size); return decode_size; } proc(client, buf + decode_size, n); decode_size += n; } while (1); return decode_size; }
bool RdfStorePrivate::Add(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store already contains statement if (Contains(triple)) return true; if (librdf_model_add_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } }
bool RdfStorePrivate::Remove(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store does not contain statement if (!Contains(triple)) return true; if (librdf_model_remove_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } return false; }
void UUpdateManager::InitialPreloadComplete() { SetUpdateState(EUpdateState::InitialLoadComplete); if (LastPatchCheckResult == EPatchCheckResult::PatchCheckFailure) { CheckComplete(EUpdateCompletionStatus::UpdateFailure_PatchCheck); } else if (LastPatchCheckResult == EPatchCheckResult::PatchRequired) { CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsPatch); } else { ensure(LastPatchCheckResult == EPatchCheckResult::NoPatchRequired); // Patch check success, check hotfix status switch (LastHotfixResult) { case EHotfixResult::Success: CheckComplete(EUpdateCompletionStatus::UpdateSuccess); break; case EHotfixResult::SuccessNoChange: CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange); break; case EHotfixResult::Failed: CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck); break; case EHotfixResult::SuccessNeedsRelaunch: CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsRelaunch); break; case EHotfixResult::SuccessNeedsReload: CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsReload); break; } } }
TPicResult TPXPictureValidator::Scan(LPTSTR input, uint termCh, uint& i, uint& j) { tchar ch; TPicResult rslt = prEmpty; uint len = ::_tcslen(input); while (i != termCh && Pic[i] != _T(',')) { if (j >= len) return CheckComplete(termCh, i, rslt); ch = input[j]; switch (Pic[i]) { case _T('#'): if (!_istdigit((tchar)ch)) return prError; else { input[j++] = ch; i++; } break; case _T('?'): if (!_istalpha((tchar)ch)) return prError; else { input[j++] = ch; i++; } break; case _T('&'): if (!_istalpha((tchar)ch)) return prError; else { input[j++] = (tchar)_totupper(ch); i++; } break; case _T('!'): { #if defined(BI_DBCS_SUPPORT) uint n = CharSize(&input[j]) / sizeof(tchar); if (j + n >= len) j = len; else{ if (n == 1) input[j++] = (tchar)_totupper((tchar)ch); else j += n; } #else input[j++] = (tchar)_totupper(ch); #endif i++; break; } case _T('@'): { #if defined(BI_DBCS_SUPPORT) uint n = CharSize(&input[j]) / sizeof(tchar); if (j + n >= len) j = len; else j += n; #else input[j++] = ch; #endif i++; break; } case _T('*'): rslt = Iteration(input, termCh, i, j); if (!IsComplete(rslt)) return rslt; if (rslt == prError) rslt = prAmbiguous; break; case _T('{'): rslt = Group(input, termCh, i, j); if (!IsComplete(rslt)) return rslt; break; case _T('['): rslt = Group(input, termCh, i, j); if (IsIncomplete(rslt)) return rslt; if (rslt == prError) rslt = prAmbiguous; break; default: { #if defined(BI_DBCS_SUPPORT) #if defined(BI_PDOXWINJ_SUPPORT) // Paradox for Windows/J database program has two special picture to // support Japanese characters in CodePage 932 // // '��' 0x81+0x93 - (2 byte '%' symbol) // 1 byte KATAKANA and KATAKANA symbols (0xA1 - 0xDF) // '��' 0x81+0x97 - (2 byte '@' symbol) // any 2 byte characters except 2 byte space (0x81+0x40) // // This is hard coded, because we don't know how to get current // code page in Windows 3.1 // uint n = CharSize(&input[j]) / sizeof(tchar); uint n2 = CharSize(((const char *))Pic.c_str() + i) / sizeof(tchar); if (n2 == 2) { utchar uc1, uc2; uc1 = (utchar)Pic[i]; uc2 = (utchar)Pic[i+1]; if (uc1 == 0x81 && uc2 == 0x93) { if ((utchar)ch >= 0xA1 && (utchar)ch <= 0xDF){ i += n2; j += n; break; } else return prError; } else if (uc1 == 0x81 && uc2 == 0x97){ if (n == 2 && j + n < len && ((utchar)ch != 0x81 || (utchar)input[j+1] != 0x40)) { i += n2; j += n; break; } else return prError; } } if (n2 == 1 && Pic[i] == ';'){ i++; n2 = CharSize((const char *)Pic.c_str() + i) / sizeof(tchar); } #else if (Pic[i] == _T(';')) i++; uint n = CharSize(&input[j]) / sizeof(tchar); uint n2 = CharSize((LPCTSTR)Pic.c_str() + i) / sizeof(tchar); #endif if (j + n >= len) n = len - j; if (n == 1) { if (ch == _T(' ')) { #if defined(BI_AUTO_COMPLETION_DBCS_BY_SPACE) // But, couldn't expand input buffer TValidator classes. // if (n < n2) { memmove(input+n2, input+n, len-n+1); len += n2 - n; n = n2; } while (n-- > 0) input[j++] = Pic[i++]; #else if (n != n2) return prError; input[j++] = Pic[i++]; #endif } else { if (n != n2) return prError; if (_totupper((tchar)Pic[i]) != _totupper((tchar)ch)) return prError; input[j++] = Pic[i++]; } } else { if (n > n2) return prError; for (uint i1 = 0; i1 < n; i1++) if (input[j+i1] != Pic[i+i1]) return prError; while (n-- > 0) input[j++] = Pic[i++]; } #else if (Pic[i] == _T(';')) i++; if (_totupper(Pic[i]) != _totupper(ch)) if (ch == _T(' ')) ch = Pic[i]; else return prError; input[j++] = Pic[i]; i++; #endif } } if (rslt == prAmbiguous) rslt = prIncompNoFill; else rslt = prIncomplete; } return (rslt == prIncompNoFill) ? prAmbiguous : prComplete; }
UUpdateManager::EUpdateStartResult UUpdateManager::StartCheckInternal(bool bInCheckHotfixOnly) { EUpdateStartResult Result = EUpdateStartResult::None; if (!ChecksEnabled()) { UE_LOG(LogHotfixManager, Display, TEXT("Update checks disabled!")); bInitialUpdateFinished = true; auto StartDelegate = [this]() { CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange); }; DelayResponse(StartDelegate, 0.1f); return Result; } if (CurrentUpdateState == EUpdateState::UpdateIdle || CurrentUpdateState == EUpdateState::UpdatePending || CurrentUpdateState == EUpdateState::UpdateComplete) { bCheckHotfixAvailabilityOnly = bInCheckHotfixOnly; // Immediately move into a pending state so the UI state trigger fires SetUpdateState(EUpdateState::UpdatePending); const EUpdateCompletionStatus LastResult = LastCompletionResult[bCheckHotfixAvailabilityOnly]; const FTimespan DeltaTime = FDateTime::UtcNow() - LastUpdateCheck[bCheckHotfixAvailabilityOnly]; const bool bForceCheck = LastResult == EUpdateCompletionStatus::UpdateUnknown || LastResult == EUpdateCompletionStatus::UpdateFailure_PatchCheck || LastResult == EUpdateCompletionStatus::UpdateFailure_HotfixCheck || LastResult == EUpdateCompletionStatus::UpdateFailure_NotLoggedIn; static double CacheTimer = UPDATE_CHECK_SECONDS; const double TimeSinceCheck = DeltaTime.GetTotalSeconds(); if (bForceCheck || TimeSinceCheck >= CacheTimer) { auto StartDelegate = [this]() { // Check for a patch first, then hotfix application StartPatchCheck(); }; // Give the UI state widget a chance to start listening for delegates DelayResponse(StartDelegate, 0.2f); Result = EUpdateStartResult::UpdateStarted; } else { UE_LOG(LogHotfixManager, Display, TEXT("Returning cached update result %d"), (int32)LastResult); auto StartDelegate = [this, LastResult]() { CheckComplete(LastResult, false); }; DelayResponse(StartDelegate, 0.1f); Result = EUpdateStartResult::UpdateCached; } } else { UE_LOG(LogHotfixManager, Display, TEXT("Update already in progress")); } return Result; }