public void Visit(IUsingFormula usingFormula)
{
replaceInUsingFormula(usingFormula, _rootContainer);
}
protected virtual IFormulaUsablePath CreateRelativePath(IFormulaUsable formulaUsable, IEntity refObject, IUsingFormula editedObject)
{
var path = createRelativePathBase(formulaUsable, refObject);
if (path == null)
{
return(null);
}
path.Replace(Constants.MOLECULE_PROPERTIES, ObjectPathKeywords.MOLECULE);
return(AdjustReferences(formulaUsable, path));
}
/// <summary>
/// Creates the path from entity.
/// </summary>
/// <param name="objectBase">The object base that should be referenced</param>
/// <param name="shouldCreateAbsolutePaths">if set to <c>true</c> should create absolute paths otherwise relative paths are created.</param>
/// <param name="refObject">The object from which the path is created.</param>
/// <param name="editedObject"></param>
/// <returns> the dto Object for the reference</returns>
public virtual ReferenceDTO CreatePathsFromEntity(IObjectBase objectBase, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
var dto = new ReferenceDTO();
if (!objectBase.IsAnImplementationOf <IFormulaUsable>())
{
return(null);
}
var formulaUseable = objectBase.DowncastTo <IFormulaUsable>();
if (isGlobal(objectBase))
{
// This a global parameters that we always use as absolute paths
dto.Path = CreateAlwaysAbsolutePaths(objectBase, formulaUseable);
}
else
{
// local reaction and molecule properties are always referenced local.
if (formulaUseable.IsAtReaction() || formulaUseable.IsAtMolecule())
{
shouldCreateAbsolutePaths = false;
}
dto.Path = shouldCreateAbsolutePaths
? CreateAbsolutePath(formulaUseable)
: CreateRelativePath(formulaUseable, refObject, editedObject);
}
var parameter = formulaUseable as IParameter;
if (parameter == null)
{
return(dto);
}
dto.BuildMode = parameter.BuildMode;
updateReferenceForTransportMoleculeContainer(dto, parameter, shouldCreateAbsolutePaths);
return(dto);
}
/// <summary>
/// Creates the path from parameter dummy.
/// </summary>
/// <param name="objectBaseDTO">The dummy parameter dto.</param>
/// <param name="shouldCreateAbsolutePaths">if set to <c>true</c> creates absolute paths otherwise creates reltive paths.</param>
/// <param name="refObject">
/// The reference object the user chosen (may the concrete object that uses the reference or a
/// existing parent of it).
/// </param>
/// <param name="editedObject"></param>
/// <returns> The path that could be uses in the model to reference the object</returns>
public virtual ReferenceDTO CreatePathFromParameterDummy(IObjectBaseDTO objectBaseDTO, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
if (IsMoleculeReference(objectBaseDTO))
{
return(createMoleculeReference());
}
var dtoDummyParameter = (DummyParameterDTO)objectBaseDTO;
var parameterToUse = _context.Get <IParameter>(dtoDummyParameter.ParameterToUse.Id);
ReferenceDTO dtoReference;
if (parameterToUse.IsAtMolecule())
{
dtoReference = new ReferenceDTO();
IObjectPath tmpPath;
//global molecule parameters we always reference absolute
if (shouldCreateAbsolutePaths || !parameterToUse.BuildMode.Equals(ParameterBuildMode.Local))
{
tmpPath = _objectPathFactory.CreateAbsoluteObjectPath(dtoDummyParameter.Parent);
}
else
{
if (refObject != dtoDummyParameter.Parent)
{
tmpPath = _objectPathFactory.CreateRelativeObjectPath(refObject, dtoDummyParameter.Parent);
}
else
{
tmpPath = new ObjectPath();
}
tmpPath = AdjustReferences(parameterToUse, tmpPath);
}
dtoReference.Path = _objectPathFactory.CreateFormulaUsablePathFrom(tmpPath)
.WithAlias(_aliasCreator.CreateAliasFrom(parameterToUse.Name))
.WithDimension(parameterToUse.Dimension);
dtoReference.Path.Add(parameterToUse.Name);
}
else
{
dtoReference = CreatePathsFromEntity(parameterToUse, shouldCreateAbsolutePaths, refObject, editedObject);
}
dtoReference.Path.Replace(Constants.MOLECULE_PROPERTIES, dtoDummyParameter.ModelParentName);
dtoReference.BuildMode = parameterToUse.BuildMode;
return(dtoReference);
}
