public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { ITimeSpaceAdaptedOutput adaptedOutput = adaptedOutputId as ITimeSpaceAdaptedOutput; if (adaptedOutput == null) throw new ArgumentException("Adapted output id does no come from this factory","adaptedOutputId"); return (adaptedOutput); }
/// <summary> /// Create an adapted output, assuming that the adaptee and target are matching (check must /// be done beforehand. /// </summary> /// <param name="adaptee">Adaptee to connect to multi input</param> /// <param name="target">Target of created multi input adaptor</param> /// <returns>Multi input adaptor, connected to adaptee</returns> public ITimeSpaceAdaptedOutput CreateAdaptedOutput(IBaseOutput adaptee, IBaseInput target) { MultiInputAdaptor multiInputAdaptor; if (!ExistingMultiInputAdaptors.TryGetValue(target, out multiInputAdaptor)) { // Set up a multi input adaptor having the same properties as the target multiInputAdaptor = new MultiInputAdaptor("MultiInputAdaptor:" + target.Id) { SpatialDefinition = ((ITimeSpaceInput)target).SpatialDefinition, ValueDefinition = target.ValueDefinition, }; ExistingMultiInputAdaptors.Add(target, multiInputAdaptor); } // Identity adaptor, create and register with multiInput //adaptedOutput = multiInputAdaptor.CreateChildAdaptor(adaptee); // The trick here is to always return and use the same multi input adaptor. // for all adaptees. multiInputAdaptor.Adaptees.Add((ITimeSpaceOutput)adaptee); // Connect adaptee and adaptor - the factory must do this. if (!adaptee.AdaptedOutputs.Contains(multiInputAdaptor)) { adaptee.AddAdaptedOutput(multiInputAdaptor); } return(multiInputAdaptor); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tadaptee = adaptee as ITimeSpaceOutput; // Not a time-space exchange item, no available adaptors if (tadaptee == null) return (new IIdentifiable[0]); // For each of the spatial extension classes, return its wrapper class // MultiPoint must come before ILineString (because ILineString is currently also an IMultiPoint) if (tadaptee.SpatialDefinition is IMultiPoint) return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new MultiPointWrapper(tadaptee.SpatialDefinition as IMultiPoint), "MultiPointWrapper") }; if (tadaptee.SpatialDefinition is ILineString) return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new LineStringWrapper(tadaptee.SpatialDefinition as ILineString), "LineStringWrapper") }; if (tadaptee.SpatialDefinition is ISpatial2DGrid) return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new Spatial2DGridWrapper(tadaptee.SpatialDefinition as ISpatial2DGrid), "Spatial2DGridWrapper") }; if (tadaptee.SpatialDefinition is ISpatialMesh) return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new SpatialMeshWrapper(tadaptee.SpatialDefinition as ISpatialMesh), "SpatialMeshWrapper") }; // Spatial definition is not known, return an empty set. return (new IIdentifiable[0]); }
/// <summary> /// Returns a List of ISpatialDefine with assumed 90deg angles. /// The ISpatialDefine is defined by two coordinates and a layer integer. /// A ISpatialDefine can represent a cuboid, rectangle or a point. /// </summary> /// <param name="elementID"></param> /// <returns></returns> private IDictionary <int, ISpatialDefine> GetModelCoordinates(string elementIDAndGrid) { char[] delimiterChars = { ',' }; string[] words = elementIDAndGrid.Split(delimiterChars); string elementID = words[0].Trim(); IBaseOutput baseOut = base._outputExchangeItems.First(vID => string.Compare(vID.Id, elementID) == 0); // Get the Grid Type from the elementID (delimiated by a ','); GeometryTypes gType = GetGridType(elementID); if (gType == GeometryTypes.Geometry3DSZ) { return(GetModelCoordinates3DSZ(gType, baseOut, elementID)); } if (gType == GeometryTypes.Geometry3DUZ) { return(GetModelCoordinates3DUZ(gType, baseOut, elementID)); } if (gType == GeometryTypes.Geometry2D) { return(GetModelCoordinates2D(gType, baseOut, elementID)); } else { throw new Exception("The Rest not Implemented"); } }
/// <summary> /// Returns the grid type based on the exchangeID. The exchange ID is a string delimiated by a comma. /// The second string after the comma contains the information of the Grid. /// Options include: /// 1) SZ3DGrid used for hydraulic head /// 2) BaseGrid used for land surface variabels (surface temperature, evapotranspiration, ...) /// 3) WMUZ3DGrid used for soil moisture content (in the UZ) /// </summary> /// <param name="exchangeItemId">string deliminated by a comma where the string after the comma contains the grid information.</param> /// <returns>The geometry type of the variable. This is MikeSHE specific</returns> GeometryTypes GetGridType(string exchangeItemId) { IBaseOutput baseOut = base._outputExchangeItems.First(vID => string.Compare(vID.Id, exchangeItemId) == 0); char[] delimiterChars = { ',' }; string[] words = baseOut.Description.Split(delimiterChars); string gridTypewords = words[1].Trim(); if (string.Compare(gridTypewords, "SZ3DGrid", 0) == 0) { return(GeometryTypes.Geometry3DSZ); } else if (string.Compare(gridTypewords, "BaseGrid", 0) == 0) { return(GeometryTypes.Geometry2D); } else if (string.Compare(gridTypewords, "WMUZ3DGrid", 0) == 0) { return(GeometryTypes.Geometry3DUZ); } else { throw new Exception("Other types do exisit (UZ...)"); } }
public IBaseAdaptedOutput CreateChildAdaptor(IBaseOutput adaptee) { var adaptedOutput = new ChildIdentityAdaptor(this, (ITimeSpaceOutput)adaptee); Adaptees.Add(adaptedOutput); return(adaptedOutput); }
public static OutputPort DefaultGetOutputPort(this IBaseOutput outputNode, ref OutputPort outputPort) { return(outputPort ?? (outputPort = new OutputPort() { Node = outputNode as Node })); }
public static IIdentifiable[] GetAvailableMethods(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tsadaptee = adaptee as ITimeSpaceOutput; // Only works with timespace output as adaptee, and element set as spatial definition if (tsadaptee == null || !(tsadaptee.SpatialDefinition is IElementSet)) { return(new IIdentifiable[0]); } IList <IIdentifiable> methods = new List <IIdentifiable>(); GetAvailableOperationMethods(ref methods, tsadaptee.ElementSet().ElementType); // Check if the target is there and is a timespace input ITimeSpaceInput tstarget = target as ITimeSpaceInput; if (target == null || tstarget == null || !(tstarget.SpatialDefinition is IElementSet)) { return(((List <IIdentifiable>)methods).ToArray()); } GetAvailableMappingMethods(ref methods, tsadaptee.ElementSet().ElementType, tstarget.ElementSet().ElementType); return(((List <IIdentifiable>)methods).ToArray()); }
/// <summary> /// Check if a consumer can be added to an output or adapted output. If both the output and the /// new consumer are time space items, the element sets and the time set types are checked. /// </summary> /// <param name="provider">The output item</param> /// <param name="consumer">The new consumer</param> /// <returns>True if the consumer can be added indeed</returns> public static bool ProviderConsumerConnectable(IBaseOutput provider, IBaseInput consumer) { if (provider is ITimeSpaceOutput && consumer is ITimeSpaceInput) { return(ProviderConsumerConnectableForTimeAndElementSet((ITimeSpaceOutput)provider, (ITimeSpaceInput)consumer)); } return(true); }
/// <summary> /// Check if a consumer can be added to an output or adapted output. If both the output and the /// new consumer are time space items, the element sets and the time set types are checked. /// </summary> /// <param name="outputItem">The output item</param> /// <param name="newConsumer">The new consumer</param> /// <returns>True if the consumer can be added indeed</returns> public static bool ConsumersCompatible(IBaseOutput outputItem, IBaseInput newConsumer) { if (outputItem is ITimeSpaceOutput && newConsumer is ITimeSpaceInput) { return(ConsumersCompatibleForTimeAndElementSet((ITimeSpaceOutput)outputItem, (ITimeSpaceInput)newConsumer)); } return(true); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput parentItem, IBaseInput target) { // The time methods in this factory only works on an ITimeSpaceOutput ITimeSpaceOutput tsoutput = parentItem as ITimeSpaceOutput; if (tsoutput == null) return (new IIdentifiable[0]); return new IIdentifiable[] { new TimeInterpolator(tsoutput), new TimeExtrapolator(tsoutput) }; }
/// <summary> /// Check if a new consumer is compatible with existing consumers. Throw an exception if not. /// </summary> /// <param name="outputItem">The output item</param> /// <param name="newConsumer">The new consumer</param> public static void CheckConsumersCompatible(IBaseOutput outputItem, IBaseInput newConsumer) { if (!ConsumersCompatible(outputItem, newConsumer)) { throw new Exception("consumer \"" + newConsumer.Caption + "\" can not be added to \"" + outputItem.Caption + "\", because it is incompatible with existing consumers"); } }
/// <summary> /// Check if a consumer can be added to an output or adapted output. Throw an exception if not. /// </summary> /// <param name="provider">The output item</param> /// <param name="consumer">The new consumer</param> public static void CheckProviderConsumerConnectable(IBaseOutput provider, IBaseInput consumer) { if (!ProviderConsumerConnectable(provider, consumer)) { throw new Exception("consumer \"" + consumer.Caption + "\" and provider \"" + provider.Caption + "\" are not connectable, put an adapted output in between"); } }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput decoratedItem, IBaseInput targetItem) { ITimeSpaceOutput tsoutput = decoratedItem as ITimeSpaceOutput; if (tsoutput == null) { return(new IIdentifiable[0]); } return(new List <IIdentifiable>(_ids.Keys).ToArray()); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { ITimeSpaceAdaptedOutput adaptedOutput = adaptedOutputId as ITimeSpaceAdaptedOutput; if (adaptedOutput == null) { throw new ArgumentException("Adapted output id does no come from this factory", "adaptedOutputId"); } return(adaptedOutput); }
public void RemoveProvider(IBaseOutput provider) { // TODO: Check if provider is valid (must be ITimeSpaceOutput) ITimeSpaceOutput timeSpaceprovider = (ITimeSpaceOutput)provider; _providers.Remove(timeSpaceprovider); if (_providers.Count == 0) { _linkableEngine.ActiveInputItems.Remove(this); } }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { // The time methods in this factory only works on an ITimeSpaceOutput ITimeSpaceOutput tsoutput = adaptee as ITimeSpaceOutput; if (tsoutput == null) { return(new IIdentifiable[0]); } return(new IIdentifiable[] { new AdaptedOutputIdentifier(TimeInterpolatorId), new AdaptedOutputIdentifier(TimeExtrapolatorId) }); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { IBaseAdaptedOutput adaptedOutput = new ElementMapperAdaptedOutput(adaptedOutputId, (ITimeSpaceOutput)adaptee, target.ElementSet()); // Connect adaptor and adaptee if (!adaptee.AdaptedOutputs.Contains(adaptedOutput)) { adaptee.AddAdaptedOutput(adaptedOutput); } return(adaptedOutput); }
public static void ReplaceOutputPort(this IBaseOutput outputNode, ref OutputPort outputPort, OutputPort value) { //if (outputPort != null) //{ // //if (outputPort.Connection != null) // // outputPort.Connection.Start = value; // outputPort.Node = null; // outputPort = null; //} outputPort = value; //if (outputPort != null) outputPort.Node = outputNode as Node; }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput targetItem) { List <IIdentifiable> available = new List <IIdentifiable>(); if (adaptee.ValueDefinition.ValueType == typeof(double) || adaptee.ValueDefinition.ValueType == typeof(double[])) { available.Add(Linear.Identifier); } return(available.ToArray()); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { IBaseAdaptedOutput adaptedOutput = new ElementMapperAdaptedOutput(adaptedOutputId, (ITimeSpaceOutput)adaptee, target.ElementSet()); // Connect adaptor and adaptee if (!adaptee.AdaptedOutputs.Contains(adaptedOutput)) { adaptee.AddAdaptedOutput(adaptedOutput); } return adaptedOutput; }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputIdentifier, IBaseOutput adaptee, IBaseInput target) { IBaseAdaptedOutput adaptor = adaptedOutputIdentifier as IBaseAdaptedOutput; if (adaptor == null) { throw new ArgumentException("Unknown adaptedOutput type - it does not originate from this factory"); } // Connect the adaptor and the adaptee if (!adaptee.AdaptedOutputs.Contains(adaptor)) { adaptee.AddAdaptedOutput(adaptor); } return adaptor; }
public void AddProvider(IBaseOutput provider) { // TODO: Check if provider is valid (must be ITimeSpaceOutput) ITimeSpaceOutput timeSpaceprovider = (ITimeSpaceOutput)provider; if (!_providers.Contains(timeSpaceprovider)) { _providers.Add(timeSpaceprovider); if (_providers.Count == 1) { _linkableEngine.ActiveInputItems.Add(this); } } }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tsadaptee = adaptee as ITimeSpaceOutput; ITimeSpaceInput tstarget = target as ITimeSpaceInput; // This inly works with time space items, and target can not be null if (tsadaptee == null || tstarget == null) return new IIdentifiable[0]; // This only works with element sets if (!(tsadaptee.SpatialDefinition is IElementSet && tstarget.SpatialDefinition is IElementSet)) return new IIdentifiable[0]; return ElementMapper.GetAvailableMethods(tsadaptee.ElementSet().ElementType, tstarget.ElementSet().ElementType); }
private static bool ConsumersCompatibleForTimeAndOrElementSet(IBaseOutput outputItem, IBaseInput consumer, bool doCheckTime, bool doCheckSpace) { // Check which time/space consumers are already there bool canBeAdded = true; if (outputItem.Consumers.Count > 0) { if (doCheckSpace) { // TODO (JG): make instead check on exchangeItem.ElementSet instead of an arbitray elementSet // check if #elements are consistent if (consumer.ElementSet() != null && outputItem.Consumers[0].ElementSet() != null && consumer.ElementSet().ElementCount != outputItem.Consumers[0].ElementSet().ElementCount) { canBeAdded = false; } } if (doCheckTime) { ITimeSpaceInput consumerAsTimeSpace = consumer as ITimeSpaceInput; if (consumerAsTimeSpace != null) { List <ITimeSpaceInput> existingConsumers = new List <ITimeSpaceInput>(); foreach (IBaseInput existingConsumer in outputItem.Consumers) { if (existingConsumer is ITimeSpaceOutput) { existingConsumers.Add((ITimeSpaceInput)existingConsumer); } } if (existingConsumers.Count > 0) { // TODO (JG): Is this a requirement? if (consumerAsTimeSpace.TimeSet != null && existingConsumers[0].TimeSet != null && consumerAsTimeSpace.TimeSet.HasDurations != existingConsumers[0].TimeSet.HasDurations ) { canBeAdded = false; } } } } } return(canBeAdded); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { MultiInputAdaptor multiInputAdaptor = null; if (adaptedOutputId == _identityAdaptor) { // If a MultiInputAdaptor already exists for the target, get that one, otherwise create a new. return(CreateAdaptedOutput(adaptee, target)); } if (multiInputAdaptor == null) { throw new ArgumentException("Adapted output id could not be found", "adaptedOutputId"); } return(multiInputAdaptor); }
public static ITime GetEarliestConsumerTime(IBaseOutput output) { ITime earliestRequiredTime = null; foreach (IBaseAdaptedOutput adaptedOutput in output.AdaptedOutputs) { earliestRequiredTime = CheckTimeHorizonMinimum(earliestRequiredTime, GetEarliestConsumerTime(adaptedOutput)); } foreach (IBaseInput input in output.Consumers) { ITimeSpaceInput timeSpaceInput = input as ITimeSpaceInput; if (timeSpaceInput != null && timeSpaceInput.TimeSet != null) { earliestRequiredTime = CheckTimeHorizonMinimum(earliestRequiredTime, timeSpaceInput.TimeSet.TimeHorizon); } } return(earliestRequiredTime); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tsadaptee = adaptee as ITimeSpaceOutput; ITimeSpaceInput tstarget = target as ITimeSpaceInput; // This inly works with time space items, and target can not be null if (tsadaptee == null || tstarget == null) { return(new IIdentifiable[0]); } // This only works with element sets if (!(tsadaptee.SpatialDefinition is IElementSet && tstarget.SpatialDefinition is IElementSet)) { return(new IIdentifiable[0]); } return(ElementMapper.GetAvailableMethods(tsadaptee.ElementSet().ElementType, tstarget.ElementSet().ElementType)); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { // Target must be this component! if (target == null || target.Component != _component) { return(new IIdentifiable[0]); } // Check for filter if (Filter != null && !Filter(adaptee, target)) { return(new IIdentifiable[0]); } List <IIdentifiable> res = new List <IIdentifiable>(); res.Add(_identityAdaptor); return(res.ToArray()); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tadaptee = adaptee as ITimeSpaceOutput; // Not a time-space exchange item, no available adaptors if (tadaptee == null) { return(new IIdentifiable[0]); } // For each of the spatial extension classes, return its wrapper class // MultiPoint must come before ILineString (because ILineString is currently also an IMultiPoint) if (tadaptee.SpatialDefinition is IMultiPoint) { return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new MultiPointWrapper(tadaptee.SpatialDefinition as IMultiPoint), "MultiPointWrapper") } } ; if (tadaptee.SpatialDefinition is ILineString) { return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new LineStringWrapper(tadaptee.SpatialDefinition as ILineString), "LineStringWrapper") } } ; if (tadaptee.SpatialDefinition is ISpatial2DGrid) { return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new Spatial2DGridWrapper(tadaptee.SpatialDefinition as ISpatial2DGrid), "Spatial2DGridWrapper") } } ; if (tadaptee.SpatialDefinition is ISpatialMesh) { return new IIdentifiable[] { new SpatialExtensionElementSetAdaptor(tadaptee, new SpatialMeshWrapper(tadaptee.SpatialDefinition as ISpatialMesh), "SpatialMeshWrapper") } } ; // Spatial definition is not known, return an empty set. return(new IIdentifiable[0]); }
private static bool ProviderConsumerConnectableForTimeAndOrElementSet(IBaseOutput provider, IBaseInput consumer, bool doCheckTime, bool doCheckSpace) { // Check which time/space consumers are already there if (doCheckSpace) { // check if #elements and elementType are consistent if (consumer.ElementSet() != null && provider.ElementSet() != null ) { if (consumer.ElementSet().ElementCount != provider.ElementSet().ElementCount) { return(false); } if (consumer.ElementSet().ElementType != provider.ElementSet().ElementType&& consumer.ElementSet().ElementCount != 1) { return(false); } } } if (doCheckTime) { ITimeSpaceInput consumerAsTimeSpace = consumer as ITimeSpaceInput; ITimeSpaceInput providerAsTimeSpace = provider as ITimeSpaceInput; if (consumerAsTimeSpace != null && providerAsTimeSpace != null) { if (consumerAsTimeSpace.TimeSet != null && providerAsTimeSpace.TimeSet != null && consumerAsTimeSpace.TimeSet.HasDurations != providerAsTimeSpace.TimeSet.HasDurations) { return(false); } } } return(true); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { if (target.Component != _component) { return(new IIdentifiable[0]); } List <IIdentifiable> res = new List <IIdentifiable>(); // TODO: Implement some criteria here //if (adaptee and target spatialDefintion equals) //{ res.Add(_identityAdaptor); //} //else //{ res.AddRange(_spatialAdaptorFactory.GetAvailableAdaptedOutputIds(adaptee, target)); //} return(res.ToArray()); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { // The time methods in this factory only works on an ITimeSpaceOutput ITimeSpaceOutput tsAdaptee = adaptee as ITimeSpaceOutput; if (tsAdaptee == null) { return(new IIdentifiable[0]); } IIdentifiable[] ids = new IBaseAdaptedOutput[] { new TimeInterpolator(tsAdaptee), new TimeExtrapolator(tsAdaptee), new LinearOperationAdaptedOutput(tsAdaptee) }; for (int i = 0; i < ids.Length; i++) { IBaseAdaptedOutput searchItem = ids[i] as IBaseAdaptedOutput; IBaseAdaptedOutput temp = (from n in outputsCreatedSoFar where searchItem.Id == n.Id && n.Adaptee == searchItem.Adaptee select n).FirstOrDefault(); if (temp == null) { outputsCreatedSoFar.Add(searchItem); } else { ids[i] = temp; } } return(ids); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { // TODO: Some usefull criteria here if (true) { // If a MultiInputAdaptor already exists for the target, get that one, otherwise create a new. MultiInputAdaptor multiInputAdaptor; if (!ExistingMultiInputAdaptors.TryGetValue(target, out multiInputAdaptor)) { multiInputAdaptor = new MultiInputAdaptor("SomeId") { SpatialDefinition = ((ITimeSpaceInput)target).SpatialDefinition }; multiInputAdaptor.AddConsumer(target); ExistingMultiInputAdaptors.Add(target, multiInputAdaptor); } if (adaptedOutputId == _identityAdaptor) { // Identity adaptor IBaseAdaptedOutput adaptedOutput = multiInputAdaptor.CreateChildAdaptor(adaptee); return(adaptedOutput); } else { // ElementMapping adaptor IBaseAdaptedOutput adaptedOutput = _spatialAdaptorFactory.CreateAdaptedOutput(adaptedOutputId, adaptee, target); if (adaptedOutput != null) { multiInputAdaptor.Adaptees.Add((ITimeSpaceOutputAdder)adaptedOutput); return(adaptedOutput); } } } return(null); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputIdentifier, IBaseOutput parentOutput, IBaseInput target) { IBaseAdaptedOutput adaptedOutput = null; if (adaptedOutputIdentifier.Id.Equals(TimeInterpolatorId)) { adaptedOutput = new MeasurementsInterpolator((ITimeSpaceOutput)parentOutput); } else if (adaptedOutputIdentifier.Id.Equals(TimeExtrapolatorId)) { adaptedOutput = new TimeExtrapolator((ITimeSpaceOutput)parentOutput); } if (adaptedOutput == null) { throw new Exception("AdaptedOutput id: " + adaptedOutputIdentifier.Id); } // connect adaptor and adaptee if (!parentOutput.AdaptedOutputs.Contains(adaptedOutput)) { parentOutput.AddAdaptedOutput(adaptedOutput); } return(adaptedOutput); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputIdentifier, IBaseOutput adaptee, IBaseInput target) { IBaseAdaptedOutput adaptor = adaptedOutputIdentifier as IBaseAdaptedOutput; if (adaptor == null) { throw new ArgumentException("Unknown adaptedOutput type - it does not originate from this factory"); } // Connect the adaptor and the adaptee if (!adaptee.AdaptedOutputs.Contains(adaptor)) { adaptee.AddAdaptedOutput(adaptor); } return(adaptor); }
public ValidationSource(IBaseOutput source) : base(source) { _source = source; }
public IBaseAdaptedOutput CreateChildAdaptor(IBaseOutput adaptee) { var adaptedOutput = new ChildIdentityAdaptor(this, (ITimeSpaceOutput)adaptee); Adaptees.Add(adaptedOutput); return (adaptedOutput); }
public IBaseAdaptedOutput CreateAdaptedOutput(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { // TODO: Some usefull criteria here if (true) { // If a MultiInputAdaptor already exists for the target, get that one, otherwise create a new. MultiInputAdaptor multiInputAdaptor; if (!ExistingMultiInputAdaptors.TryGetValue(target, out multiInputAdaptor)) { multiInputAdaptor = new MultiInputAdaptor("SomeId") { SpatialDefinition = ((ITimeSpaceInput)target).SpatialDefinition }; multiInputAdaptor.AddConsumer(target); ExistingMultiInputAdaptors.Add(target, multiInputAdaptor); } if (adaptedOutputId == _identityAdaptor) { // Identity adaptor IBaseAdaptedOutput adaptedOutput = multiInputAdaptor.CreateChildAdaptor(adaptee); return (adaptedOutput); } else { // ElementMapping adaptor IBaseAdaptedOutput adaptedOutput = _spatialAdaptorFactory.CreateAdaptedOutput(adaptedOutputId, adaptee, target); if (adaptedOutput != null) { multiInputAdaptor.Adaptees.Add((ITimeSpaceOutputAdder) adaptedOutput); return (adaptedOutput); } } } return (null); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { if (target.Component != _component) return (new IIdentifiable[0]); List<IIdentifiable> res = new List<IIdentifiable>(); // TODO: Implement some criteria here //if (adaptee and target spatialDefintion equals) //{ res.Add(_identityAdaptor); //} //else //{ res.AddRange(_spatialAdaptorFactory.GetAvailableAdaptedOutputIds(adaptee, target)); //} return (res.ToArray()); }
List<IBaseInput> Consumers(IBaseOutput source) { List<IBaseInput> consumers = new List<IBaseInput>(source.Consumers); AddConsumersRecursive(source, consumers); return consumers; }
void AddConsumersRecursive(IBaseOutput source, List<IBaseInput> consumers) { if (source == null) return; consumers.AddRange(source.Consumers); foreach (IBaseAdaptedOutput adapted in source.AdaptedOutputs) AddConsumersRecursive(adapted, consumers); }