public void ReloadWithPKSimSettings()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _modelingXmlSerializerRepository.SerializerFor <ImporterConfiguration>();
var fileName = _dialogCreator.AskForFileToOpen("Save configuration", "xml files (*.xml)|*.xml|All files (*.*)|*.*",
Constants.DirectoryKey.PROJECT);
if (fileName.IsNullOrEmpty())
{
return;
}
var xel = XElement.Load(fileName); // We have to correctly handle the case of cancellation
var configuration = serializer.Deserialize <ImporterConfiguration>(xel, serializationContext);
dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = "Molecule";
dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = "Molecular Weight";
_dialogCreator.MessageBoxInfo(_dataImporter.ImportFromConfiguration
(
configuration,
_dataImporter.DefaultMetaDataCategoriesForObservedData(),
_dataImporter.ColumnInfosForObservedData(),
dataImporterSettings,
_dialogCreator.AskForFileToOpen(Captions.Importer.OpenFile, Captions.Importer.ImportFileFilter, Constants.DirectoryKey.OBSERVED_DATA)
)?.Count() + " data sets successfully imported");
}
}
public CurveChartTemplate Deserialize(XElement element)
{
using (var serializationContext = SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, _withIdRepository))
{
var chartTemplateSerializer = _modellingXmlSerializerRepository.SerializerFor(element);
return(chartTemplateSerializer.Deserialize <CurveChartTemplate>(element, serializationContext));
}
}
private XElement serializeModelPart <T>(T entityToSerialize, SerializationContext serializationContext)
{
var partSerializer = _serializerRepository.SerializerFor(entityToSerialize);
var xElement = partSerializer.Serialize(entityToSerialize, serializationContext);
if (needsFormulaCacheSerialization(entityToSerialize))
{
var xElementFormulas = serializeFormulas(serializationContext.Formulas, serializationContext);
xElement.Add(xElementFormulas);
}
return(xElement);
}
public byte[] Serialize <TObject>(TObject objectToSerialize)
{
if (typeof(TObject) != typeof(IDiagramModel))
{
return(new byte[0]);
}
var serializer = _modelingXmlSerializerRepository.SerializerFor <IDiagramModel>();
using (var serializationContext = SerializationTransaction.Create())
return(_compress.Compress(XmlHelper.XmlContentToByte(serializer.Serialize(objectToSerialize, serializationContext))));
}
public T Load <T>(string pkmlFileFullPath,
IDimensionFactory dimensionFactory = null,
IObjectBaseFactory objectBaseFactory = null,
IWithIdRepository withIdRepository = null,
ICloneManagerForModel cloneManagerForModel = null) where T : class
{
T loadedObject;
int version;
using (var serializationContext = SerializationTransaction.Create(
_container,
dimensionFactory ?? _dimensionFactory,
objectBaseFactory ?? _objectBaseFactory,
withIdRepository ?? new WithIdRepository(),
cloneManagerForModel ?? _cloneManagerForModel))
{
var element = XElement.Load(pkmlFileFullPath);
version = element.GetPKMLVersion();
convertXml(element, version);
var serializer = _serializerRepository.SerializerFor <T>();
if (!string.Equals(serializer.ElementName, element.Name.LocalName))
{
throw new OSPSuiteException(Error.CouldNotLoadObjectFromFile(pkmlFileFullPath, serializer.ElementName));
}
loadedObject = serializer.Deserialize <T>(element, serializationContext);
}
resolveReferenceIfRequired(loadedObject);
convert(loadedObject, version, x => x.Convert);
return(loadedObject);
}
public ObserverLoader(
IOSPSuiteXmlSerializerRepository modellingXmlSerializerRepository,
IObjectConverterFinder objectConverterFinder,
IDimensionFactory dimensionFactory,
IObjectBaseFactory objectBaseFactory,
ICloneManagerForModel cloneManagerForModel
)
{
_objectConverterFinder = objectConverterFinder;
_dimensionFactory = dimensionFactory;
_objectBaseFactory = objectBaseFactory;
_cloneManagerForModel = cloneManagerForModel;
_modellingXmlSerializerRepository = modellingXmlSerializerRepository;
_containerObserverSerializer = modellingXmlSerializerRepository.SerializerFor <ContainerObserverBuilder>();
_amountObserverSerializer = modellingXmlSerializerRepository.SerializerFor <AmountObserverBuilder>();
}
public void Load(IPKParameterRepository pkParameterMetaDataRepository, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_dimensionFactory))
{
var serializer = _modellingXmlSerializerRepository.SerializerFor(pkParameterMetaDataRepository);
var xel = XElement.Load(fileName);
serializer.Deserialize(pkParameterMetaDataRepository, xel, serializationContext);
}
}
public void Save(SimulationTransfer simulationTransfer, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _xmlSerializerRepository.SerializerFor(simulationTransfer);
var element = serializer.Serialize(simulationTransfer, serializationContext);
element.Save(fileName);
}
}
public ImporterConfiguration OpenXmlConfiguration()
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _modelingXmlSerializerRepository.SerializerFor <ImporterConfiguration>();
var fileName = _dialogCreator.AskForFileToOpen("Open configuration", "xml files (*.xml)|*.xml|All files (*.*)|*.*", //move to constants and use filter
Constants.DirectoryKey.PROJECT);
if (fileName.IsNullOrEmpty())
{
return(null);
}
var xel = XElement.Load(fileName); // We have to correctly handle the case of cancellation
return(serializer.Deserialize <ImporterConfiguration>(xel, serializationContext));
}
}
public virtual XElement Serialize <T>(T obj, SerializationContext serializationContext)
{
var serializer = _serializerRepository.SerializerFor(obj);
return(serializer.Serialize(obj, serializationContext));
}
