private static void WriteDescription(this MamlWriter writer, ChildEntry entry, Context context)
{
if (entry.Particle != null)
{
writer.WriteSummaryForObject(context, entry.Particle);
}
}
private static void WriteName(this MamlWriter writer, ChildEntry entry, TopicManager topicManager)
{
switch (entry.ChildType)
{
case ChildType.Element:
case ChildType.ElementExtension:
var element = (XmlSchemaElement)entry.Particle;
var isExtension = (entry.ChildType == ChildType.ElementExtension);
writer.WriteElementLink(topicManager, element, isExtension);
break;
case ChildType.Any:
writer.WriteHtmlArtItemWithText(ArtItem.AnyElement, "Any");
break;
case ChildType.All:
writer.WriteHtmlArtItemWithText(ArtItem.All, "All");
break;
case ChildType.Choice:
writer.WriteHtmlArtItemWithText(ArtItem.Choice, "Choice");
break;
case ChildType.Sequence:
writer.WriteHtmlArtItemWithText(ArtItem.Sequence, "Sequence");
break;
default:
throw ExceptionBuilder.UnhandledCaseLabel(entry.ChildType);
}
}
/// <summary>
/// Update child life according to the current time.
/// The entry should be in <see cref="childStateMap"/>.
/// If the current state is <see cref="LifetimeState.Current"/> then
/// the child should be contained in <see cref="CompositeDrawable.AliveInternalChildren"/>.
/// Otherwise, the entry should already be removed from the corresponding list.
/// </summary>
/// <returns>Whether <see cref="CompositeDrawable.AliveInternalChildren"/> has changed.</returns>
private bool updateChildEntry([NotNull] ChildEntry entry, bool onChildLifetimeChange = false)
{
var child = entry.Drawable;
var oldState = entry.State;
Debug.Assert(child.LoadState >= LoadState.Ready);
Debug.Assert(childStateMap.TryGetValue(child, out var e) && e == entry);
Debug.Assert(oldState != LifetimeState.Current || AliveInternalChildren.Contains(child));
Debug.Assert(!futureChildren.Contains(entry) && !pastChildren.Contains(entry));
var currentTime = Time.Current;
var newState =
currentTime < entry.LifetimeStart ? LifetimeState.Future :
entry.LifetimeEnd <= currentTime ? LifetimeState.Past :
LifetimeState.Current;
if (newState == oldState)
{
// We need to re-insert to future/past children even if lifetime state is not changed if it is from ChildLifetimeChange.
if (onChildLifetimeChange)
{
futureOrPastChildren(newState)?.Add(entry);
}
else
{
Debug.Assert(newState != LifetimeState.Future && newState != LifetimeState.Past);
}
return(false);
}
bool aliveChildrenChanged = false;
if (newState == LifetimeState.Current)
{
MakeChildAlive(child);
aliveChildrenChanged = true;
}
else if (oldState == LifetimeState.Current)
{
bool removed = MakeChildDead(child);
Trace.Assert(!removed, $"{nameof(RemoveWhenNotAlive)} is not supported for children of {nameof(LifetimeManagementContainer)}");
aliveChildrenChanged = true;
}
entry.State = newState;
futureOrPastChildren(newState)?.Add(entry);
enqueueEvents(child, oldState, newState);
return(aliveChildrenChanged);
}
private static void WriteOccurrence(this MamlWriter writer, ChildEntry entry)
{
if (entry.MinOccurs == 1 && entry.MaxOccurs == 1)
{
return;
}
if (entry.MaxOccurs == decimal.MaxValue)
{
writer.WriteString("[{0}, *]", entry.MinOccurs);
}
else
{
writer.WriteString("[{0}, {1}]", entry.MinOccurs, entry.MaxOccurs);
}
}
private static int CompareChildEntries(ChildEntry x, ChildEntry y)
{
if (x.ChildType == ChildType.Element &&
y.ChildType == ChildType.Element ||
x.ChildType == ChildType.ElementExtension &&
y.ChildType == ChildType.ElementExtension)
{
var xElement = (XmlSchemaElement)x.Particle;
var yElement = (XmlSchemaElement)y.Particle;
return(xElement.QualifiedName.Name.CompareTo(yElement.QualifiedName.Name));
}
if (x.ChildType == y.ChildType)
{
return(0);
}
if (x.ChildType == ChildType.Any)
{
return(1);
}
if (y.ChildType == ChildType.Any)
{
return(-1);
}
if (x.ChildType != ChildType.Element)
{
return(-1);
}
if (y.ChildType != ChildType.Element)
{
return(1);
}
return(0);
}
protected override bool CheckChildrenLife()
{
// We have to at least wait until Clock becomes available.
if (LoadState != LoadState.Loaded)
{
return(false);
}
bool aliveChildrenChanged = false;
// Move loaded children to appropriate list.
for (var i = newChildren.Count - 1; i >= 0; --i)
{
FrameStatistics.Increment(StatisticsCounterType.CCL);
var child = newChildren[i];
if (child.LoadState >= LoadState.Ready)
{
Debug.Assert(!childStateMap.ContainsKey(child));
newChildren.RemoveAt(i);
var entry = new ChildEntry(child);
childStateMap.Add(child, entry);
aliveChildrenChanged |= updateChildEntry(entry);
}
}
var currentTime = Time.Current;
// Checks for newly alive children when time is increased or new children added.
while (futureChildren.Count > 0)
{
FrameStatistics.Increment(StatisticsCounterType.CCL);
var entry = futureChildren.Min;
Debug.Assert(entry.State == LifetimeState.Future);
if (currentTime < entry.LifetimeStart)
{
break;
}
futureChildren.Remove(entry);
aliveChildrenChanged |= updateChildEntry(entry);
}
while (pastChildren.Count > 0)
{
FrameStatistics.Increment(StatisticsCounterType.CCL);
var entry = pastChildren.Max;
Debug.Assert(entry.State == LifetimeState.Past);
if (entry.LifetimeEnd <= currentTime)
{
break;
}
pastChildren.Remove(entry);
aliveChildrenChanged |= updateChildEntry(entry);
}
for (var i = AliveInternalChildren.Count - 1; i >= 0; --i)
{
FrameStatistics.Increment(StatisticsCounterType.CCL);
var child = AliveInternalChildren[i];
Debug.Assert(childStateMap.ContainsKey(child));
var entry = childStateMap[child];
aliveChildrenChanged |= updateChildEntry(entry);
}
Debug.Assert(newChildren.Count + futureChildren.Count + pastChildren.Count + AliveInternalChildren.Count == InternalChildren.Count);
while (eventQueue.Count != 0)
{
var e = eventQueue.Dequeue();
OnChildLifetimeBoundaryCrossed(e);
}
return(aliveChildrenChanged);
}
public void Remove(ChildEntry entry)
{
Entries.Remove(entry);
}
public void Add()
{
Entries.Add(NewEntry);
NewEntry = new ChildEntry();
}
/// <summary>
/// Removes the entry with the specified id.
/// </summary>
/// <param name="id"> The id. </param>
/// <param name="entry"> The entry. </param>
public virtual void RemoveEntry(int id, ChildEntry entry)
{
entries.Remove(id);
}
/// <summary>
/// Replaces or inserts the child entry with the specified id.
/// </summary>
/// <param name="id"> The id. </param>
/// <param name="entry"> The entry. </param>
public virtual void PutEntry(int id, ChildEntry entry)
{
entries.Add(id, entry);
}
async void Add_Children_Handler(object sender, EventArgs e)
{
var childEntryPage = new ChildEntry();
await Navigation.PushModalAsync(childEntryPage);
}
