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