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