private static Wrapper Deserialize(RMap rm)
{
return(new Wrapper()
{
Text = rm.Get <string>(nameof(Text))
});
}
public static ChangeTracker <T> Deserialize(RMap rm)
{
if (!rm.ContainsKey("¡RootId") || rm["¡RootId"] == null)
{
return(new ChangeTracker <T>());
}
var changeTracker = new ChangeTracker <T>();
var rootId = rm.Get <int>("¡RootId");
var maxId = rootId;
var(currNode, nextId) = Node.Deserialize(rm, rootId, changeTracker);
changeTracker.Head = currNode;
changeTracker.Tail = currNode;
while (nextId != null)
{
maxId = Max(nextId.Value, maxId);
var(nextNode, id) = Node.Deserialize(rm, nextId.Value, changeTracker);
nextId = id;
currNode.Next = nextNode;
nextNode.Prev = currNode;
currNode = nextNode;
changeTracker.Tail = currNode;
}
changeTracker.NextId = maxId + 1;
return(changeTracker);
}
private static Person Deserialize(RMap rm)
{
var person = new Person
{
Name = rm.Get <string>(nameof(Name))
};
rm.WhenResolved <Person>(nameof(Relationship), p => person.Relationship = p);
return(person);
}
internal static CMethodBuilder2 Deserialize(RMap rm)
{
var stmType = Type.GetType(rm["¡StmType"].ToString());
var stmInstance = (IAsyncStateMachine)Activator.CreateInstance(stmType);
ReflectiveSerializer.Deserialize(rm, stmInstance);
var builder = new CMethodBuilder2();
rm.WhenResolved <CTask2>("¡Task", t => builder.Task = t);
builder.StateMachine = stmInstance;
return(builder);
}
private static ChangeTrackerWrapper Deserialize(RMap rm)
=> new ChangeTrackerWrapper()
{
ChangeTracker = ChangeTracker <int> .Deserialize(rm)
};
private static KeyAndValue Deserialize(RMap rm)
=> new KeyAndValue()
{
Key = rm.Get <TKey>(nameof(Key)),
Value = rm.Get <TValue>(nameof(Value))
};
/// <summary> This makes a map of matching atoms out of a map of matching bonds as produced by the get(Subgraph|Ismorphism)Map methods.
///
/// </summary>
/// <param name="l"> The list produced by the getMap method.
/// </param>
/// <param name="g1"> The first atom container.
/// </param>
/// <param name="g2"> The second one (first and second as in getMap)
/// </param>
/// <returns> The mapping found projected on g1. This is a List of RMap objects containing Ids of matching atoms.
/// </returns>
public static System.Collections.IList makeAtomsMapOfBondsMap(System.Collections.IList l, IAtomContainer g1, IAtomContainer g2)
{
if (l == null)
{
return(l);
}
IBond[] bonds1 = g1.Bonds;
IBond[] bonds2 = g2.Bonds;
System.Collections.IList result = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
for (int i = 0; i < l.Count; i++)
{
IBond bond1 = bonds1[((RMap)l[i]).Id1];
IBond bond2 = bonds2[((RMap)l[i]).Id2];
IAtom[] atom1 = bond1.getAtoms();
IAtom[] atom2 = bond2.getAtoms();
for (int j = 0; j < 2; j++)
{
IBond[] bondsConnectedToAtom1j = g1.getConnectedBonds(atom1[j]);
for (int k = 0; k < bondsConnectedToAtom1j.Length; k++)
{
if (bondsConnectedToAtom1j[k] != bond1)
{
IBond testBond = bondsConnectedToAtom1j[k];
for (int m = 0; m < l.Count; m++)
{
IBond testBond2;
if (((RMap)l[m]).Id1 == g1.getBondNumber(testBond))
{
testBond2 = bonds2[((RMap)l[m]).Id2];
for (int n = 0; n < 2; n++)
{
System.Collections.IList bondsToTest = g2.getConnectedBondsVector(atom2[n]);
if (bondsToTest.Contains(testBond2))
{
RMap map;
if (j == n)
{
map = new RMap(g1.getAtomNumber(atom1[0]), g2.getAtomNumber(atom2[0]));
}
else
{
map = new RMap(g1.getAtomNumber(atom1[1]), g2.getAtomNumber(atom2[0]));
}
if (!result.Contains(map))
{
result.Add(map);
}
RMap map2;
if (j == n)
{
map2 = new RMap(g1.getAtomNumber(atom1[1]), g2.getAtomNumber(atom2[1]));
}
else
{
map2 = new RMap(g1.getAtomNumber(atom1[0]), g2.getAtomNumber(atom2[1]));
}
if (!result.Contains(map2))
{
result.Add(map2);
}
}
}
}
}
}
}
}
}
return(result);
}
//////////////////////////////////////
// Manipulation tools
/// <summary> Projects a list of RMap on a molecule
///
/// </summary>
/// <param name="rMapList"> the list to project
/// </param>
/// <param name="g"> the molecule on which project
/// </param>
/// <param name="id"> the id in the RMap of the molecule g
/// </param>
/// <returns> an AtomContainer
/// </returns>
public static IAtomContainer project(System.Collections.IList rMapList, IAtomContainer g, int id)
{
IAtomContainer ac = g.Builder.newAtomContainer();
IBond[] bondList = g.Bonds;
System.Collections.Hashtable table = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
IAtom a1;
IAtom a2;
IAtom a;
IBond bond;
//UPGRADE_TODO: Method 'java.util.Iterator.hasNext' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilIteratorhasNext'"
for (System.Collections.IEnumerator i = rMapList.GetEnumerator(); i.MoveNext();)
{
//UPGRADE_TODO: Method 'java.util.Iterator.next' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilIteratornext'"
RMap rMap = (RMap)i.Current;
if (id == UniversalIsomorphismTester.ID1)
{
bond = bondList[rMap.Id1];
}
else
{
bond = bondList[rMap.Id2];
}
a = bond.getAtomAt(0);
a1 = (IAtom)table[a];
if (a1 == null)
{
try
{
a1 = (IAtom)a.Clone();
}
//UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
catch (System.Exception e)
{
SupportClass.WriteStackTrace(e, Console.Error);
}
ac.addAtom(a1);
table[a] = a1;
}
a = bond.getAtomAt(1);
a2 = (IAtom)table[a];
if (a2 == null)
{
try
{
a2 = (IAtom)a.Clone();
}
//UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
catch (System.Exception e)
{
SupportClass.WriteStackTrace(e, Console.Error);
}
ac.addAtom(a2);
table[a] = a2;
}
IBond newBond = g.Builder.newBond(a1, a2, bond.Order);
newBond.setFlag(CDKConstants.ISAROMATIC, bond.getFlag(CDKConstants.ISAROMATIC));
ac.addBond(newBond);
}
return(ac);
}
private static CSet <T> Deserialize(RMap rm) => new CSet <T>(ChangeTracker <T> .Deserialize(rm));
private static Person Deserialize(RMap rm)
=> new Person
{
Name = rm[nameof(Name)].CastTo <string>(),
Sibling = rm[nameof(Sibling)].CastTo <Person>()
};
public override void _Ready()
{
this._rMap = new RMap(128, 128);
this.state = "init";
}
private static Wrapper Deserialize(RMap rm)
=> new Wrapper()
{
State = rm.Get <string>(nameof(State))
};
