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); }