/// <summary> /// Checks the conflicts. /// </summary> /// <param name="element">The element.</param> /// <param name="newName">The new name.</param> /// <returns></returns> private ConflictType CheckConflicts(CodeElement element, string newName) { IConflictResolver resolver = RenameStrategyFactory.CreateConflictResolver(element.Kind, GetFileCodeModel()); if (resolver != null) { IEnumerable <CodeElement> conflictElements = resolver.FindConflicts(element, newName); if (resolver.HasConflict()) { using (var conflictsFrom = new RenameConflictsFrom(conflictElements)) { DialogResult dResult = conflictsFrom.ShowDialog(); if (dResult == DialogResult.OK) { return(ConflictType.Function); } if (dResult == DialogResult.Cancel) { return(ConflictType.Canceled); } } } } return(ConflictType.None); }
internal void DoOpenManual() { SetStandBy("Manual opening file: " + mSavedGameFilename); PlayGamesPlatform.Instance.SavedGame.OpenWithManualConflictResolution( mSavedGameFilename, DataSource.ReadNetworkOnly, true, (resolver, original, originalData, unmerged, unmergedData) => { GooglePlayGames.OurUtils.Logger.d("Entering conflict callback"); mConflictResolver = resolver; mConflictOriginal = original; mConflictOriginalData = System.Text.ASCIIEncoding.Default.GetString(originalData); mConflictUnmerged = unmerged; mConflictUnmergedData = System.Text.ASCIIEncoding.Default.GetString(unmergedData); SetUI(Ui.ResolveSaveConflict); EndStandBy(); GooglePlayGames.OurUtils.Logger.d("Encountered manual open conflict."); }, (status, openedFile) => { Status = "Open status for file " + mSavedGameFilename + ": " + status + "\n"; if (openedFile != null) { Status += "Successfully opened file: " + openedFile; GooglePlayGames.OurUtils.Logger.d("Opened file: " + openedFile); mCurrentSavedGame = openedFile; } EndStandBy(); }); }
private void ResolveConflict(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { if (originalData == null) { resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { resolver.ChooseMetadata(original); } else { string originalStr = Encoding.ASCII.GetString(originalData); string unmergedStr = Encoding.ASCII.GetString(unmergedData); int[] originalArray = JsonUtil.JsonStringToArray(originalStr, "SaveKey", str => int.Parse(str)); int[] unmergedArray = JsonUtil.JsonStringToArray(unmergedStr, "SaveKey", str => int.Parse(str)); for (int i = 0; i < originalArray.Length; i++) { if (originalArray[i] > unmergedArray[i]) { resolver.ChooseMetadata(original); return; } else if (unmergedArray[i] > originalArray[i]) { resolver.ChooseMetadata(unmerged); return; } } resolver.ChooseMetadata(original); } }
public void ResolveConflicts(IConflictResolver <TType> resolver) { foreach (var item in resolver.ToList()) { resolver.ResolveConflict(item, this.aAction); } }
private void ResolveConflict(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { if (originalData == null) { resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { resolver.ChooseMetadata(original); } else { BinaryFormatter bf = null; MemoryStream memStream = null; GameData originalObj = null; GameData unmergedObj = null; // Deserialize originalData bf = new BinaryFormatter(); memStream = new MemoryStream(); memStream.Write(originalData, 0, originalData.Length); memStream.Seek(0, SeekOrigin.Begin); originalObj = (GameData)bf.Deserialize(memStream); // Deserialize unmergedData bf = new BinaryFormatter(); memStream = new MemoryStream(); memStream.Write(unmergedData, 0, unmergedData.Length); memStream.Seek(0, SeekOrigin.Begin); unmergedObj = (GameData)bf.Deserialize(memStream); // resolving strategy: pick the one with highest totalItemsPurchasedToDate // if both totalItemsPurchasedToDate are equal, pick the one with higher caughtCount if (originalObj.GetTotalItemsPurchasedToDate() > unmergedObj.GetTotalItemsPurchasedToDate()) { resolver.ChooseMetadata(original); return; } else if (unmergedObj.GetTotalItemsPurchasedToDate() > originalObj.GetTotalItemsPurchasedToDate()) { resolver.ChooseMetadata(unmerged); return; } else { if (originalObj.GetCaughtTotal() > unmergedObj.GetCaughtTotal()) { resolver.ChooseMetadata(original); } else { resolver.ChooseMetadata(unmerged); } } } }
internal static ConflictResolverWindow Show(IConflictResolver conflictResolver, IEnumerable <KeyCombination> keyCombinationSequence, IEnumerable <ShortcutEntry> entries) { var win = CreateInstance <ConflictResolverWindow>(); win.Init(conflictResolver, keyCombinationSequence, entries, GUIView.focusedView); win.minSize = new Vector2(550, 250); win.maxSize = new Vector2(550, 600); win.ShowModal(); win.Focus(); return(win); }
protected BasePersistState( IRepository <TDatabaseInterface> repository, ISinceParameterRepository sinceParameterRepository, IConflictResolver <TDatabaseInterface> conflictResolver, IRivalsResolver <TDatabaseInterface> rivalsResolver = null) { this.repository = repository; this.sinceParameterRepository = sinceParameterRepository; this.conflictResolver = conflictResolver; this.rivalsResolver = rivalsResolver; }
/// <summary> /// Creates a new instance of a ProjectMerger class /// </summary> /// <param name="operation">The operation being performed</param> /// <param name="referenceResolver">An object to resolve reference conflicts that cannot be auto resolved.</param> /// <param name="projectReferenceResolver">An object to resolve project reference conflicts that cannot be auto resolved.</param> /// <param name="itemResolver">An object to resolve item conflicts that cannot be auto resolved.</param> /// <param name="duplicateReferenceResolver">An object to resolve duplicate references.</param> public ProjectMerger( CurrentOperation operation, IConflictResolver<ProjectReference> projectReferenceResolver, IConflictResolver<Reference> referenceResolver, IConflictResolver<RawItem> itemResolver, IDuplicateResolver<Reference> duplicateReferenceResolver ) { _operation = operation; _referenceResolver = referenceResolver; _itemResolver = itemResolver; _duplicateReferenceResolver = duplicateReferenceResolver; _projectReferenceResolver = projectReferenceResolver; }
internal void Init(IConflictResolver conflictResolver, IEnumerable <KeyCombination> keyCombinationSequence, IEnumerable <ShortcutEntry> entries, GUIView previouslyFocusedView) { m_PreviouslyFocusedView = previouslyFocusedView; m_ConflictResolver = conflictResolver; m_Entries = entries.ToList(); var multiColumnHeader = new MultiColumnHeader(m_MulticolumnHeaderState); multiColumnHeader.ResizeToFit(); m_ConflictListView = new ConflictListView(m_TreeViewState, multiColumnHeader, m_Entries); m_Header = string.Format(L10n.Tr("The binding \"{0}\" conflicts with multiple commands."), KeyCombination.SequenceToString(keyCombinationSequence)); }
public ImportService( IApiLoader apiLoader, IConflictResolver <ApiMaterial, Database.MaterialOverviewItem> materialConflictResolver, IConflictResolver <ApiSection, Database.ParametricSectionOverviewItem> sectionConflictResolver, IUbsmDatabase database, IdGenerator idGenerator, Settings settings) { _apiLoader = apiLoader; _materialConflictResolver = materialConflictResolver; _sectionConflictResolver = sectionConflictResolver; _database = database; _idGenerator = idGenerator; _settings = settings; }
/// <summary> /// Creates IConflictResolver by elementType. /// </summary> /// <param name="elementType">Type of CodeElement.</param> /// <param name="fileCodeModel">LuaFileCodeModel instance.</param> /// <returns>IConflictResolver implementation.</returns> public static IConflictResolver CreateConflictResolver(vsCMElement elementType, LuaFileCodeModel fileCodeModel) { IConflictResolver result = null; switch (elementType) { case vsCMElement.vsCMElementFunctionInvokeStmt: case vsCMElement.vsCMElementFunction: { result = new FunctionConflictResolver(fileCodeModel); break; } } return(result); }
private void ResolveConflict(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { if (originalData == null) { resolver.ChooseMetadata(unmerged); Debug.Log("(Hangry)unmerged data chosen due to null!"); } else if (unmergedData == null) { resolver.ChooseMetadata(original); Debug.Log("(Hangry)original data chosen due to null!"); } else { //decoding byte data into string string originalStr = Encoding.UTF8.GetString(originalData); string unmergedStr = Encoding.UTF8.GetString(unmergedData); //parsing int[] originalArray = JsonUtil.JsonStringToArray(originalStr, "myKey", str => int.Parse(str)); int[] unmergedArray = JsonUtil.JsonStringToArray(unmergedStr, "myKey", str => int.Parse(str)); for (int i = 0; i < originalArray.Length; i++) { //if original score is greater than unmerged if (originalArray[i] > unmergedArray[i]) { Debug.Log("(Hangry)original data chosen, better!"); resolver.ChooseMetadata(original); return; } //else (unmerged score is greater than original) else if (unmergedArray[i] > originalArray[i]) { Debug.Log("(Hangry)unmerged data chosen, vbettter!"); resolver.ChooseMetadata(unmerged); return; } } //if return doesn't get called, original and unmerged are identical //we can keep either one Debug.Log("(Hangry)original data chosen, same!"); resolver.ChooseMetadata(original); } }
internal MergePanel( ICurrentConflictUpdater currentConflictUpdater, IConflictResolver conflictResolver, IHeaderPrinter headerPrinter, IIconPrinter iconPrinter, IExplanationUpdater explanationUpdater, IManualEditionSaver manualEditionSaver, SemanticMergeSource.FileTrees fileTrees, SemanticToolInfo toolInfo, IDifferencesExecutor diffExecutor, ISyntaxLanguageListener syntaxLanguageListener, IFileNavigator fileNavigator) { mFileTrees = fileTrees; mToolInfo = toolInfo; mContributorsView = new ContributorsView( currentConflictUpdater, conflictResolver, this, headerPrinter, explanationUpdater, this, this, toolInfo, diffExecutor, fileNavigator); mResultView = new ResultView( currentConflictUpdater, conflictResolver, this, headerPrinter, iconPrinter, explanationUpdater, this, this, manualEditionSaver, toolInfo, diffExecutor, syntaxLanguageListener, fileNavigator); }
private void ResolveConflict(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { if (originalData == null) { resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { resolver.ChooseMetadata(original); } else { //decoding byte data into string string originalStr = Encoding.ASCII.GetString(originalData); string unmergedStr = Encoding.ASCII.GetString(unmergedData); //parsing int originalNum = int.Parse(originalStr); int unmergedNum = int.Parse(unmergedStr); //if original score is greater than unmerged if (originalNum > unmergedNum) { resolver.ChooseMetadata(original); return; } //else (unmerged score is greater than original) else if (unmergedNum > originalNum) { resolver.ChooseMetadata(unmerged); return; } //if return doesn't get called, original and unmerged are identical //we can keep either one resolver.ChooseMetadata(original); } }
private void ResolveConflict( IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { if (originalData == null) { resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { resolver.ChooseMetadata(original); } else { string originalString = Encoding.ASCII.GetString(originalData); string unmergedString = Encoding.ASCII.GetString(unmergedData); // TODO: Compare the save resolver.ChooseMetadata(unmerged); } }
public Trigger(IDirectory directory, IConflictResolver conflictResolver) { m_Directory = directory; m_ConflictResolver = conflictResolver; }
public void ResolveConflicts(IConflictResolver resolver) { this.ResolveConflicts((IConflictResolver <TType>)resolver); }
public void ResolveConflicts(IConflictResolver <TType> resolver) { this.aCallBack(typeof(TType), resolver); }
/// <summary> /// Callback for resolving metadata conflict. /// </summary> private void ResolveConflict(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { Debug.Log("[GPGS BUG] ResolveConflict entered."); if (originalData == null) { Debug.Log("[GPGS BUG] ResolveConflict: originalData null. Choose unmerged."); resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { Debug.Log("[GPGS BUG] ResolveConflict: unmergedData null. Choose original."); resolver.ChooseMetadata(original); } else { // deserialising byte data into Save Data SaveData originalSaveData = DeserialiseSaveData(originalData); SaveData unmergedSaveData = DeserialiseSaveData(unmergedData); #region Old Timestamp-based Validation //// getting Timestamp //DateTime originalTimestamp = originalSaveData.Timestamp; //DateTime unmergedTimestamp = unmergedSaveData.Timestamp; //// if original Timestamp is more recent than unmerged Timestamp //if (originalTimestamp > unmergedTimestamp) //{ // resolver.ChooseMetadata(original); // return; //} //// unmerged Timestamp is more recent than original //else if (unmergedTimestamp > originalTimestamp) //{ // resolver.ChooseMetadata(unmerged); // return; //} //// if return doesn't get called, original and unmerged are identical //// can keep either one //resolver.ChooseMetadata(original); #endregion // getting last level int originalLastLevel = originalSaveData.LastLevelNumber; int unmergedLastLevel = originalSaveData.LastLevelNumber; // if original last level is farther than unmerged last level if (originalLastLevel > unmergedLastLevel) { resolver.ChooseMetadata(original); return; } // if unmerged last level is farther than original last level else if (unmergedLastLevel > originalLastLevel) { resolver.ChooseMetadata(unmerged); return; } // if return doesn't get called, original and unmerged last levels are identical // getting stars int originalStars = 0; int unmergedStars = 0; foreach (var levelSaveData in originalSaveData.levelSaveData) { originalStars += levelSaveData.stars; } foreach (var levelSaveData in unmergedSaveData.levelSaveData) { unmergedStars += levelSaveData.stars; } // if original stars is more than unmerged stars if (originalStars > unmergedStars) { Debug.Log("[GPGS BUG] ResolveConflict: originalStars more. Choose original."); resolver.ChooseMetadata(original); return; } // if unmerged stars is more than original stars else if (unmergedStars > originalStars) { Debug.Log("[GPGS BUG] ResolveConflict: unmergedStars more. Choose unmerged."); resolver.ChooseMetadata(unmerged); return; } // if return doesn't get called, original and unmerged are identical // can choose either one Debug.Log("[GPGS BUG] ResolveConflict: identical. Choose original."); resolver.ChooseMetadata(original); } }
private void Worker(int jobId, double lockChance, IConflictResolver resolver) { using (var uc = new FakeUserContext()) { Exception ex = null; try { Exec(jobId, lockChance, s_conflictGuarantee, resolver); } catch (Exception e) { ex = e; } EnsureJobIsNotLocked(jobId, ex, uc.Identity.Name); } }
public void ResolveConflicts <TType>(IConflictResolver <TType> resolver) { IResolveConflictsAlgorithm <TType> algorithm = this.Algorithms.GetResolveConflictsAlgorithm <TType>(); algorithm.ResolveConflicts(resolver); }
public void ResolveConflicts(IConflictResolver <TType> resolver) { throw new NotPossibleToResolveException(); }
static void OnSavedGameOpenedAndWriteConflictResolve(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { resolver.ChooseMetadata(unmerged); }
private void ConflictCallback(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { LoadingText("Conflict detected"); if (originalData == null) { resolver.ChooseMetadata(unmerged); } else if (unmergedData == null) { resolver.ChooseMetadata(original); } else { //decoding byte data into string string originalStr = Encoding.ASCII.GetString(originalData); string unmergedStr = Encoding.ASCII.GetString(unmergedData); JSONSaveData originalJson; JSONSaveData unmergedJson; //parsing try { originalJson = JsonUtility.FromJson <JSONSaveData>(originalStr); } catch (System.Exception e) { originalJson = null; Debug.Log("Error on original" + e); throw; }; try { unmergedJson = JsonUtility.FromJson <JSONSaveData>(unmergedStr); } catch (System.Exception e) { unmergedJson = null; Debug.Log("Error on unmerged" + e); throw; }; if (originalJson == null) { if (unmergedJson == null) { JSONSaveData.currentSave = LoadGameLocal(); } else { resolver.ChooseMetadata(unmerged); } } else { if (unmergedJson == null) { resolver.ChooseMetadata(original); } else { //Comparison if (originalJson.playTime >= unmergedJson.playTime) { resolver.ChooseMetadata(original); } else { resolver.ChooseMetadata(unmerged); } } } } LoadingText("Conflict resolved"); }
public DbConfigurationGetter() { _conflictResolver = new DataBaseConfictResolver(); }
internal void DoOpenManual() { SetStandBy("Manual opening file: " + mSavedGameFilename); PlayGamesPlatform.Instance.SavedGame.OpenWithManualConflictResolution( mSavedGameFilename, DataSource.ReadNetworkOnly, true, (resolver, original, originalData, unmerged, unmergedData) => { Logger.d("Entering conflict callback"); mConflictResolver = resolver; mConflictOriginal = original; mConflictOriginalData = System.Text.ASCIIEncoding.Default.GetString(originalData); mConflictUnmerged = unmerged; mConflictUnmergedData = System.Text.ASCIIEncoding.Default.GetString(unmergedData); mUi = Ui.ResolveSaveConflict; EndStandBy(); Logger.d("Encountered manual open conflict."); }, (status, openedFile) => { mStatus = "Open status for file " + mSavedGameFilename + ": " + status + "\n"; if (openedFile != null) { mStatus += "Successfully opened file: " + openedFile.ToString(); Logger.d("Opened file: " + openedFile.ToString()); mCurrentSavedGame = openedFile; } EndStandBy(); }); }
internal void ResolveConflict([NotNull] string docID, [NotNull] IConflictResolver resolver) { Debug.Assert(docID != null); Document doc = null, otherDoc = null, baseDoc = null; var inConflict = true; while (inConflict) { ThreadSafety.DoLocked(() => { LiteCoreBridge.Check(err => Native.c4db_beginTransaction(_c4db, err)); try { doc = new Document(this, docID); if (!doc.Exists) { doc.Dispose(); return; } otherDoc = new Document(this, docID); if (!otherDoc.Exists) { doc.Dispose(); otherDoc.Dispose(); return; } otherDoc.SelectConflictingRevision(); baseDoc = new Document(this, docID); if (!baseDoc.SelectCommonAncestor(doc, otherDoc) || baseDoc.ToDictionary() == null) { baseDoc.Dispose(); baseDoc = null; } LiteCoreBridge.Check(err => Native.c4db_endTransaction(_c4db, true, err)); } catch (Exception) { doc?.Dispose(); otherDoc?.Dispose(); baseDoc?.Dispose(); LiteCoreBridge.Check(err => Native.c4db_endTransaction(_c4db, false, err)); } }); var conflict = new Conflict(doc, otherDoc, baseDoc); var logID = new SecureLogString(doc.Id, LogMessageSensitivity.PotentiallyInsecure); Log.To.Database.I(Tag, $"Resolving doc '{logID}' with {resolver.GetType().Name} (mine={doc.RevID}, theirs={otherDoc.RevID}, base={baseDoc?.RevID})"); Document resolved = null; try { resolved = resolver.Resolve(conflict); if (resolved == null) { throw new LiteCoreException(new C4Error(C4ErrorCode.Conflict)); } SaveResolvedDocument(resolved, conflict); inConflict = false; } catch (LiteCoreException e) { if (e.Error.domain == C4ErrorDomain.LiteCoreDomain && e.Error.code == (int)C4ErrorCode.Conflict) { continue; } throw; } finally { resolved?.Dispose(); if (resolved != doc) { doc?.Dispose(); } if (resolved != otherDoc) { otherDoc?.Dispose(); } if (resolved != baseDoc) { baseDoc?.Dispose(); } } } }
public DataBaseGetter(IDataBaseIndexesCreator dataBaseIndexesCreator) { _conflictResolver = new DataBaseConfictResolver(); _dataBaseIndexesCreator = dataBaseIndexesCreator; }
private void Exec(int jobId, double pcPercent, double conflictGuarantee, IConflictResolver resolver) { bool claimIt = false; if (s_rng.NextDouble() < pcPercent) claimIt = true; var cs = BuildChangeSet(jobId); var dc = new Rel.Data.Ef6.TpContext(); var res = resolver; var csp = new ChangeSetProcessor(dc, res); ChangeSet result; if (s_rng.NextDouble() < conflictGuarantee) { Touch(jobId, cs); } using (new Timed(false, "ChangeSet {0}", res.GetType().Name)) result = csp.Process(jobId, claimIt, cs); }
void OnSavedGameOpenedAndReadConflictResolve(IConflictResolver resolver, ISavedGameMetadata original, byte[] originalData, ISavedGameMetadata unmerged, byte[] unmergedData) { resolver.ChooseMetadata(original); }
public void Show(IConflictResolver conflictResolver, IEnumerable <KeyCombination> keyCombinationSequence, IEnumerable <ShortcutEntry> entries) { ConflictResolverWindow.Show(conflictResolver, keyCombinationSequence, entries); }