internal static GraphStack New(IGraphRoot root, List <IGraphParentElement> parentElements)
{
var stack = GenericPool <GraphStack> .New(() => new GraphStack());
stack.InitializeNoAlloc(root, parentElements, true);
return(stack);
}
internal static GraphStack New(GraphPointer model)
{
var stack = GenericPool <GraphStack> .New(() => new GraphStack());
stack.CopyFrom(model);
return(stack);
}
public static CloningContext New(ICloner fallbackCloner, bool tryPreserveInstances)
{
var context = GenericPool <CloningContext> .New(() => new CloningContext());
context.fallbackCloner = fallbackCloner;
context.tryPreserveInstances = tryPreserveInstances;
return(context);
}
public void Dispose()
{
if (disposed)
{
throw new ObjectDisposedException(ToString());
}
GenericPool <Flow> .Free(this);
}
public static Flow New(GraphReference reference)
{
Ensure.That(nameof(reference)).IsNotNull(reference);
var flow = GenericPool <Flow> .New(() => new Flow());;
flow.stack = reference.ToStackPooled();
return(flow);
}
public void RestoreTo(IUnit unit)
{
if (disposed)
{
throw new ObjectDisposedException(ToString());
}
// Restore inline values if possible
foreach (var previousDefaultValue in defaultValues)
{
if (unit.defaultValues.ContainsKey(previousDefaultValue.Key) &&
unit.valueInputs.Contains(previousDefaultValue.Key) &&
unit.valueInputs[previousDefaultValue.Key].type.IsAssignableFrom(previousDefaultValue.Value))
{
unit.defaultValues[previousDefaultValue.Key] = previousDefaultValue.Value;
}
}
// Restore connections if possible
foreach (var previousInputConnections in inputConnections)
{
var previousInputPort = new UnitPortPreservation(unit, previousInputConnections.Key);
var previousOutputPorts = previousInputConnections.Value;
foreach (var previousOutputPort in previousOutputPorts)
{
RestoreConnection(previousOutputPort, previousInputPort);
}
}
foreach (var previousOutputConnections in outputConnections)
{
var previousOutputPort = new UnitPortPreservation(unit, previousOutputConnections.Key);
var previousInputPorts = previousOutputConnections.Value;
foreach (var previousInputPort in previousInputPorts)
{
RestoreConnection(previousOutputPort, previousInputPort);
}
}
GenericPool <UnitPreservation> .Free(this);
}
public static Recursion <T> New(int maxDepth)
{
if (!Recursion.safeMode)
{
return(null);
}
if (maxDepth < 1)
{
throw new ArgumentException("Max recursion depth must be at least one.", nameof(maxDepth));
}
var recursion = GenericPool <Recursion <T> > .New(() => new Recursion <T>());
recursion.maxDepth = maxDepth;
return(recursion);
}
public static UnitPreservation Preserve(IUnit unit)
{
var preservation = GenericPool <UnitPreservation> .New(() => new UnitPreservation());
foreach (var defaultValue in unit.defaultValues)
{
preservation.defaultValues.Add(defaultValue.Key, defaultValue.Value);
}
foreach (var input in unit.inputs)
{
if (input.hasAnyConnection)
{
preservation.inputConnections.Add(input.key, ListPool <UnitPortPreservation> .New());
foreach (var connectedPort in input.connectedPorts)
{
preservation.inputConnections[input.key].Add(new UnitPortPreservation(connectedPort));
}
}
}
foreach (var output in unit.outputs)
{
if (output.hasAnyConnection)
{
preservation.outputConnections.Add(output.key, ListPool <UnitPortPreservation> .New());
foreach (var connectedPort in output.connectedPorts)
{
preservation.outputConnections[output.key].Add(new UnitPortPreservation(connectedPort));
}
}
}
return(preservation);
}
public void Dispose()
{
GenericPool <GraphStack> .Free(this);
}
protected virtual void Free()
{
GenericPool <Recursion <T> > .Free(this);
}
