public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, IBuildConfiguration buildConfiguration)
{
//molecule amount always in amount
var moleculeAmount = _objectBaseFactory.Create <IMoleculeAmount>()
.WithName(moleculeBuilder.Name)
.WithDescription(moleculeBuilder.Description)
.WithContainerType(ContainerType.Molecule)
.WithIcon(moleculeBuilder.Icon)
.WithQuantityType(moleculeBuilder.QuantityType)
.WithDimension(_amountDimension)
.WithDisplayUnit(_amountDimension.UnitOrDefault(_amountDimension.DefaultUnit.Name));
buildConfiguration.AddBuilderReference(moleculeAmount, moleculeBuilder);
createMoleculeAmountDefaultFormula(moleculeBuilder, buildConfiguration, moleculeAmount);
//map parameters. Only parameters having BuildMode="Local" will
//be added to the molecule amount. Global/Property-Parameters
//will be filled in elsewhere (by the GlobalProperties-Mapper)
var allLocalParameters = moleculeBuilder.Parameters
.Where(x => x.BuildMode == ParameterBuildMode.Local)
.Where(x => x.ContainerCriteria?.IsSatisfiedBy(targetContainer) ?? true);
allLocalParameters.Each(x => moleculeAmount.Add(_parameterMapper.MapFrom(x, buildConfiguration)));
_keywordReplacerTask.ReplaceIn(moleculeAmount);
return(moleculeAmount);
}
private void addHelpParametersFor(ICoreCalculationMethod calculationMethod, IList <IMoleculeBuilder> allMoleculesUsingMethod)
{
foreach (var helpParameter in calculationMethod.AllHelpParameters())
{
var containerDescriptor = calculationMethod.DescriptorFor(helpParameter);
foreach (var molecule in allMoleculesUsingMethod)
{
foreach (var container in allMoleculeContainersFor(containerDescriptor, molecule))
{
var exisitingParameter = container.GetSingleChildByName <IParameter>(helpParameter.Name);
//does not exist yet
if (exisitingParameter == null)
{
var parameter = _parameterMapper.MapFrom(helpParameter, _buildConfiguration);
container.Add(parameter);
replaceKeyWordsIn(parameter, molecule.Name);
}
else if (!formulasAreTheSameForParameter(exisitingParameter, helpParameter.Formula, molecule.Name))
{
throw new OSPSuiteException(Error.HelpParameterAlreadyDefinedWithAnotherFormula(calculationMethod.Name, _objectPathFactory.CreateAbsoluteObjectPath(helpParameter).ToString()));
}
}
}
}
}
private void createEventGroupStructure(IEventGroupBuilder eventGroupBuilder, IEventGroup eventGroup, IBuildConfiguration buildConfiguration)
{
foreach (var childBuilder in eventGroupBuilder.Children)
{
//nothing to do for these entities that should not be copied in the model structure
if (doesNotBelongIntoModel(childBuilder))
{
continue;
}
if (childBuilder.IsAnImplementationOf <IEventGroupBuilder>())
{
var childEventGroup = MapFrom(childBuilder.DowncastTo <IEventGroupBuilder>(), buildConfiguration);
eventGroup.Add(childEventGroup);
if (childBuilder.IsAnImplementationOf <IApplicationBuilder>())
{
createApplication(childBuilder.DowncastTo <IApplicationBuilder>(), childEventGroup, buildConfiguration);
}
}
else if (childBuilder.IsAnImplementationOf <IEventBuilder>())
{
eventGroup.Add(_eventMapper.MapFrom(childBuilder.DowncastTo <IEventBuilder>(), buildConfiguration));
}
else if (childBuilder.IsAnImplementationOf <IParameter>())
{
eventGroup.Add(_parameterMapper.MapFrom(childBuilder.DowncastTo <IParameter>(), buildConfiguration));
}
else if (childBuilder.IsAnImplementationOf <IContainer>())
{
eventGroup.Add(_containerMapper.MapFrom(childBuilder.DowncastTo <IContainer>(), buildConfiguration));
}
else
{
eventGroup.Add(_cloneManagerForModel.Clone(childBuilder));
}
}
}
public INeighborhood MapFrom(INeighborhoodBuilder neighborhoodBuilder, IModel model,
IBuildConfiguration buildConfiguration,
IEnumerable <string> moleculeNames,
IEnumerable <string> moleculeNamesWithCopyPropertiesRequired)
{
var neighborhood = _objectBaseFactory.Create <INeighborhood>();
neighborhood.UpdatePropertiesFrom(neighborhoodBuilder, _cloneManagerForModel);
buildConfiguration.AddBuilderReference(neighborhood, neighborhoodBuilder);
neighborhood.FirstNeighbor = resolveReference(model, neighborhoodBuilder.FirstNeighbor);
neighborhood.SecondNeighbor = resolveReference(model, neighborhoodBuilder.SecondNeighbor);
if (neighborhoodBuilder.MoleculeProperties != null)
{
moleculeNames.Each(moleculeName => neighborhood.Add(
createMoleculePropertiesFor(neighborhoodBuilder, moleculeName, model.Root, buildConfiguration, moleculeNamesWithCopyPropertiesRequired)));
}
//Add neighorhood parameter to the neighborhood (clone the existing parmeter)
neighborhoodBuilder.Parameters.Each(param => neighborhood.Add(_parameterMapper.MapFrom(param, buildConfiguration)));
return(neighborhood);
}
public IEvent MapFrom(IEventBuilder eventBuilder, IBuildConfiguration buildConfiguration)
{
var modelEvent = _objectBaseFactory.Create <IEvent>()
.WithName(eventBuilder.Name)
.WithDimension(eventBuilder.Dimension)
.WithDescription(eventBuilder.Description)
.WithFormula(_formulaMapper.MapFrom(eventBuilder.Formula, buildConfiguration));
buildConfiguration.AddBuilderReference(modelEvent, eventBuilder);
eventBuilder.Assignments
.SelectMany(x => _assignmentMapper.MapFrom(x, buildConfiguration))
.Each(modelEvent.AddAssignment);
foreach (var param in eventBuilder.Parameters)
{
modelEvent.Add(_parameterMapper.MapFrom(param, buildConfiguration));
}
modelEvent.OneTime = eventBuilder.OneTime;
return(modelEvent);
}
public IEnumerable <IParameter> MapFrom(IEnumerable <IParameter> parameterBuilders, IBuildConfiguration buildConfiguration, params ParameterBuildMode[] parameterBuildModesToMap)
{
return(parameterBuilders.Where(p => canBeMapped(p, parameterBuildModesToMap))
.Select(parameterBuilder => _parameterMapper.MapFrom(parameterBuilder, buildConfiguration)).ToList());
}
