public void ReplaceDeserializedObject(string id, object?oldObj, object?newObj)
{
if (object.ReferenceEquals(oldObj, newObj))
{
return;
}
if (id != Globals.NewObjectId)
{
// In certain cases (IObjectReference, SerializationSurrogate or DataContractSurrogate),
// an object can be replaced with a different object once it is deserialized. If the
// object happens to be referenced from within itself, that reference needs to be updated
// with the new instance. BinaryFormatter supports this by fixing up such references later.
// These XmlObjectSerializer implementations do not currently support fix-ups. Hence we
// throw in such cases to allow us add fix-up support in the future if we need to.
if (DeserializedObjects.IsObjectReferenced(id))
{
string oldType = (oldObj != null) ? DataContract.GetClrTypeFullName(oldObj.GetType()) : SR.UnknownNullType;
string newType = (newObj != null) ? DataContract.GetClrTypeFullName(newObj.GetType()) : SR.UnknownNullType;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.FactoryObjectContainsSelfReference, oldType, newType, id)));
}
DeserializedObjects.Remove(id);
DeserializedObjects.Add(id, newObj);
}
}
public static void InitializeClass(TestContext context)
{
string path = @"../../Classes/Xml/TestXML/testMSystemDescription.xml";
XDocument inventoryFile = XDocument.Load(path);
v_TestDeserializedMSystemObjects = new DeserializedObjects(inventoryFile, path);
}
internal void AddNewObjectWithId(string id, object?obj)
{
if (id != Globals.NewObjectId)
{
DeserializedObjects.Add(id, obj);
}
}
public void ReplaceDeserializedObject(string id, object?oldObj, object?newObj)
{
if (object.ReferenceEquals(oldObj, newObj))
{
return;
}
if (id != Globals.NewObjectId)
{
// In certain cases (IObjectReference, SerializationSurrogate or DataContractSurrogate),
// an object can be replaced with a different object once it is deserialized. If the
// object happens to be referenced from within itself, that reference needs to be updated
// with the new instance. BinaryFormatter supports this by fixing up such references later.
// These XmlObjectSerializer implementations do not currently support fix-ups. Hence we
// throw in such cases to allow us add fix-up support in the future if we need to.
if (DeserializedObjects.IsObjectReferenced(id))
{
// https://github.com/dotnet/runtime/issues/41465 - oldObj or newObj may be null below - suppress compiler error by asserting non-null
Debug.Assert(oldObj != null && newObj != null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.FactoryObjectContainsSelfReference, DataContract.GetClrTypeFullName(oldObj.GetType()), DataContract.GetClrTypeFullName(newObj.GetType()), id)));
}
DeserializedObjects.Remove(id);
DeserializedObjects.Add(id, newObj);
}
}
public void Initialize()
{
mSystemObjects = new DeserializedObjects(mSystemDescription, _path);
m_testMSystem = new MSystem(mSystemObjects);
m_tilesWorld = new TilesWorld(m_testMSystem);
m_floatingObjWorld = new FloatingObjectsWorld(m_testMSystem, m_tilesWorld);
m_tilesWorld.FltObjectsWorld = m_floatingObjWorld;
}
public static void InitializeClass(TestContext context)
{
string path = @"../../Classes/Xml/TestXML/testMSystemDescription.xml";
XDocument mSystemDescription = XDocument.Load(path);
var mSystemObjects = new DeserializedObjects(mSystemDescription, path);
_testMSystem = new MSystem(mSystemObjects);
}
internal object GetExistingObject(string id, Type?type, string?name, string?ns)
{
object?retObj = DeserializedObjects.GetObject(id);
if (retObj == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.DeserializedObjectWithIdNotFound, id)));
}
return(retObj);
}
public void TestThatInventoryFileIsDeserializable()
{
//Key of this test is to use oficial published inventory file.
//DO NOT USE TEST XMLs.
string path = @"..\..\..\Cytos_v2\Examples\MSystemDescription.xml";
XDocument mSystemDescription = XDocument.Load(path);
// ReSharper disable once UnusedVariable
DeserializedObjects testDeserializedObjects = new DeserializedObjects(mSystemDescription, path);
//No assert needed, tests only ability to deserialize invenoty file
}
/// <summary>
/// Simulation constructor.
/// </summary>
/// <param name="mSystemObjects">Deserialized M System objects.</param>
/// <exception cref="ArgumentException">
/// If M System objects objecst list is null.
/// </exception>
protected SimulationWorld(DeserializedObjects mSystemObjects)
{
if (mSystemObjects == null)
{
throw new ArgumentException("M System objects can't be null");
}
SimulationMSystem = new MSystem(mSystemObjects);
TilesWorld = new TilesWorld(SimulationMSystem);
FltObjectsWorld = new FloatingObjectsWorld(SimulationMSystem, TilesWorld);
// The TilesWorld and FltObjectsWorld need to crossref.
TilesWorld.FltObjectsWorld = FltObjectsWorld;
}
private object GetExistingObjectOrExtensionData(string id)
{
object?retObj = DeserializedObjects.GetObject(id);
if (retObj == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
XmlObjectSerializer.CreateSerializationException(SR.Format(SR.DeserializedObjectWithIdNotFound, id)));
}
return(retObj);
}
/// <summary>
/// --- Load example -> M System description - Click event ---
/// Opens OpenFileDialog, M System description file and deserialize input.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event parameter.</param>
private void mSystemDescriptionToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "XML Files (.xml)|*.xml";
openFileDialog.Multiselect = false;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
//Check if selected file is really evolution file.
XDocument doc = XDocument.Load(openFileDialog.FileName);
if (doc.Element("root") == null)
{
throw new InvalidOperationException("Selected file is not an M System description file.");
}
v_MSystemObjectsPath = openFileDialog.FileName;
//XSD validation
if (v_ValidateUsingXSD)
{
string errorsAndWarnings;
if (!XmlValidator.Validate(v_MSystemObjectsPath, v_XSDPath, out errorsAndWarnings))
{
throw new ValidationFailed(errorsAndWarnings);
}
}
string errorMessage;
IDeserializedObjects deserializedObjects = Xmlizer.Deserialize(v_MSystemObjectsPath, out errorMessage);
if (deserializedObjects == null)
{
richTextBoxMSystem.Text = errorMessage;
return;
}
v_MSystemObjects = TypeUtil.Cast <DeserializedObjects>(deserializedObjects);
RestartSimulator();
richTextBoxMSystem.Text = v_Simulator.MSystemToString();
VisualizeLogging.LogMessageAndVisualize("Deserialization of M System description file was successful.");
VisualizeLogging.LogMessageAndVisualize(string.Format("File: {0}", openFileDialog.FileName));
}
}
catch (Exception exception)
{
ExceptionWindow.Show(exception);
}
}
/// <summary>
/// P system constructor used during simulation.
/// </summary>
/// <param name="mSystemObjects">Deserialized M System objects.</param>
/// <exception cref="ArgumentException">
/// If M System objects objecst list is null.
/// </exception>
public MSystem(DeserializedObjects mSystemObjects)
{
if (mSystemObjects == null)
{
throw new ArgumentException("M System objects can't be null.");
}
// New copies of seed tiles must be created here!
SeedTiles = mSystemObjects.SeedTiles.Select(tile => new TileInSpace((Tile)tile, tile.Position, tile.Quaternion)).ToList();
GlueRadius = mSystemObjects.GlueRadius;
TilingRandomMovement = mSystemObjects.TilingRandomMovement;
Tau = mSystemObjects.Tau;
Nu0 = mSystemObjects.Nu0;
PushingCoef = mSystemObjects.PushingCoef;
RandomizeConnectors = mSystemObjects.RandomizeConnectors;
FloatingObjects = new ReadOnlyDictionary <string, FloatingObject>(mSystemObjects.FloatingObjects);
if (FloatingObjects.Any())
{
Mobility = FloatingObjects.Values.Max(obj => obj.Mobility);
}
RefillEnvironment = mSystemObjects.RefillEnvironment;
v_Proteins = new ReadOnlyDictionary <string, Protein>(mSystemObjects.Proteins);
Tiles = new ReadOnlyDictionary <string, Tile>(mSystemObjects.Tiles);
GlueRelation = mSystemObjects.GluePRelation;
v_EvolutionRules = mSystemObjects.EvolutionRules;
//======================================================================
MetabolicRules = new Dictionary <string, IReadOnlyList <EvoMetabolicRule> >();
foreach (string proteinName in v_Proteins.Keys)
{
MetabolicRules[proteinName] = v_EvolutionRules.OfType <EvoMetabolicRule>().Where(rule => proteinName == rule.RProtein.Name).ToList();
}
//======================================================================
CreationRules = new Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> >();
foreach (Glue glue in mSystemObjects.Glues.Values)
{
var creationRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>().Where(rule => rule.Type == EvolutionRule.RuleType.Create).ToList();
CreationRulesPriorities = new SortedSet <int>(creationRules.Select(rule => rule.Priority));
CreationRules[glue] = creationRules.Where(rule => rule.RightSideObjects.OfType <Tile>().Single()
.Connectors.Any(connector => GlueRelation.ContainsKey(Tuple.Create(glue, connector.Glue))))
.ToList();
}
//======================================================================
InsertionRules = new Dictionary <Glue, Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> > >();
foreach (Glue glue1 in mSystemObjects.Glues.Values)
{
foreach (Glue glue2 in mSystemObjects.Glues.Values)
{
var insRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>()
.Where(rule => (rule.Type == EvolutionRule.RuleType.Insert) &&
IsInsertable(rule.RightSideObjects.OfType <Tile>().Single(), glue1, glue2))
.ToList();
if (insRules.Any())
{
AddRulesToDictionary(InsertionRules, glue1, glue2, insRules);
AddRulesToDictionary(InsertionRules, glue2, glue1, insRules);
}
}
}
//======================================================================
DestructionRules = new Dictionary <string, IReadOnlyList <EvoNonMetabolicRule> >();
foreach (string tileName in Tiles.Keys)
{
DestructionRules[tileName] = v_EvolutionRules.OfType <EvoNonMetabolicRule>().Where(rule => (rule.Type == EvolutionRule.RuleType.Destroy) &&
rule.LeftSideObjects.OfType <Tile>().Single().Name == tileName).ToList();
}
//======================================================================
DivisionRules = new Dictionary <Glue, Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> > >();
foreach (Glue glue1 in mSystemObjects.Glues.Values)
{
foreach (Glue glue2 in mSystemObjects.Glues.Values)
{
var divRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>()
.Where(rule => (rule.Type == EvolutionRule.RuleType.Divide) &&
glue1 == (Glue)rule.RightSideObjects[0] &&
glue2 == (Glue)rule.RightSideObjects[1])
.ToList();
if (divRules.Any())
{
AddRulesToDictionary(DivisionRules, glue1, glue2, divRules);
AddRulesToDictionary(DivisionRules, glue2, glue1, divRules);
}
}
}
}
//Initialize object/s before each test is run. It will be called for each test.
public void Initialize()
{
_testDeserializedMSystemObjects = new DeserializedObjects(_mSystemDescription, _path);
_testMSystem = new MSystem(_testDeserializedMSystemObjects);
_testSimulator = new SimulatorFacade(_testDeserializedMSystemObjects);
}
internal SimulatorFacade(DeserializedObjects mSystemObjects) :
base(mSystemObjects, false)
{
}
public void TestDeserializationCreatesObjectWithCorrectValues()
{
//NOTE: We cannot test equivalence of objects as objects contains readonly parameters, which are never equal.
//Due to this limitation we test only values of parameters.
string path = @"../../Classes/Xml/TestXML/testMSystemDescription.xml";
XDocument mSystemDescription = XDocument.Load(path);
DeserializedObjects testDeserializedObjects = new DeserializedObjects(mSystemDescription, path);
//Floating objects
Dictionary <string, FloatingObject> floatingObjects = testDeserializedObjects.FloatingObjects;
Assert.AreEqual(3, floatingObjects.Count);
Assert.AreEqual("a", floatingObjects["a"].Name);
Assert.AreEqual(0, floatingObjects["a"].Concentration);
Assert.AreEqual(2, floatingObjects["a"].Mobility);
Assert.AreEqual("b", floatingObjects["b"].Name);
Assert.AreEqual(2, floatingObjects["b"].Concentration);
Assert.AreEqual(3, floatingObjects["b"].Mobility);
//Proteins
Dictionary <string, Protein> proteins = testDeserializedObjects.Proteins;
Assert.AreEqual(2, proteins.Count);
Assert.AreEqual("p1", proteins["p1"].Name);
Assert.AreEqual("p2", proteins["p2"].Name);
//Glues
Dictionary <string, Glue> glues = testDeserializedObjects.Glues;
Assert.AreEqual(3, glues.Count);
Assert.AreEqual("pa", glues["pa"].Name);
Assert.AreEqual("pb", glues["pb"].Name);
Assert.AreEqual("px", glues["px"].Name);
//Tiles
Dictionary <string, Tile> tiles = testDeserializedObjects.Tiles;
Assert.AreEqual(3, tiles.Count);
Tile tileQ1 = tiles["q1"];
//Connectors
var connectors = tileQ1.Connectors;
Assert.AreEqual(6, connectors.Count);
var connectorC1 = connectors[0];
Assert.AreEqual("c1", connectorC1.Name);
Assert.AreEqual(Tile.SideType.undef, connectorC1.Side);
Assert.AreEqual(glues["pa"], connectorC1.Glue);
Assert.AreEqual(Angle.FromRadians(2.034443935795703), connectorC1.Angle);
Assert.AreEqual(2, connectorC1.Positions.Count);
Assert.AreEqual(new Point3D(0, 10, 0), connectorC1.Positions[0]);
double posY = 10 * Math.Cos((1) * 2 * Math.PI / 5);
double posX = 10 * Math.Sin((1) * 2 * Math.PI / 5);
Assert.AreEqual(new Point3D(posX, posY, 0), connectorC1.Positions[1]);
//Surface glue
Glue surfaceGLuePx = tileQ1.SurfaceGlue;
Assert.AreEqual("px", surfaceGLuePx.Name);
//Proteins
Assert.AreEqual(4, tileQ1.Proteins.Count);
Assert.AreEqual("p1", tileQ1.Proteins[0].Name);
Assert.AreEqual("p1", tileQ1.Proteins[1].Name);
Assert.AreEqual("p2", tileQ1.Proteins[2].Name);
Assert.AreEqual("p2", tileQ1.Proteins[3].Name);
foreach (var protein in tileQ1.Proteins)
{
Assert.AreEqual(Point3D.Origin, protein.Position);
}
Assert.AreEqual(Color.DeepSkyBlue, tileQ1.Color);
Tile tileS1 = tiles["s1"];
Assert.AreEqual(2, tileS1.Connectors.Count);
Assert.AreEqual(1, tileS1.Proteins.Count);
//Initial objects
List <TileInSpace> seedTiles = testDeserializedObjects.SeedTiles;
Assert.AreEqual(3, seedTiles.Count);
var seedTileQ1 = seedTiles[0];
Assert.AreEqual("q1", seedTileQ1.Name);
Assert.AreEqual(new Point3D(0, 0, 0), seedTileQ1.Position.Round());
Assert.AreEqual(new EulerAngles(default(Angle), default(Angle), default(Angle)), seedTileQ1.Quaternion.ToEulerAngles());
//Others
Assert.AreEqual(0.1, testDeserializedObjects.GlueRadius);
//Glue tuples
GlueRelation glueTuples = testDeserializedObjects.GluePRelation;
Assert.AreEqual(3, glueTuples.Count);
Tuple <Glue, Glue> glueTuplePaPb = glueTuples.Keys.ElementAt(0);
Assert.AreEqual("pa", glueTuplePaPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePaPb.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(0).ToDictionary()["a"]);
Tuple <Glue, Glue> glueTuplePaPa = glueTuples.Keys.ElementAt(1);
Assert.AreEqual("pa", glueTuplePaPa.Item1.Name);
Assert.AreEqual("pa", glueTuplePaPa.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(1).ToDictionary().Count);
Tuple <Glue, Glue> glueTuplePbPb = glueTuples.Keys.ElementAt(2);
Assert.AreEqual("pb", glueTuplePbPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePbPb.Item2.Name);
Assert.AreEqual(0, glueTuples.Values.ElementAt(2).ToDictionary().Count);
//Evo rules
List <EvolutionRule> evoRules = testDeserializedObjects.EvolutionRules;
Assert.AreEqual(4, evoRules.Count);
EvoMetabolicRule metabolicRule = TypeUtil.Cast <EvoMetabolicRule>(evoRules[0]);
Assert.AreEqual(0, metabolicRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Metabolic, metabolicRule.Type);
Assert.AreEqual(EvoMetabolicRule.MetabolicRuleType.Symport, metabolicRule.SubType);
Assert.AreEqual(2, metabolicRule.LeftSideObjects.Count);
Assert.AreEqual("a", metabolicRule.LeftSideObjects[0].Name);
Assert.AreEqual("p1", metabolicRule.LeftSideObjects[1].Name);
Assert.AreEqual(2, metabolicRule.RightSideObjects.Count);
Assert.AreEqual("p1", metabolicRule.RightSideObjects[0].Name);
Assert.AreEqual("a", metabolicRule.RightSideObjects[1].Name);
Assert.AreEqual(0, metabolicRule.MLeftInNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.ToDictionary()["a"]);
Assert.AreEqual(1, metabolicRule.MRightInNames.Count);
Assert.AreEqual(1, metabolicRule.MRightInNames.ToDictionary()["a"]);
Assert.AreEqual(0, metabolicRule.MRightOutNames.Count);
Assert.AreEqual("p1", metabolicRule.RProtein.Name);
EvoNonMetabolicRule createRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[1]);
Assert.AreEqual(1, createRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Create, createRule.Type);
Assert.AreEqual(3, createRule.LeftSideObjects.Count);
Assert.AreEqual("a", createRule.LeftSideObjects[0].Name);
Assert.AreEqual("a", createRule.LeftSideObjects[1].Name);
Assert.AreEqual("a", createRule.LeftSideObjects[2].Name);
Assert.AreEqual(1, createRule.RightSideObjects.Count);
Assert.AreEqual("q1", createRule.RightSideObjects[0].Name);
Assert.AreEqual(3, createRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(3, createRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, createRule.MRightSideFloatingNames.Count);
EvoNonMetabolicRule divideRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[2]);
Assert.AreEqual(1, divideRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Divide, divideRule.Type);
Assert.AreEqual(4, divideRule.LeftSideObjects.Count);
Assert.AreEqual("pa", divideRule.LeftSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.LeftSideObjects[1].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[2].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[3].Name);
Assert.AreEqual(2, divideRule.RightSideObjects.Count);
Assert.AreEqual("pa", divideRule.RightSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.RightSideObjects[1].Name);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, divideRule.MRightSideFloatingNames.Count);
EvoNonMetabolicRule destroyRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[3]);
Assert.AreEqual(1, destroyRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Destroy, destroyRule.Type);
Assert.AreEqual(3, destroyRule.LeftSideObjects.Count);
Assert.AreEqual("a", destroyRule.LeftSideObjects[0].Name);
Assert.AreEqual("a", destroyRule.LeftSideObjects[1].Name);
Assert.AreEqual("s1", destroyRule.LeftSideObjects[2].Name);
Assert.AreEqual(2, destroyRule.RightSideObjects.Count);
Assert.AreEqual("c", destroyRule.RightSideObjects[0].Name);
Assert.AreEqual("c", destroyRule.RightSideObjects[1].Name);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.ToDictionary()["c"]);
}
