public void testTyping() { Model.ElementDefinition ed = new Model.ElementDefinition(); ed.Binding = new Model.ElementDefinition.BindingComponent(); ed.Binding.setValueSet(new UriType("http://test.org")); testBoolean(null, ed.Binding.getValueSet(), "ElementDefinition.binding.valueSetUri", "startsWith('http:') or startsWith('https') or startsWith('urn:')", true); }
/// <summary> /// Creates a differential structure with all "skipped" parents filled in. /// </summary> /// <returns>The full tree structure representing the differential</returns> /// <remarks>This operation will not touch the source differential, but instead will return a new structure.</remarks> public List<ElementDefinition> MakeTree() { var diff = new List<ElementDefinition>(_source.DeepCopy()); // We're going to modify the differential if (diff.Count == 0 ) return diff; // nothing to do var index = 0; while (index < diff.Count) { var thisPath = diff[index].Path; var prevPath = index > 0 ? diff[index - 1].Path : String.Empty; if (thisPath.IndexOf('.') == -1) { // I am a root node, just one segment of path, I need to be the first element if (index != 0) throw Error.InvalidOperation("Differential has multiple roots at " + thisPath); // Else, I am fine, proceed index++; } else if (ElementNavigator.IsSibling(thisPath, prevPath) || ElementNavigator.IsDirectChildPath(prevPath, thisPath)) { // The previous path is a sibling, or my direct parent, so everything is alright, proceed to next node index++; } else { var parentPath = ElementNavigator.GetParentPath(thisPath); if (prevPath == String.Empty || !prevPath.StartsWith(parentPath + ".")) { // We're missing a path part, insert an empty parent var parentElement = new ElementDefinition() { Path = parentPath }; diff.Insert(index, parentElement); // Now, we're not sure this parent has parents, so proceed by checking the parent we have just inserted // so -> index is untouched } else { // So, my predecessor an I share ancestry, of which I am sure it has been inserted by this algorithm // before because of my predecessor, so we're fine. index++; } } } return diff; }
public static bool AppendChild(this BaseElementNavigator nav, ElementDefinition child) { var bm = nav.Bookmark(); if (nav.MoveToFirstChild()) { while (nav.MoveToNext()) ; var result = nav.InsertAfter(child); if(!result) nav.ReturnToBookmark(bm); return result; } else { return nav.InsertFirstChild(child); } }
public void TestChildAlterations() { var nav = createTestNav(); var newENode = new ElementDefinition() { Path = "X.Y.E" }; var newC3Node = new ElementDefinition() { Path = "X.Y.C3" }; Assert.IsTrue(nav.JumpToFirst("A.B.C1.D")); Assert.IsTrue(nav.InsertFirstChild(newENode)); Assert.AreEqual(8,nav.OrdinalPosition); Assert.IsTrue(nav.MoveToParent()); Assert.AreEqual("A.B.C1.D", nav.Path); Assert.IsTrue(nav.MoveToFirstChild()); Assert.IsTrue(nav.Delete()); Assert.AreEqual("A.B.C1.D", nav.Path); // should have moved back to parent (single child deleted) Assert.IsTrue(nav.JumpToFirst("A.D")); Assert.IsTrue(nav.InsertFirstChild(newENode)); Assert.AreEqual(9,nav.OrdinalPosition); Assert.IsTrue(nav.MoveToParent()); Assert.AreEqual("A.D", nav.Path); Assert.IsTrue(nav.MoveToFirstChild()); Assert.IsTrue(nav.Delete()); Assert.AreEqual("A.D", nav.Path); // should have moved back to parent (single child deleted) nav.Reset(); Assert.IsTrue(nav.MoveToFirstChild()); Assert.IsTrue(nav.MoveToFirstChild()); // A.B Assert.IsTrue(nav.AppendChild(newC3Node)); Assert.AreEqual("A.B.C3",nav.Path); Assert.AreEqual(4, nav.OrdinalPosition); Assert.IsTrue(nav.Delete()); Assert.AreEqual(3, nav.OrdinalPosition); Assert.IsTrue(nav.MoveToPrevious()); // A.B.C1 Assert.IsTrue(nav.Delete()); Assert.AreEqual(2, nav.OrdinalPosition); Assert.IsTrue(nav.Delete()); Assert.AreEqual(1, nav.OrdinalPosition); // Moved back to parent? }
public void TestSiblingAlterations() { var nav = createTestNav(); var newCNode = new ElementDefinition() { Path = "X.C" }; Assert.AreEqual(9, nav.Count); nav.MoveToFirstChild(); Assert.IsTrue(nav.MoveToChild("D")); Assert.IsTrue(nav.InsertBefore(newCNode)); Assert.AreEqual("A.C", nav.Path); Assert.AreEqual(8, nav.OrdinalPosition); Assert.AreEqual(10, nav.Count); Assert.IsTrue(nav.Delete()); // delete new "C" node we just created Assert.AreEqual(8, nav.OrdinalPosition); Assert.AreEqual(9, nav.Count); Assert.IsTrue(nav.MoveToPrevious()); // 3rd "A.B" node Assert.IsTrue(nav.InsertAfter(newCNode)); Assert.AreEqual("A.C", nav.Path); Assert.AreEqual(8, nav.OrdinalPosition); Assert.AreEqual(10, nav.Count); Assert.IsTrue(nav.Delete()); // delete new "C" node we just created Assert.AreEqual(8, nav.OrdinalPosition); Assert.AreEqual(9, nav.Count); Assert.IsTrue(nav.InsertAfter(newCNode)); Assert.AreEqual("A.C", nav.Path); Assert.AreEqual(9, nav.OrdinalPosition); Assert.AreEqual(10, nav.Count); Assert.IsTrue(nav.Delete()); // delete new "C" node we just created Assert.AreEqual(8, nav.OrdinalPosition); Assert.AreEqual(9, nav.Count); Assert.IsTrue(nav.MoveToParent()); Assert.IsTrue(nav.MoveToFirstChild()); Assert.IsTrue(nav.InsertBefore(newCNode)); Assert.AreEqual("A.C", nav.Path); Assert.AreEqual(1, nav.OrdinalPosition); Assert.AreEqual(10, nav.Count); }
/// <summary> /// Inserts the element passed in as a child of the element the navigator is currently on. /// The navigator will move to the inserted element. /// </summary> /// <param name="child"></param> /// <returns></returns> /// <remarks>You can only insert a child for an element does not have children yet.</remarks> public override bool InsertFirstChild(ElementDefinition child) { if(Count == 0) { // Special case, insert a new root Elements.Add(child); child.Path = child.GetNameFromPath(); OrdinalPosition = 0; return true; } else if(HasChildren) return false; // Cannot insert another child, there's already one. else { var newSiblingPath = Path + "." + child.GetNameFromPath(); if (OrdinalPosition == Count - 1) // At last position Elements.Add(child); else Elements.Insert(OrdinalPosition.Value + 1, child); // Set the name to be a true child -> this actually creates a child child.Path = newSiblingPath; // Navigate to newly inserted child OrdinalPosition += 1; return true; } }
/// <summary> /// Inserts the element passed in as a sibling to the element the navigator is currently on. /// The navigator will move to the inserted element. /// </summary> /// <param name="sibling"></param> /// <returns></returns> public override bool InsertAfter(ElementDefinition sibling) { if (!canInsertSiblingHere()) return false; var insertPosition = positionAfter(); var newSiblingPath = ParentPath + "." + sibling.GetNameFromPath(); if (insertPosition == Count) // At last position Elements.Add(sibling); else Elements.Insert(insertPosition, sibling); // Adjust the sibling's path so it's parent is the same as the current node sibling.Path = newSiblingPath; // Navigate to newly inserted node OrdinalPosition = insertPosition; return true; }
//---------------------------------- // // Methods that alter the list of elements // //---------------------------------- /// <summary> /// Inserts the element passed in as a sibling to the element the navigator is currently on. /// The navigator will move to the inserted element. /// </summary> /// <param name="sibling"></param> /// <returns></returns> public override bool InsertBefore(ElementDefinition sibling) { if (!canInsertSiblingHere()) return false; var newSiblingPath = ParentPath + "." + sibling.GetNameFromPath(); Elements.Insert(OrdinalPosition.Value, sibling); // Adjust the sibling's path so it's parent is the same as the current node sibling.Path = newSiblingPath; // Note: we're now positioned on the newly inserted element return true; }
public abstract bool InsertFirstChild(ElementDefinition child);
private static ElementDefinition createExtensionSlicingEntry() { // Create a pre-fab extension slice, filled with sensible defaults var slicingDiff = new ElementDefinition(); slicingDiff.Slicing = new ElementDefinition.SlicingComponent(); slicingDiff.Slicing.Discriminator = new[] { "url" }; slicingDiff.Slicing.Ordered = false; slicingDiff.Slicing.Rules = ElementDefinition.SlicingRules.Open; return slicingDiff; }
public abstract bool InsertAfter(ElementDefinition sibling);
//---------------------------------- // // Methods that alter the list of elements // //---------------------------------- public abstract bool InsertBefore(ElementDefinition sibling);
private ElementDefinition createExtensionSlicingEntry(string path, ElementDefinition template) { // Create a pre-fab extension slice, filled with sensible defaults var slicingDiff = new ElementDefinition(); slicingDiff.Slicing = new ElementDefinition.ElementDefinitionSlicingComponent(); slicingDiff.Slicing.Discriminator = new[] { "url" }; slicingDiff.Slicing.Ordered = false; slicingDiff.Slicing.Rules = ElementDefinition.SlicingRules.Open; var result = createSliceEntry(template, slicingDiff); return result; }
private ElementDefinition createSliceEntry(ElementDefinition baseDefn, ElementDefinition diff) { var slicingEntry = (ElementDefinition)baseDefn.DeepCopy(); (new ElementDefnMerger(_markChanges)).Merge(slicingEntry, diff); return slicingEntry; }
private static bool isSlicedToOne(ElementDefinition element) { return element.Slicing != null && element.Max == "1"; }