protected override void Context() { sut = new ObjectPathXmlAttributeMapper(); _container = A.Fake <IContainer>(); A.CallTo(() => _container.Resolve <IObjectPathFactory>()).Returns(new ObjectPathFactoryForSpecs()); _serializationContext = SerializationTransaction.Create(_container); }
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 void Convert(XElement element) { foreach (var parameterCacheElement in element.Descendants("ParameterValuesCache").ToList()) { var parameterValuesCache = new ParameterValuesCache(); foreach (var dataColumnNode in parameterCacheElement.Descendants(ConverterConstants.Serialization.DATA_TABLE_COLUMN)) { var parameterValues = new ParameterValues(dataColumnNode.GetAttribute(CoreConstants.Serialization.Attribute.Name)); parameterValuesCache.Add(parameterValues); } var documentElement = parameterCacheElement.Descendants("DocumentElement").First(); foreach (var parameterValuesElement in documentElement.Descendants("ParameterValues")) { int index = 0; foreach (var parameterValue in parameterValuesElement.Descendants()) { var parameterValues = parameterValuesCache.ParameterValuesAt(index); parameterValues.Add(parameterValue.Value.ConvertedTo <double>()); index++; } } var writer = _container.Resolve <IXmlWriter <ParameterValuesCache> >(); var newElement = writer.WriteFor(parameterValuesCache, SerializationTransaction.Create()); var parent = parameterCacheElement.Parent; parameterCacheElement.Remove(); parent.Add(newElement); } }
public override void GlobalContext() { base.GlobalContext(); _unitSystemXmlRepository = new UnitSystemXmlSerializerRepository(); _unitSystemXmlRepository.PerformMapping(); _serializationContext = SerializationTransaction.Create(); }
protected SerializationContext NewDeserializationContext() { var objectBaseFactory = IoC.Resolve <IObjectBaseFactory>(); var dimensionFactory = IoC.Resolve <IDimensionFactory>(); return(SerializationTransaction.Create(dimensionFactory, objectBaseFactory, new WithIdRepository(), new CloneManagerForModel(objectBaseFactory, new DataRepositoryTask(), new ModelFinalizer(new ObjectPathFactory(new AliasCreator()), new ReferencesResolver())), new List <DataRepository>())); }
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); }
private void loadDimensionsFromFile() { var serializer = _unitSystemXmlSerializerRepository.SerializerFor(_dimensionFactory); var xel = XElement.Load(_pkSimConfiguration.DimensionFilePath); serializer.Deserialize(_dimensionFactory, xel, SerializationTransaction.Create()); }
public virtual string ToString <T>(T obj) { using (var serializationContext = SerializationTransaction.Create(_container)) { return(Serialize(obj, serializationContext).ToString()); } }
private void convertIndividualSimulation(XElement individualSimulationElement) { //this value is not always available var aucIV = individualSimulationElement.GetAttribute("aucIV"); if (string.IsNullOrEmpty(aucIV)) { return; } var allCompoundPKElement = new XElement("AllCompoundPK"); individualSimulationElement.Add(allCompoundPKElement); var aucIVValue = aucIV.ConvertedTo <double>(); //Add existing value to cache with a dummy compound name that will be replaced with the real compound name once the object //are loaded var compoundPK = new CompoundPK { CompoundName = DUMMY_COMPOUND_NAME, AucIV = aucIVValue }; var compoundPKSerializer = _serializerRepository.SerializerFor(compoundPK); var compoundPKElement = compoundPKSerializer.Serialize(compoundPK, SerializationTransaction.Create()); allCompoundPKElement.Add(compoundPKElement); }
private void convertProject(IProject project) { if (!_projectObservedDataElementCache.Any()) { return; } var serializerRepository = _container.Resolve <IPKSimXmlSerializerRepository>(); var serializer = serializerRepository.SerializerFor <DataRepository>(); using (var serializationContext = SerializationTransaction.Create(dimensionFactory: _dimensionFactory, withIdRepository: new WithIdRepository())) { var context = serializationContext; _projectObservedDataElementCache.Each(e => { _observedDataConvertor.ConvertDimensionIn(e); project.AddObservedData(serializer.Deserialize <DataRepository>(e, context)); }); } _projectObservedDataElementCache.Clear(); project.AllObservedData.Each(x => _observedDataConvertor.Convert(project, x, _originalVersion)); _converted = true; }
public SerializationContext Create(IEnumerable <DataRepository> dataRepositories = null, IEnumerable <IWithId> externalReferences = null) { var projectRetriever = _container.Resolve <IPKSimProjectRetriever>(); var project = projectRetriever.Current; //do not use the pksim repository since we need to register the deserialized object afterwards //this repository is only used to resolve the references var withIdRepository = new WithIdRepository(); externalReferences?.Each(withIdRepository.Register); var allRepositories = new List <DataRepository>(); if (project != null) { allRepositories.AddRange(project.All <IndividualSimulation>() .Where(s => s.HasResults) .Select(s => s.DataRepository) .Union(project.AllObservedData)); } if (dataRepositories != null) { allRepositories.AddRange(dataRepositories); } allRepositories.Each(withIdRepository.Register); return(SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, withIdRepository, _cloneManagerForModel, allRepositories)); }
public virtual void Save <T>(T obj, string fileName) { using (var serializationContext = SerializationTransaction.Create(_container)) { var xel = Serialize(obj, serializationContext); xel.Save(fileName); } }
public virtual T Load <T>(string fileName, IDimensionFactory dimensionFactory = null, IEnumerable <DataRepository> dataRepositories = null) { using (var serializationContext = SerializationTransaction.Create(_container, dimensionFactory, dataRepositories: dataRepositories)) { var xel = XElement.Load(fileName); return(Deserialize <T>(xel, serializationContext)); } }
public CurveChartTemplate Deserialize(XElement element) { using (var serializationContext = SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, _withIdRepository)) { var chartTemplateSerializer = _modellingXmlSerializerRepository.SerializerFor(element); return(chartTemplateSerializer.Deserialize <CurveChartTemplate>(element, serializationContext)); } }
public XElement Serialize(CurveChartTemplate chartTemplate) { using (var serializationContext = SerializationTransaction.Create()) { var chartSerializer = _modellingXmlSerializerRepository.SerializerFor(chartTemplate); return(chartSerializer.Serialize(chartTemplate, serializationContext)); } }
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 virtual void Load(T objectToLoad, string fileName) { using (var serializationContext = SerializationTransaction.Create(_container)) { var serializer = _serializerRepository.SerializerFor(objectToLoad); var element = XElement.Load(fileName); serializer.Deserialize(objectToLoad, element, serializationContext); } }
public virtual void Save(T objectToSerialize, string fileName) { using (var serializationContext = SerializationTransaction.Create(_container)) { var serializer = _serializerRepository.SerializerFor(objectToSerialize); var xel = serializer.Serialize(objectToSerialize, serializationContext); xel.Save(fileName); } }
public override void Load(DataRepository dataRepository, string fileName) { using (var context = SerializationTransaction.Create(_dimensionFactory, withIdRepository: new WithIdRepository())) { var xmlSerializer = _serializerRepository.SerializerFor(dataRepository); var outputToDeserialize = XElement.Load(fileName); xmlSerializer.Deserialize(dataRepository, outputToDeserialize, context); } }
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 void SaveToPKML <T>(T entityToSerialize, string fileName) { using (var serializationContext = SerializationTransaction.Create()) { var xElement = serializeModelPart(entityToSerialize, serializationContext); xElement.AddAttribute(Constants.Serialization.Attribute.VERSION, Constants.PKML_VERSION.ToString()); xElement.Save(fileName); } }
protected override void Context() { base.Context(); _entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >(); _serializationContext = SerializationTransaction.Create(_container); _deserializedObject = A.Fake <IEntity>(); _element = new XElement("TUTU"); A.CallTo(() => _entitySerializer.Deserialize <IEntity>(_element, _serializationContext)).Returns(_deserializedObject); A.CallTo(() => _serializerRepository.SerializerFor(_element)).Returns(_entitySerializer); }
protected override void Context() { base.Context(); _element = new XElement("TOTO"); _entityToSerialize = A.Fake <IEntity>(); _entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >(); A.CallTo(() => _entitySerializer.ObjectType).Returns(typeof(IEntity)); _serializationContext = SerializationTransaction.Create(); A.CallTo(() => _entitySerializer.Serialize(_entityToSerialize, _serializationContext)).Returns(_element); A.CallTo(() => _serializerRepository.SerializerFor(_entityToSerialize)).Returns(_entitySerializer); }
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 virtual T FromString <T>(string serializationString) { if (string.IsNullOrEmpty(serializationString)) { return(default(T)); } using (var serializationContext = SerializationTransaction.Create(_container)) { var xDoc = XDocument.Load(new StringReader(serializationString)); return(Deserialize <T>(xDoc.Root, serializationContext)); } }
protected override void Context() { base.Context(); _entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >(); _serializationContext = SerializationTransaction.Create(_container); _deserializedObject = A.Fake <IEntity>(); A.CallTo(() => _entitySerializer.ObjectType).Returns(typeof(IEntity)); _element = new XElement("TUTU"); A.CallTo(() => _entitySerializer.Deserialize <IEntity>(_element, _serializationContext)).Returns(_deserializedObject); //serializers only defined for type but not for element A.CallTo(() => _serializerRepository.SerializerFor(typeof(IEntity))).Returns(_entitySerializer); A.CallTo(() => _serializerRepository.SerializerFor(_element)).Throws(new SerializerNotFoundException("toto")); }
public TObject Deserialize <TObject>(byte[] serializationByte) { if (typeof(TObject) != typeof(IDiagramModel)) { return(default(TObject)); } var serializer = _modelingXmlSerializerRepository.SerializerFor <IDiagramModel>(); using (var serializationContext = SerializationTransaction.Create()) { var outputToDeserialize = XmlHelper.ElementFromBytes(_compress.Decompress(serializationByte)); return((TObject)serializer.Deserialize(outputToDeserialize, serializationContext)); } }
protected override void DoStart() { var serializer = _unitSystemXmlSerializerRepository.SerializerFor(_dimensionFactory); var xel = XElement.Load(_pkSimConfiguration.DimensionFilePath); serializer.Deserialize(_dimensionFactory, xel, SerializationTransaction.Create()); //add pksim specific dimension var inputDose = _dimensionFactory.AddDimension(new BaseDimensionRepresentation(), CoreConstants.Dimension.InputDose, "kg/kg"); inputDose.AddUnit("mg", 1e-6, 0); inputDose.DefaultUnit = inputDose.AddUnit("mg/kg", 1e-6, 0); inputDose.BaseUnit.Visible = false; _dimensionNames = _dimensionFactory.GetDimensionNames().ToList(); _dimensionFactory.AddDimension(Constants.Dimension.NO_DIMENSION); }
public override void Load(IGroupRepository groupRepository, string fileName) { groupRepository.Clear(); using (var serializationContext = SerializationTransaction.Create(_container, withIdRepository: new WithIdRepository())) { var serializer = _serializerRepository.SerializerFor(groupRepository); var element = XElement.Load(fileName); serializer.Deserialize(groupRepository, element, serializationContext); } //last step. groups only have reference to parents. We need to add them as child foreach (var group in groupRepository.All().Where(x => x.Parent != null)) { group.Parent.AddChild(group); } }
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)); } }