protected override void TypedDeserialize(TBuildingBlock bb, XElement element, SerializationContext serializationContext)
{
var formulaCache = SerializerRepository.DeserializeFormulaCacheIn(element, serializationContext);
base.TypedDeserialize(bb, element, serializationContext);
formulaCache.Each(bb.AddFormula);
}
protected override void TypedDeserialize(MoBiSimulation simulation, XElement outputToDeserialize, SerializationContext serializationContext)
{
base.TypedDeserialize(simulation, outputToDeserialize, serializationContext);
if (simulation.Results != null)
{
serializationContext.AddRepository(simulation.Results);
}
var chartSerializer = SerializerRepository.SerializerFor <CurveChart>();
var chartElement = outputToDeserialize.Element(chartSerializer.ElementName);
if (chartElement != null)
{
simulation.Chart = chartSerializer.Deserialize <CurveChart>(outputToDeserialize.Element(chartSerializer.ElementName), serializationContext);
}
var diagramSerializer = serializationContext.Resolve <IDiagramModelToXmlMapper>();
var diagramElement = outputToDeserialize.Element(diagramSerializer.ElementName);
if (diagramElement != null)
{
simulation.DiagramModel = diagramSerializer.XmlDocumentToDiagramModel(diagramElement.ToXmlDocument());
}
}
protected override XElement TypedSerialize(T objectToSerialize, SimModelSerializationContext serializationContext)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(objectToSerialize.ConvertedTo <string>());
return(element);
}
public void Can_replace_default_string_bytearray_serializer()
{
var custom = new CustomStringSerializer();
SerializerRepository.RegisterByteArraySerializer(custom);
Assert.AreEqual(custom, SerializerRepository.GetByteArraySerializer <string>());
}
protected override XElement TypedSerialize(string objectToSerialize, TestSerializationContext context)
{
var element = SerializerRepository.CreateElement(ElementName);
element.SetValue(objectToSerialize);
return(element);
}
public void Can_replace_default_string_stream_serializer()
{
var custom = new CustomStringSerializer();
SerializerRepository.RegisterStreamSerializer(custom);
Assert.AreEqual(custom, SerializerRepository.GetStreamSerializer <string>());
}
protected override XElement TypedSerialize(Model model, SerializationContext serializationContext)
{
var element = base.TypedSerialize(model, serializationContext);
SerializerRepository.AddFormulaCacheElement(element, serializationContext);
return(element);
}
protected override XElement TypedSerialize(IndividualSimulationComparison chart, SerializationContext serializationContext)
{
var element = base.TypedSerialize(chart, serializationContext);
element.Add(SerializerRepository.CreateSimulationReferenceListElement(chart));
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(ObservedDataCollection observedDataCollection, SerializationContext serializationContext)
{
var element = base.TypedSerialize(observedDataCollection, serializationContext);
element.Add(SerializerRepository.CreateObservedDataReferenceListElement(observedDataCollection));
return(element);
}
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(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);
}
public void Can_register_custom_stream_serializer()
{
var custom = new CustomSerializer();
SerializerRepository.RegisterStreamSerializer(custom);
Assert.AreEqual(custom, SerializerRepository.GetStreamSerializer <TypeToSerialize>());
}
protected override XElement TypedSerialize(T buildingBlock, SerializationContext serializationContext)
{
var element = base.TypedSerialize(buildingBlock, serializationContext);
SerializerRepository.AddFormulaCacheElement(element, serializationContext);
return(element);
}
public void Can_register_custom_bytearray_serializer()
{
var custom = new CustomSerializer();
SerializerRepository.RegisterByteArraySerializer(custom);
Assert.AreEqual(custom, SerializerRepository.GetByteArraySerializer <TypeToSerialize>());
}
protected override void TypedDeserialize(List <T> objectList, XElement element, SerializationContext serializationContext)
{
foreach (var childElement in element.Elements())
{
var serializer = SerializerRepository.SerializerFor(childElement);
objectList.Add(serializer.Deserialize <T>(childElement, serializationContext));
}
}
protected override XElement TypedSerialize(TChart chart, SerializationContext serializationContext)
{
var chartSerializer = SerializerRepository.SerializerFor <CurveChart>();
var chartElement = base.TypedSerialize(chart, serializationContext);
chartElement.Add(chartSerializer.Serialize(chart, serializationContext));
return(chartElement);
}
protected override XElement TypedSerialize(TBuildingBlock bb, SerializationContext serializationContext)
{
serializationContext.AddFormulasToCache(bb.FormulaCache);
var element = base.TypedSerialize(bb, serializationContext);
SerializerRepository.AddFormulaCacheElement(element, serializationContext);
return(element);
}
public void Can_replace_default_serializer_generator()
{
SerializerRepository.SerializerGenerator = new CustomGenerator();
Assert.IsTrue(SerializerRepository.HasByteArraySerializer <TypeToSerialize>());
Assert.IsTrue(SerializerRepository.HasStreamSerializer <TypeToSerialize>());
Assert.AreEqual(typeof(CustomSerializer), SerializerRepository.GetByteArraySerializer <TypeToSerialize>().GetType());
Assert.AreEqual(typeof(CustomSerializer), SerializerRepository.GetStreamSerializer <TypeToSerialize>().GetType());
}
protected override XElement TypedSerialize(ParameterIdentification parameterIdentification, SerializationContext context)
{
var element = base.TypedSerialize(parameterIdentification, context);
element.Add(SerializerRepository.CreateSimulationReferenceListElement(parameterIdentification));
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);
}
protected override void TypedDeserialize(UsedBuildingBlock usedBuildingBlock, XElement usedBuildingBlockNode, SerializationContext context)
{
base.TypedDeserialize(usedBuildingBlock, usedBuildingBlockNode, context);
var buildingBlockNode = usedBuildingBlockNode.Elements().First();
var serializer = SerializerRepository.SerializerFor(buildingBlockNode);
usedBuildingBlock.BuildingBlock = serializer.Deserialize <IPKSimBuildingBlock>(buildingBlockNode, context);
}
protected override XElement TypedSerialize(UsedBuildingBlock usedBuildingBlock, SerializationContext context)
{
var usedBuildingBlockNode = base.TypedSerialize(usedBuildingBlock, context);
var serializer = SerializerRepository.SerializerFor(usedBuildingBlock.BuildingBlock);
usedBuildingBlockNode.Add(serializer.Serialize(usedBuildingBlock.BuildingBlock, context));
return(usedBuildingBlockNode);
}
private void RoundTripStream <T>(T value)
{
var serializer = SerializerRepository.GetStreamSerializer <T>();
var ms = new MemoryStream();
serializer.Serialize(ms, value);
ms.Position = 0;
Assert.AreEqual(value, serializer.Deserialize(ms));
}
protected override void TypedDeserialize(TChart chart, XElement chartElement, SerializationContext serializationContext)
{
var chartSerializer = SerializerRepository.SerializerFor <CurveChart>();
base.TypedDeserialize(chart, chartElement, serializationContext);
var dataChartElement = chartElement.Element(chartSerializer.ElementName);
chartSerializer.Deserialize(chart, dataChartElement, serializationContext);
}
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(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(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 void TypedDeserialize(ICache <string, DataRepository> objectToDeserialize, XElement xel, SerializationContext serializationContext)
{
var serializer = SerializerRepository.SerializerFor(typeof(DataRepository));
foreach (var subXel in xel.Elements())
{
var dataRepository = new DataRepository();
serializer.Deserialize(dataRepository, subXel, serializationContext);
objectToDeserialize.Add(dataRepository);
}
}
protected override XElement TypedSerialize(PopulationSimulationComparison comparison, SerializationContext context)
{
var element = base.TypedSerialize(comparison, context);
element.Add(SerializerRepository.CreateSimulationReferenceListElement(comparison));
if (comparison.HasReference)
{
element.AddAttribute(CoreConstants.Serialization.Attribute.ReferenceSimulation, comparison.ReferenceSimulation.Id);
}
return(element);
}
