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(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 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 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(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);
}
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);
}
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(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 <string, DataRepository> objectToSerialize, SerializationContext serializationContext)
{
var serializer = SerializerRepository.SerializerFor(typeof(DataRepository));
var xel = new XElement("repositories");
foreach (var dataRepository in objectToSerialize)
{
xel.AddElement(serializer.Serialize(dataRepository, serializationContext));
}
return(xel);
}
protected override void TypedDeserialize(TAnalysis populationPivotAnalysis, XElement element, SerializationContext serializationContext)
{
base.TypedDeserialize(populationPivotAnalysis, element, serializationContext);
var fieldPositionSerializer = SerializerRepository.SerializerFor <PivotPosition>();
foreach (var positionElement in element.Descendants(CoreConstants.Serialization.PivotPositionList).Descendants())
{
var position = fieldPositionSerializer.Deserialize <PivotPosition>(positionElement, serializationContext);
var fieldName = positionElement.GetAttribute(CoreConstants.Serialization.Attribute.Name);
populationPivotAnalysis.SetPosition(fieldName, position);
}
}
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(Cache <TKey, TValue> cache, SerializationContext serializationContext)
{
var element = base.TypedSerialize(cache, serializationContext);
var keyListSerializer = SerializerRepository.SerializerFor <List <TKey> >();
var valueListSerializer = SerializerRepository.SerializerFor <List <TValue> >();
var keysElement = keyListSerializer.Serialize(cache.Keys.ToList(), serializationContext);
keysElement.Name = Constants.Serialization.KEYS;
var valuesElement = valueListSerializer.Serialize(cache.ToList(), serializationContext);
valuesElement.Name = Constants.Serialization.VALUES;
element.Add(keysElement);
element.Add(valuesElement);
return(element);
}
protected override void TypedDeserialize(Cache <TKey, TValue> cache, XElement element, SerializationContext serializationContext)
{
base.TypedDeserialize(cache, element, serializationContext);
var keysElement = element.Element(Constants.Serialization.KEYS);
var valuesElement = element.Element(Constants.Serialization.VALUES);
var keyListSerializer = SerializerRepository.SerializerFor <List <TKey> >();
var valueListSerializer = SerializerRepository.SerializerFor <List <TValue> >();
var keys = keyListSerializer.Deserialize <List <TKey> >(keysElement, serializationContext);
var values = valueListSerializer.Deserialize <List <TValue> >(valuesElement, serializationContext);
for (int i = 0; i < keys.Count; i++)
{
cache.Add(keys[i], values[i]);
}
}
protected override void TypedDeserialize(ParameterValues parameterValues, XElement element, SerializationContext serializationContext)
{
base.TypedDeserialize(parameterValues, element, serializationContext);
var percentilesElements = element.Element(CoreConstants.Serialization.Percentiles);
if (element.Element(CoreConstants.Serialization.Percentiles) != null)
{
var percentileSerializer = SerializerRepository.SerializerFor <List <double> >();
parameterValues.Percentiles = percentileSerializer.Deserialize <List <double> >(percentilesElements, serializationContext);
}
else
{
parameterValues.Percentiles = new double[parameterValues.Count].InitializeWith(CoreConstants.DEFAULT_PERCENTILE).ToList();
}
}
protected override XElement TypedSerialize(ParameterValues parameterValues, SerializationContext serializationContext)
{
var element = base.TypedSerialize(parameterValues, serializationContext);
var allPercentiles = parameterValues.Percentiles.Distinct().ToList();
if (allPercentiles.Count == 1 && allPercentiles[0] == CoreConstants.DEFAULT_PERCENTILE)
{
return(element);
}
var doubleSerializer = SerializerRepository.SerializerFor(parameterValues.Percentiles);
element.Add(doubleSerializer.Serialize(parameterValues.Percentiles, serializationContext));
return(element);
}
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 void TypedDeserialize(ICache <TKey, TValue> cache, XElement cacheElement, TContext context)
{
foreach (XElement keyValueElement in cacheElement.Elements(KeyValueNode))
{
//not right format
if (keyValueElement.Elements().Count() < 2)
{
continue;
}
var keyNode = keyValueElement.Elements().ElementAt(0);
var valueNode = keyValueElement.Elements().ElementAt(1);
var key = SerializerRepository.SerializerFor(keyNode).Deserialize <TKey>(keyNode, context);
var value = SerializerRepository.SerializerFor(valueNode).Deserialize <TValue>(valueNode, context);
cache.Add(key, value);
}
}
protected override XElement TypedSerialize(MoBiSimulation simulation, SerializationContext serializationContext)
{
var xElement = base.TypedSerialize(simulation, serializationContext);
var chartSerializer = SerializerRepository.SerializerFor <CurveChart>();
var diagramSerializer = serializationContext.Resolve <IDiagramModelToXmlMapper>();
if (simulation.DiagramModel != null)
{
xElement.Add(diagramSerializer.DiagramModelToXmlDocument(simulation.DiagramModel).ToXElement());
}
if (simulation.Chart != null)
{
xElement.Add(chartSerializer.Serialize(simulation.Chart, serializationContext));
}
return(xElement);
}
