public void DeserializeVersionLinks(XElement parentNode, SerializationContext context)
{
foreach (XElement linkedItemsElement in parentNode.Elements(context.ExolutioNS + "LinkedItems"))
{
VersionedItemPivot pivot = new VersionedItemPivot();
PivotList.Add(pivot);
Dictionary <Version, Guid> linkedItemsIds = new Dictionary <Version, Guid>();
foreach (XElement linkedItemElement in linkedItemsElement.Elements(context.ExolutioNS + "LinkedItem"))
{
Guid id = SerializationContext.DecodeGuid(linkedItemElement.Attribute("itemID").Value);
Guid versionId = SerializationContext.DecodeGuid(linkedItemElement.Attribute("versionNumber").Value);
Version version = (Version)Project.TranslateComponent(versionId);
linkedItemsIds[version] = id;
}
if (linkedItemsIds.Count > 0)
{
foreach (KeyValuePair <Version, Guid> kvp in linkedItemsIds)
{
IVersionedItem exolutioObject = (IVersionedItem)Project.TranslateComponent(kvp.Value);
pivotLookupDictionary[exolutioObject.ID] = pivot;
pivot.PivotMapping.Add(kvp.Key, exolutioObject.ID);
}
}
}
}
public IVersionedItem GetItemInVersion(IVersionedItem item, Version version)
{
VersionedItemPivot pivot = PivotLookupDictionary[item.ID];
Guid result;
if (pivot.PivotMapping.TryGetValue(version, out result))
{
return((IVersionedItem)Project.TranslateComponent(result));
}
else
{
return(null);
}
}
/// <summary>
/// Adds new item to versioning infrastracture (item must not be linked to any other existing item).
/// </summary>
public void AddVersionedItem(IVersionedItem item, bool addWhenBranchingOrLoading = false)
{
if ((!Loading && !branching) || addWhenBranchingOrLoading)
{
if (pivotLookupDictionary.ContainsKey(item.ID))
{
throw new ExolutioModelException("Item already added into versioning infrastracture. ");
}
VersionedItemPivot pivot = new VersionedItemPivot();
PivotList.Add(pivot);
pivotLookupDictionary[item.ID] = pivot;
pivot.PivotMapping.Add(item.Version, item.ID);
}
}
/// <summary>
/// Removes item from versioning infrastructure
/// </summary>
public void RemoveVersionedItem(IVersionedItem removedItem)
{
if (!PivotLookupDictionary.ContainsKey(removedItem.ID) && branching)
{
return;
}
VersionedItemPivot pivot = PivotLookupDictionary[removedItem.ID];
Version deletedVersion = removedItem.Version;
// versioned item is going to be removed, thus it is removed from pivot lookup
pivotLookupDictionary.Remove(removedItem.ID);
pivot.PivotMapping.Remove(removedItem.Version.ID);
if (pivot.PivotMapping.IsEmpty())
{
PivotList.Remove(pivot);
}
}
public void VerifyConsistency()
{
foreach (KeyValuePair <Guid, VersionedItemPivot> kvp in PivotLookupDictionary)
{
VersionedItemPivot pivot = kvp.Value;
IVersionedItem versionedItem = (IVersionedItem)Project.TranslateComponent(kvp.Key);
Debug.Assert(pivot.PivotMapping.ContainsKey(versionedItem.Version));
Debug.Assert(pivot.PivotMapping[versionedItem.Version.ID] == versionedItem.ID);
}
foreach (VersionedItemPivot pivot in PivotList)
{
foreach (KeyValuePair <Guid, Guid> itemID in pivot.PivotMapping)
{
Version version = Project.TranslateComponent <Version>(itemID.Key);
IVersionedItem linkedItem = (IVersionedItem)Project.TranslateComponent(itemID.Value);
Debug.Assert(PivotLookupDictionary[linkedItem.ID] == pivot);
}
}
}
public void UnregisterVersionLink(IVersionedItem item1, IVersionedItem item2, IEnumerable <IVersionedItem> group1 = null, IEnumerable <IVersionedItem> group2 = null)
{
if (!AreItemsLinked(item1, item2))
{
throw new ExolutioModelException();
}
VersionedItemPivot pivot;
if (!pivotLookupDictionary.TryGetValue(item1.ID, out pivot))
{
throw new ExolutioModelException();
}
if (group1 == null && group2 == null)
{
group1 = new List <IVersionedItem>(pivot.PivotMapping.Where(kvp => kvp.Key != item2.Version.ID).
Select(kvp => (IVersionedItem)Project.TranslateComponent(kvp.Value)));
group2 = new IVersionedItem[] { item2 };
}
if (group1 == null)
{
group1 = new List <IVersionedItem>(pivot.PivotMapping.Where(kvp => !group2.Contains((IVersionedItem)Project.TranslateComponent(kvp.Value))).
Select(kvp => (IVersionedItem)Project.TranslateComponent(kvp.Value)));
}
if (group2 == null)
{
group2 = new List <IVersionedItem>(pivot.PivotMapping.Where(kvp => !group1.Contains((IVersionedItem)Project.TranslateComponent(kvp.Value))).
Select(kvp => (IVersionedItem)Project.TranslateComponent(kvp.Value)));
}
{
VersionedItemPivot pivot1 = new VersionedItemPivot();
PivotList.Add(pivot1);
foreach (IVersionedItem versionedItem in group1)
{
pivot1.PivotMapping[versionedItem.Version.ID] = versionedItem.ID;
pivotLookupDictionary[versionedItem.ID] = pivot1;
}
}
{
VersionedItemPivot pivot2 = new VersionedItemPivot();
PivotList.Add(pivot2);
foreach (IVersionedItem versionedItem in group2)
{
pivot2.PivotMapping[versionedItem.Version.ID] = versionedItem.ID;
pivotLookupDictionary[versionedItem.ID] = pivot2;
}
}
foreach (KeyValuePair <Guid, Guid> keyValuePair in pivot.PivotMapping)
{
IVersionedItem item = (IVersionedItem)Project.TranslateComponent(keyValuePair.Value);
if (!group1.Contains(item) && !group2.Contains(item))
{
throw new ExolutioModelException();
}
}
PivotList.Remove(pivot);
#if DEBUG
VerifyConsistency();
#endif
}
public void RegisterVersionLink(Version version1, Version version2, IVersionedItem itemVersion1, IVersionedItem itemVersion2)
{
if (version1 != itemVersion1.Version)
{
throw new ExolutioModelException(Exceptions.VersionManager_RegisterVersionLink_itemOldVersion_Version_must_point_to_the_same_object_as_oldVersion);
}
if (itemVersion1.GetType() != itemVersion2.GetType())
{
throw new ExolutioModelException();
}
VersionedItemPivot pivot1;
VersionedItemPivot pivot2;
VersionedItemPivot pivot;
pivotLookupDictionary.TryGetValue(itemVersion1.ID, out pivot1);
pivotLookupDictionary.TryGetValue(itemVersion2.ID, out pivot2);
if (pivot1 == null && pivot2 == null) // new pivot is created
{
AddVersionedItem(itemVersion1, true);
pivot = pivotLookupDictionary[itemVersion1.ID];
pivotLookupDictionary[itemVersion2.ID] = pivot;
pivot.PivotMapping[version2] = itemVersion2.ID;
}
else if (pivot1 == null) //existing pivot is used
{
pivot = pivot2;
pivotLookupDictionary[itemVersion1.ID] = pivot;
pivot.PivotMapping[version1] = itemVersion1.ID;
}
else if (pivot2 == null) //existing pivot is used
{
pivot = pivot1;
pivotLookupDictionary[itemVersion2.ID] = pivot;
pivot.PivotMapping[version2] = itemVersion2.ID;
}
else // in this case the two existing pivots are merged
{
pivot = new VersionedItemPivot();
PivotList.Add(pivot);
PivotList.Remove(pivot1);
PivotList.Remove(pivot2);
foreach (KeyValuePair <Guid, Guid> keyValuePair in pivot1.PivotMapping)
{
Guid versionGuid = keyValuePair.Key;
Guid itemGuid = keyValuePair.Value;
pivotLookupDictionary[itemGuid] = pivot;
pivot.PivotMapping[versionGuid] = itemGuid;
}
foreach (KeyValuePair <Guid, Guid> keyValuePair in pivot2.PivotMapping)
{
Guid versionGuid = keyValuePair.Key;
Guid itemGuid = keyValuePair.Value;
pivotLookupDictionary[itemGuid] = pivot;
pivot.PivotMapping[versionGuid] = itemGuid;
}
}
#if DEBUG
VerifyConsistency();
#endif
}
public IEnumerable <IVersionedItem> GetAllVersionsOfItem(IVersionedItem item)
{
VersionedItemPivot pivot = PivotLookupDictionary[item.ID];
return(pivot.PivotMapping.Values.Select(ID => (IVersionedItem)Project.TranslateComponent(ID)));
}
