protected override XElement TypedSerialize(VariableExport variableExport, SimModelSerializationContext serializationContext)
{
var speciesNode = base.TypedSerialize(variableExport, serializationContext);
//Export only if NOT allowed (SimModel default for missing attribute is: ALLOWED)
if (!variableExport.NegativeValuesAllowed)
{
speciesNode.AddAttribute(SimModelSchemaConstants.NegativeValuesAllowed, "0");
}
if (variableExport.RHSIds.Count == 0)
{
return(speciesNode);
}
var rhsListNode = speciesNode.AddElement(SerializerRepository.CreateElement(SimModelSchemaConstants.RhsFormulaList));
foreach (var rhsId in variableExport.RHSIds)
{
var rhsNode = rhsListNode.AddElement(SerializerRepository.CreateElement(SimModelSchemaConstants.RhsFormula));
rhsNode.AddAttribute(SimModelSchemaConstants.Id, rhsId.ConvertedTo <string>());
}
return(speciesNode);
}
protected override XElement TypedSerialize(List <T> list, SerializationContext context)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(StringValueFor(list, context));
return(element);
}
protected override XElement TypedSerialize(T[] array, SerializationContext serializationContext)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(array.ToByteString());
return(element);
}
protected override XElement TypedSerialize(string objectToSerialize, TestSerializationContext context)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(objectToSerialize);
return(element);
}
protected override XElement TypedSerialize(T objectToSerialize, SimModelSerializationContext serializationContext)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(objectToSerialize.ConvertedTo <string>());
return(element);
}
private XElement addAsElement <TObject, TProperty>(XElement element, TObject objectToSerialize, Expression <Func <TObject, TProperty> > exp)
{
var memberAccessor = _propertyMapFactory.CreateFor(exp);
var elemNode = element.AddElement(SerializerRepository.CreateElement(memberAccessor.Name));
elemNode.AddAttribute(SimModelSchemaConstants.Id, memberAccessor.ResolveValue(objectToSerialize).ToString());
return(element);
}
private XElement createPointElement(WeightedObservedData weightedObservedData, int i)
{
var element = SerializerRepository.CreateElement(ParameterIdentificationExportSchemaConstants.Point);
var dataColumn = weightedObservedData.ObservedData.FirstDataColumn();
element.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.Time, dataColumn.BaseGrid[i]);
element.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.Value, dataColumn[i]);
element.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.Weight, weightedObservedData.Weights[i]);
return(element);
}
protected override XElement TypedSerialize(ExplicitFormulaExport explicitFormulaExport, SimModelSerializationContext serializationContext)
{
var formulaNode = base.TypedSerialize(explicitFormulaExport, serializationContext);
var equationNode = SerializerRepository.CreateElement(SimModelSchemaConstants.Equation);
equationNode.Value = explicitFormulaExport.Equation;
formulaNode.Add(equationNode);
addReferenceNodeFor(formulaNode, explicitFormulaExport.ReferenceList, SimModelSchemaConstants.ReferenceList, SimModelSchemaConstants.Reference);
return(formulaNode);
}
protected override XElement TypedSerialize(List <T> objectList, SerializationContext serializationContext)
{
var element = SerializerRepository.CreateElement(ElementName);
foreach (var item in objectList)
{
var serializer = SerializerRepository.SerializerFor(item);
element.Add(serializer.Serialize(item, serializationContext));
}
return(element);
}
protected override XElement TypedSerialize(ICache <TKey, TValue> cache, TContext context)
{
var cacheElement = SerializerRepository.CreateElement(ElementName);
foreach (var keyValue in cache.KeyValues)
{
var keyValueElement = SerializerRepository.CreateElement(_keyValueDefaultName);
keyValueElement.Add(SerializerRepository.SerializerFor(keyValue.Key).Serialize(keyValue.Key, context));
keyValueElement.Add(SerializerRepository.SerializerFor(keyValue.Value).Serialize(keyValue.Value, context));
cacheElement.Add(keyValueElement);
}
return(cacheElement);
}
protected override XElement TypedSerialize(FormulaCache formulaCache, SerializationContext serializationContext)
{
var formulaCacheElement = base.TypedSerialize(formulaCache, serializationContext);
var stringMapListElement = SerializerRepository.CreateElement(Constants.Serialization.STRING_MAP_LIST);
foreach (var stringMap in serializationContext.StringMap.KeyValues)
{
var stringMapElement = SerializerRepository.CreateElement(Constants.Serialization.STRING_MAP);
stringMapElement.AddAttribute(Constants.Serialization.Attribute.STRING, stringMap.Key);
stringMapElement.AddAttribute(Constants.Serialization.Attribute.ID, stringMap.Value.ToString());
stringMapListElement.Add(stringMapElement);
}
formulaCacheElement.Add(stringMapListElement);
return(formulaCacheElement);
}
protected virtual XElement TypedSerialize(TObject objectToSerialize, TContext context)
{
var xElement = SerializerRepository.CreateElement(ElementName);
foreach (var xmlMapper in _allXmlMappers)
{
var node = xmlMapper.Serialize(objectToSerialize, context);
if (node == null)
{
continue;
}
xElement.Add(node);
}
return(xElement);
}
protected override XElement TypedSerialize(TableFormulaWithOffsetExport tableFormulaWithOffsetExport, SimModelSerializationContext serializationContext)
{
var formulaNode = base.TypedSerialize(tableFormulaWithOffsetExport, serializationContext);
var tableObjectNode = SerializerRepository.CreateElement(SimModelSchemaConstants.TableObject);
tableObjectNode.AddAttribute(SimModelSchemaConstants.Id, tableFormulaWithOffsetExport.TableObjectId.ConvertedTo <string>());
formulaNode.Add(tableObjectNode);
var offsetObjectNode = SerializerRepository.CreateElement(SimModelSchemaConstants.OffsetObject);
offsetObjectNode.AddAttribute(SimModelSchemaConstants.Id, tableFormulaWithOffsetExport.OffsetObjectId.ConvertedTo <string>());
formulaNode.Add(offsetObjectNode);
return(formulaNode);
}
protected override XElement TypedSerialize(TableFormulaWithXArgumentExport tableFormulaWithXArgumentExport, SimModelSerializationContext serializationContext)
{
var formulaNode = base.TypedSerialize(tableFormulaWithXArgumentExport, serializationContext);
var tableObjectNode = SerializerRepository.CreateElement(SimModelSchemaConstants.TableObject);
tableObjectNode.AddAttribute(SimModelSchemaConstants.Id, tableFormulaWithXArgumentExport.TableObjectId);
formulaNode.Add(tableObjectNode);
var xArgumentObject = SerializerRepository.CreateElement(SimModelSchemaConstants.XArgumentObject);
xArgumentObject.AddAttribute(SimModelSchemaConstants.Id, tableFormulaWithXArgumentExport.XArgumentObjectId);
formulaNode.Add(xArgumentObject);
return(formulaNode);
}
protected override XElement TypedSerialize(TAnalysis populationPivotAnalysis, SerializationContext serializationContext)
{
var element = base.TypedSerialize(populationPivotAnalysis, serializationContext);
var fieldPositionSerializer = SerializerRepository.SerializerFor <PivotPosition>();
var positionListElement = SerializerRepository.CreateElement(CoreConstants.Serialization.PivotPositionList);
element.Add(positionListElement);
foreach (var fieldWithDefinedPosition in populationPivotAnalysis.AllFieldPositions.KeyValues)
{
var positionElement = fieldPositionSerializer.Serialize(fieldWithDefinedPosition.Value, serializationContext);
positionElement.AddAttribute(CoreConstants.Serialization.Attribute.Name, fieldWithDefinedPosition.Key.Name);
positionListElement.Add(positionElement);
}
return(element);
}
protected override XElement TypedSerialize(WeightedObservedData weightedObservedData, ParameterIdentificationExportSerializationContext context)
{
var observedDataElement = base.TypedSerialize(weightedObservedData, context);
var dataColumn = weightedObservedData.ObservedData.FirstDataColumn();
observedDataElement.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.Dimension, dataColumn.Dimension.Name);
observedDataElement.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.MolWeight, dataColumn.DataInfo.MolWeight.GetValueOrDefault(double.NaN));
observedDataElement.AddAttribute(ParameterIdentificationExportSchemaConstants.Attributes.lloq, dataColumn.DataInfo.LLOQ.GetValueOrDefault(float.NaN));
var pointListNode = observedDataElement.AddElement(SerializerRepository.CreateElement(ParameterIdentificationExportSchemaConstants.PointList));
for (int i = 0; i < weightedObservedData.Count; i++)
{
pointListNode.Add(createPointElement(weightedObservedData, i));
}
return(observedDataElement);
}
private void addReferenceNodeFor(XElement formulaNode, IDictionary <string, int> referenceDictionary, string enumerationNodeName, string referenceNodeName)
{
if (referenceDictionary.Count == 0)
{
return;
}
var enumerationNode = SerializerRepository.CreateElement(enumerationNodeName);
foreach (var aliasIdPair in referenceDictionary)
{
var referenceNode = SerializerRepository.CreateElement(referenceNodeName);
referenceNode.AddAttribute(SimModelSchemaConstants.Alias, aliasIdPair.Key);
referenceNode.AddAttribute(SimModelSchemaConstants.Id, aliasIdPair.Value.ConvertedTo <string>());
enumerationNode.Add(referenceNode);
}
formulaNode.Add(enumerationNode);
}
