public override void write(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { try { ISetOfMolecules som = object_Renamed.Builder.newSetOfMolecules(); som.addMolecule((IMolecule)object_Renamed); writeMolecule(som); } catch (System.Exception ex) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" throw new CDKException("Error while writing HIN file: " + ex.Message, ex); } } else if (object_Renamed is ISetOfMolecules) { try { writeMolecule((ISetOfMolecules)object_Renamed); } catch (System.IO.IOException ex) { // } } else { throw new CDKException("HINWriter only supports output of Molecule or SetOfMolecule classes."); } }
public virtual void TestGetProperties() { IChemObject chemObject = NewChemObject(); Assert.IsNotNull(chemObject.GetProperties()); Assert.AreEqual(0, chemObject.GetProperties().Count()); }
/// <summary> /// Compare two <see cref="IChemObject"/> classes and return the difference as an <see cref="IDifference"/>. /// </summary> /// <param name="first">the first of the two classes to compare</param> /// <param name="second">the second of the two classes to compare</param> /// <returns>an <see cref="IDifference"/> representation of the difference between the first and second <see cref="IChemObject"/>.</returns> public static IDifference Difference(IChemObject first, IChemObject second) { if (!(first is IAtomType && second is IAtomType)) { return(null); } var firstElem = (IAtomType)first; var secondElem = (IAtomType)second; var totalDiff = new ChemObjectDifference("AtomTypeDiff"); totalDiff.AddChild(StringDifference.Construct("N", firstElem.AtomTypeName, secondElem.AtomTypeName)); totalDiff.AddChild(BondOrderDifference.Construct("MBO", firstElem.MaxBondOrder, secondElem.MaxBondOrder)); totalDiff .AddChild(DoubleDifference.Construct("BOS", firstElem.BondOrderSum, secondElem.BondOrderSum)); totalDiff .AddChild(IntegerDifference.Construct("FC", firstElem.FormalCharge, secondElem.FormalCharge)); totalDiff.AddChild(AtomTypeHybridizationDifference.Construct("H", firstElem.Hybridization, secondElem.Hybridization)); totalDiff.AddChild(IntegerDifference.Construct("NC", firstElem.FormalNeighbourCount, secondElem.FormalNeighbourCount)); totalDiff.AddChild(DoubleDifference.Construct("CR", firstElem.CovalentRadius, secondElem.CovalentRadius)); totalDiff.AddChild(IntegerDifference.Construct("V", firstElem.Valency, secondElem.Valency)); totalDiff.AddChild(IsotopeDiff.Difference(first, second)); if (totalDiff.ChildCount() > 0) { return(totalDiff); } else { return(null); } }
private static void SetIfMissing(IChemObject chemObject, string key, string val) { if (chemObject.GetProperty <string>(key) == null) { chemObject.SetProperty(key, val); } }
public virtual void TestSetNotification_bool() { IChemObject chemObject = NewChemObject(); chemObject.Notification = false; Assert.IsFalse(chemObject.Notification); }
public static void TestSetAtoms_RemoveListener(IChemObject newChemObject) { IAtomContainer container = (IAtomContainer)newChemObject; IAtom[] atoms = new IAtom[4]; atoms[0] = container.Builder.NewAtom("C"); atoms[1] = container.Builder.NewAtom("C"); atoms[2] = container.Builder.NewAtom("C"); atoms[3] = container.Builder.NewAtom("O"); container.SetAtoms(atoms); // if an atom changes, the atomcontainer will throw a change event too ChemObjectListener listener = new ChemObjectListener(); container.Listeners.Add(listener); Assert.IsFalse(listener.Changed); // ok, change the atom, and make sure we do get an event atoms[0].AtomTypeName = "C.sp2"; Assert.IsFalse(listener.Changed); // reset the listener, overwrite the atoms, and change an old atom. // if all is well, we should not get a change event this time listener.Reset(); Assert.IsFalse(listener.Changed); // make sure the reset worked container.SetAtoms(Array.Empty <IAtom>()); atoms[1].AtomTypeName = "C.sp2"; // make a change to an old atom Assert.IsFalse(listener.Changed); // but no change event should happen }
public static void TestGetListenerCount(IChemObject chemObject) { ChemObjectListener listener = new ChemObjectListener(); chemObject.Listeners.Add(listener); Assert.AreEqual(0, chemObject.Listeners.Count); }
/// <summary> /// Compare two <see cref="IChemObject"/> classes and return the difference as an <see cref="IDifference"/>. /// </summary> /// <param name="first">the first of the two classes to compare</param> /// <param name="second">the second of the two classes to compare</param> /// <returns>an <see cref="IDifference"/> representation of the difference between the first and second <see cref="IChemObject"/>.</returns> public static IDifference Difference(IChemObject first, IChemObject second) { if (!(first is IBond && second is IBond)) { return(null); } IBond firstB = (IBond)first; IBond secondB = (IBond)second; IDifferenceList totalDiff = new ChemObjectDifference("BondDiff"); totalDiff.AddChild(BondOrderDifference.Construct("order", firstB.Order, secondB.Order)); totalDiff.AddChild(IntegerDifference.Construct("atomCount", firstB.Atoms.Count, secondB.Atoms.Count)); if (firstB.Atoms.Count == secondB.Atoms.Count) { totalDiff.AddChild(AtomDiff.Difference(firstB.Begin, secondB.Begin)); totalDiff.AddChild(AtomDiff.Difference(firstB.End, secondB.End)); for (int i = 2; i < firstB.Atoms.Count; i++) { totalDiff.AddChild(AtomDiff.Difference(firstB.Atoms[i], secondB.Atoms[i])); } } totalDiff.AddChild(ElectronContainerDiff.Difference(first, second)); if (totalDiff.ChildCount() > 0) { return(totalDiff); } else { return(null); } }
/// <summary> Takes an object which subclasses IChemObject, e.g.Molecule, and will read /// this from from the Reader. If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object">The object that subclasses IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { IChemFile file = (IChemFile)object_Renamed; IChemSequence sequence = file.Builder.newChemSequence(); IChemModel model = file.Builder.newChemModel(); ISetOfMolecules moleculeSet = file.Builder.newSetOfMolecules(); moleculeSet.addMolecule(readMolecule(model.Builder.newMolecule())); model.SetOfMolecules = moleculeSet; sequence.addChemModel(model); file.addChemSequence(sequence); return(file); } else if (object_Renamed is IChemModel) { IChemModel model = (IChemModel)object_Renamed; ISetOfMolecules moleculeSet = model.Builder.newSetOfMolecules(); moleculeSet.addMolecule(readMolecule(model.Builder.newMolecule())); model.SetOfMolecules = moleculeSet; return(model); } else { throw new CDKException("Only supported is ChemModel, and not " + object_Renamed.GetType().FullName + "."); } }
/// <summary> /// Compare two <see cref="IChemObject"/> classes and return the difference as an <see cref="IDifference"/>. /// </summary> /// <param name="first">the first of the two classes to compare</param> /// <param name="second">the second of the two classes to compare</param> /// <returns>an <see cref="IDifference"/> representation of the difference between the first and second <see cref="IChemObject"/>.</returns> public static IDifference Difference(IChemObject first, IChemObject second) { if (!(first is IAtom && second is IAtom)) { return(null); } IAtom firstElem = (IAtom)first; IAtom secondElem = (IAtom)second; ChemObjectDifference totalDiff = new ChemObjectDifference("AtomDiff"); totalDiff.AddChild(IntegerDifference.Construct("H", firstElem.ImplicitHydrogenCount, secondElem.ImplicitHydrogenCount)); totalDiff .AddChild(IntegerDifference.Construct("SP", (int)firstElem.StereoParity, (int)secondElem.StereoParity)); totalDiff.AddChild(Point2DDifference.Construct("2D", firstElem.Point2D, secondElem.Point2D)); totalDiff.AddChild(Point3DDifference.Construct("3D", firstElem.Point3D, secondElem.Point3D)); totalDiff.AddChild(Point3DDifference.Construct("F3D", firstElem.FractionalPoint3D, secondElem.FractionalPoint3D)); totalDiff.AddChild(DoubleDifference.Construct("C", firstElem.Charge, secondElem.Charge)); totalDiff.AddChild(AtomTypeDiff.Difference(first, second)); if (totalDiff.ChildCount() > 0) { return(totalDiff); } else { return(null); } }
public override void Write(IChemObject obj) { if (obj is IAtomContainer) { try { IChemObjectSet <IAtomContainer> som = obj.Builder.NewAtomContainerSet(); som.Add((IAtomContainer)obj); WriteAtomContainer(som); } catch (Exception ex) { if (!(ex is ArgumentException | ex is IOException)) { throw; } throw new CDKException("Error while writing HIN file: " + ex.Message, ex); } } else if (obj is IEnumerableChemObject <IAtomContainer> ) { try { WriteAtomContainer((IEnumerableChemObject <IAtomContainer>)obj); } catch (IOException) { // } } else { throw new CDKException("HINWriter only supports output of Molecule or SetOfMolecule classes."); } }
public virtual void TestGetRingSize() { IChemObject obj = NewChemObject(); IRing r = obj.Builder.NewRing(5, "C"); Assert.AreEqual(5, r.RingSize); }
/// <summary> Takes an object which subclasses IChemObject, e.g.Molecule, and will read /// this (from file, database, internet etc). If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object"> The object that subclasses /// IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IReaction) { return((IChemObject)readReaction(object_Renamed.Builder)); } else if (object_Renamed is IChemModel) { IChemModel model = object_Renamed.Builder.newChemModel(); ISetOfReactions reactionSet = object_Renamed.Builder.newSetOfReactions(); reactionSet.addReaction(readReaction(object_Renamed.Builder)); model.SetOfReactions = reactionSet; return(model); } else if (object_Renamed is IChemFile) { IChemFile chemFile = object_Renamed.Builder.newChemFile(); IChemSequence sequence = object_Renamed.Builder.newChemSequence(); sequence.addChemModel((IChemModel)read(object_Renamed.Builder.newChemModel())); chemFile.addChemSequence(sequence); return(chemFile); } else { throw new CDKException("Only supported are Reaction and ChemModel, and not " + object_Renamed.GetType().FullName + "."); } }
public virtual void TestGetFlagValue() { IChemObject chemObject = NewChemObject(); chemObject.Flag = CDKConstants.ISALIPHATIC, true; Assert.AreNotSame((short)0, chemObject.GetFlagValue()); }
//[ExpectedException(typeof(ArgumentException))] public virtual void TestGetProperty_Object_ClassCast() { IChemObject chemObject = NewChemObject(); chemObject.SetProperty("dummy", 5); Assert.IsNull(chemObject.GetProperty <object>("dummy") as string); }
public void TestNewChemObject_IChemObject() { IChemObjectBuilder builder = RootObject.Builder; IChemObject model = builder.NewChemObject(builder.NewChemObject()); Assert.IsNotNull(model); }
public IChemObject[] QueryConnected(IChemObject obj) { List <IChemObject> objs = new List <IChemObject>(); if (obj is IAtom) { // find connected bonds foreach (IBond bond in renderContext.bonds) { IAtom[] atoms = bond.getAtoms(); foreach (IAtom atom in atoms) { if (atom == obj) { // add bond objs.Add(bond); // add all other atoms on this bond foreach (IAtom a in atoms) { if (a != obj) { objs.Add(a); } } } } } } return(objs.ToArray()); }
/// <summary> Writes a IChemObject to the MDL molfile formated output. /// It can only output ChemObjects of type ChemFile, Molecule and /// SetOfMolecules. /// /// </summary> /// <param name="object">class must be of type ChemFile, Molecule or SetOfMolecules. /// /// </param> /// <seealso cref="org.openscience.cdk.ChemFile"> /// </seealso> public override void write(IChemObject object_Renamed) { if (object_Renamed is ISetOfMolecules) { writeSetOfMolecules((ISetOfMolecules)object_Renamed); } else if (object_Renamed is IChemFile) { writeChemFile((IChemFile)object_Renamed); } else if (object_Renamed is IMolecule) { try { bool[] isVisible = new bool[((IMolecule)object_Renamed).AtomCount]; for (int i = 0; i < isVisible.Length; i++) { isVisible[i] = true; } writeMolecule((IMolecule)object_Renamed, isVisible); } catch (System.Exception ex) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.error(ex.Message); //logger.debug(ex); //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" throw new CDKException("Exception while writing MDL file: " + ex.Message, ex); } } else { throw new CDKException("Only supported is writing of ChemFile, SetOfMolecules, AtomContainer and Molecule objects."); } }
private void WriteProperties(IChemObject obj, CMLElement cmlElement) { var props = obj.GetProperties(); foreach (var key in props.Keys) { var stringKey = (string)key; switch (stringKey) { case CDKPropertyName.Title: // don't output this one. It's covered by AddTitle() break; default: if (!(stringKey.StartsWith("org.openscience.cdk", StringComparison.Ordinal))) { object value = props[key]; var scalar = new CMLScalar(); this.CheckPrefix(scalar); scalar.Title = (string)key; scalar.Value = value.ToString(); cmlElement.Add(scalar); } break; } } }
public void TestMatchAgainstItself() { var m_atom1 = new Mock <IChemObject>(); IChemObject atom1 = m_atom1.Object; string result = ChemObjectDiff.Diff(atom1, atom1); AssertZeroLength(result); }
/// <summary> Takes an object which subclasses IChemObject, e.g. Molecule, and will read /// this (from file, database, internet etc). If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object">The object that subclasses IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { customizeJob(); try { if (object_Renamed is IChemSequence) { return(readReactions(false)); } else if (object_Renamed is IChemModel) { return(readReactions(true)); } else if (object_Renamed is IChemFile) { IChemFile chemFile = object_Renamed.Builder.newChemFile(); chemFile.addChemSequence((ChemSequence)readReactions(false)); return(chemFile); } } catch (System.IO.IOException exception) { //UPGRADE_ISSUE: Method 'java.io.LineNumberReader.getLineNumber' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioLineNumberReadergetLineNumber'" System.String message = "Error while reading file, line number: ";// +input.getLineNumber(); //logger.error(message); //logger.debug(exception); throw new CDKException(message, exception); } throw new CDKException("Only supported are ChemSequence and ChemModel."); }
private void SerializeChemObjectFields(INode rdfObject, IChemObject obj) { if (obj.Id != null) { g.Assert(new Triple(rdfObject, P_IDENTIFIER, g.CreateLiteralNode(obj.Id))); } }
/// <summary> /// Compare two <see cref="IChemObject"/> classes and return the difference as an <see cref="IDifference"/>. /// </summary> /// <param name="first">the first of the two classes to compare</param> /// <param name="second">the second of the two classes to compare</param> /// <returns>an <see cref="IDifference"/> representation of the difference between the first and second <see cref="IChemObject"/>.</returns> public static IDifference Difference(IChemObject first, IChemObject second) { if (!(first is IAtomContainer && second is IAtomContainer)) { return(null); } var firstAC = (IAtomContainer)first; var secondAC = (IAtomContainer)second; var totalDiff = new ChemObjectDifference("AtomContainerDiff"); totalDiff.AddChild(IntegerDifference.Construct("atomCount", firstAC.Atoms.Count, secondAC.Atoms.Count)); if (firstAC.Atoms.Count == secondAC.Atoms.Count) { for (int i = 0; i < firstAC.Atoms.Count; i++) { totalDiff.AddChild(AtomDiff.Difference(firstAC.Atoms[i], secondAC.Atoms[i])); } } totalDiff.AddChild(IntegerDifference.Construct("electronContainerCount", firstAC.GetElectronContainers().Count(), secondAC.GetElectronContainers().Count())); if (firstAC.GetElectronContainers().Count() == secondAC.GetElectronContainers().Count()) { for (int i = 0; i < firstAC.GetElectronContainers().Count(); i++) { if (firstAC.GetElectronContainers().ElementAt(i) is IBond && secondAC.GetElectronContainers().ElementAt(i) is IBond) { totalDiff.AddChild(BondDiff.Difference(firstAC.GetElectronContainers().ElementAt(i), secondAC.GetElectronContainers().ElementAt(i))); } else if (firstAC.GetElectronContainers().ElementAt(i) is ILonePair && secondAC.GetElectronContainers().ElementAt(i) is ILonePair) { totalDiff.AddChild(LonePairDiff.Difference(firstAC.GetElectronContainers().ElementAt(i), secondAC.GetElectronContainers().ElementAt(i))); } else if (firstAC.GetElectronContainers().ElementAt(i) is ISingleElectron && secondAC.GetElectronContainers().ElementAt(i) is ISingleElectron) { totalDiff.AddChild(SingleElectronDiff.Difference(firstAC.GetElectronContainers().ElementAt(i), secondAC.GetElectronContainers().ElementAt(i))); } else { totalDiff.AddChild(ElectronContainerDiff.Difference(firstAC.GetElectronContainers().ElementAt(i), secondAC.GetElectronContainers().ElementAt(i))); } } } totalDiff.AddChild(ChemObjectDiff.Difference(first, second)); if (totalDiff.ChildCount() > 0) { return(totalDiff); } else { return(null); } }
public virtual void TestClone_PropertyNull() { IChemObject chemObject = NewChemObject(); string key = "NullProperty"; chemObject.SetProperty(key, null); chemObject.Clone(); }
public virtual void TestGetFlags_Array() { IChemObject chemObject = NewChemObject(); chemObject.IsPlaced = true; bool[] flags = chemObject.GetFlags(); Assert.IsTrue(flags[1]); }
public virtual void TestSetID_String() { IChemObject chemObject = NewChemObject(); string id = "objectX"; chemObject.Id = id; Assert.AreEqual(id, chemObject.Id); }
public virtual void TestGetListenerCount() { IChemObject chemObject1 = NewChemObject(); DummyChemObjectListener listener = new DummyChemObjectListener(this); chemObject1.Listeners.Add(listener); Assert.AreEqual(1, chemObject1.Listeners.Count); }
public virtual void TestShallowCopy() { IChemObject chemObject = NewChemObject(); object clone = chemObject.Clone(); Assert.IsNotNull(clone); Assert.IsTrue(clone is IChemObject); }
public virtual bool accepts(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { return(true); } return(false); }
public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { return(readMolecule(object_Renamed.Builder)); } return(null); }
public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { IChemFile cf = (IChemFile)object_Renamed; try { cf = readChemFile(cf); } catch (System.IO.IOException exception) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" System.String error = "Input/Output error while reading from input: " + exception.Message; //logger.error(error); //logger.debug(exception); throw new CDKException(error, exception); } return cf; } else { throw new CDKException("Only supported is reading of ChemFile."); } }
public abstract void write(IChemObject param1);
public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemSequence) { return readChemSequence((IChemSequence)object_Renamed); } else if (object_Renamed is IChemFile) { return readChemFile((IChemFile)object_Renamed); } else { throw new CDKException("Object " + object_Renamed.GetType().FullName + " is not supported"); } }
/* (non-Javadoc) (Javadoc is automaticly inherited from the link below) * @see org.openscience.cdk.io.ChemObjectReader#read(org.openscience.cdk.ChemObject) */ public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { try { return (IChemObject)readChemFile((IChemFile)object_Renamed); } catch (System.IO.IOException e) { return null; } } else { throw new CDKException("Only supported is reading of ChemFile objects."); } }
public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { return readMolecule(object_Renamed.Builder); } return null; }
/// <summary> Read a ChemFile from input /// /// </summary> /// <returns> the content in a ChemFile object /// </returns> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { IChemFile cf = (IChemFile)object_Renamed; try { cf = readChemFile(cf); } catch (System.IO.IOException e) { //logger.error("Input/Output error while reading from input."); } return cf; } else { throw new CDKException("Only supported is reading of ChemFile."); } }
/// <summary> Writes a IChemObject to the MDL RXN file formated output. /// It can only output ChemObjects of type Reaction /// /// </summary> /// <param name="object">class must be of type Molecule or SetOfMolecules. /// /// </param> /// <seealso cref="org.openscience.cdk.ChemFile"> /// </seealso> public override void write(IChemObject object_Renamed) { if (object_Renamed is IReaction) { writeReaction((IReaction)object_Renamed); } else { throw new CDKException("Only supported is writing Reaction objects."); } }
/// <summary> /// Takes an object which subclasses IChemObject, e.g. Molecule, and will /// read this (from file, database, internet etc). If the specific /// implementation does not support a specific IChemObject it will throw /// an Exception. /// /// </summary> /// <param name="oObj"> The object that subclasses IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// /// </exception> public override IChemObject read(IChemObject oObj) { if (oObj is IChemFile) { if (pdbFactory == null) { try { pdbFactory = AtomTypeFactory.getInstance("pdb_atomtypes.xml", ((IChemFile)oObj).Builder); } catch (System.Exception exception) { //logger.debug(exception); //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" throw new CDKException("Could not setup list of PDB atom types! " + exception.Message); } } return readChemFile((IChemFile)oObj); } else { throw new CDKException("Only supported is reading of ChemFile objects."); } }
private static string GetNeutralChange(IChemObject ac, int hydrogensAdded) { var neutralLoss = ""; if (ac.getProperty("NlElementalComposition") != null && (string)ac.getProperty("NlElementalComposition") != "") { neutralLoss = "-" + ac.getProperty("NlElementalComposition") + " "; } var signString = hydrogensAdded < 0 ? "-" : "+"; switch (Math.Abs(hydrogensAdded)) { case 0: return neutralLoss; case 1: return string.Format("{0}{1}H", neutralLoss, signString); default: return string.Format("{0}{1}{2}H", neutralLoss, signString, Math.Abs(hydrogensAdded)); } }
/// <summary> Writes the content from object to output. /// /// </summary> /// <param name="object"> IChemObject of which the data is outputted. /// </param> public override void write(IChemObject object_Renamed) { if (object_Renamed is ISetOfMolecules) { writeSetOfMolecules((ISetOfMolecules)object_Renamed); } else if (object_Renamed is IMolecule) { writeMolecule((IMolecule)object_Renamed); } else { throw new CDKException("Only supported is writing of ChemFile and Molecule objects."); } }
public virtual bool accepts(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { } else if (object_Renamed is IChemModel) { return true; } return false; }
public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemModel) { return (IChemObject)readChemModel((IChemModel)object_Renamed); } else { throw new CDKException("Only supported is ChemModel."); } }
/// <summary> Constructs an unconnected lone pair. /// /// </summary> /// <param name="objectOne">The first IChemObject of the mapping /// </param> /// <param name="objectTwo">The second IChemObject of the mapping /// </param> public Mapping(IChemObject objectOne, IChemObject objectTwo) { relation = new IChemObject[2]; relation[0] = objectOne; relation[1] = objectTwo; }
public virtual bool accepts(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { return true; } return false; }
public virtual IMapping newMapping(IChemObject objectOne, IChemObject objectTwo) { return new Mapping(objectOne, objectTwo); }
public override void write(IChemObject object_Renamed) { if (object_Renamed is IMolecule) { try { writeMolecule((IMolecule)object_Renamed); } catch (System.Exception ex) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.error(ex.Message); //logger.debug(ex); } } else { throw new CDKException("Only supported is writing of Molecule objects."); } }
public IChemObject[] QueryConnected(IChemObject obj) { List<IChemObject> objs = new List<IChemObject>(); if (obj is IAtom) { // find connected bonds foreach (IBond bond in renderContext.bonds) { IAtom[] atoms = bond.getAtoms(); foreach (IAtom atom in atoms) { if (atom == obj) { // add bond objs.Add(bond); // add all other atoms on this bond foreach (IAtom a in atoms) { if (a != obj) objs.Add(a); } } } } } return objs.ToArray(); }
/// <summary> Takes an object which subclasses IChemObject, e.g.Molecule, and will read /// this (from file, database, internet etc). If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object"> The object that subclasses /// IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IReaction) { return (IChemObject)readReaction(object_Renamed.Builder); } else if (object_Renamed is IChemModel) { IChemModel model = object_Renamed.Builder.newChemModel(); ISetOfReactions reactionSet = object_Renamed.Builder.newSetOfReactions(); reactionSet.addReaction(readReaction(object_Renamed.Builder)); model.SetOfReactions = reactionSet; return model; } else if (object_Renamed is IChemFile) { IChemFile chemFile = object_Renamed.Builder.newChemFile(); IChemSequence sequence = object_Renamed.Builder.newChemSequence(); sequence.addChemModel((IChemModel)read(object_Renamed.Builder.newChemModel())); chemFile.addChemSequence(sequence); return chemFile; } else { throw new CDKException("Only supported are Reaction and ChemModel, and not " + object_Renamed.GetType().FullName + "."); } }
public abstract IChemObject read(IChemObject param1);
public virtual bool accepts(IChemObject object_Renamed) { if (object_Renamed is ChemSequence) { return true; } else if (object_Renamed is ChemModel) { return true; } else if (object_Renamed is ChemFile) { return true; } else if (object_Renamed == null) { //logger.warn("MACiEReader can not read null objects."); } else { //logger.warn("MACiEReader can not read IChemObject of type: ", object_Renamed.GetType().FullName); } return false; }
private void addDictRefedAnnotation(IChemObject object_Renamed, System.String type, System.String values) { SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(values, ","); while (tokenizer.HasMoreTokens()) { System.String token = tokenizer.NextToken(); object_Renamed.setProperty(new DictRef("macie:" + type, token), token); //logger.debug("Added dict ref ", token, " to ", object_Renamed.GetType().FullName); } }
/// <summary> Takes an object which subclasses IChemObject, e.g.Molecule, and will read /// this from from the Reader. If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object">The object that subclasses IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { IChemFile file = (IChemFile)object_Renamed; IChemSequence sequence = file.Builder.newChemSequence(); IChemModel model = file.Builder.newChemModel(); ISetOfMolecules moleculeSet = file.Builder.newSetOfMolecules(); moleculeSet.addMolecule(readMolecule(model.Builder.newMolecule())); model.SetOfMolecules = moleculeSet; sequence.addChemModel(model); file.addChemSequence(sequence); return file; } else if (object_Renamed is IChemModel) { IChemModel model = (IChemModel)object_Renamed; ISetOfMolecules moleculeSet = model.Builder.newSetOfMolecules(); moleculeSet.addMolecule(readMolecule(model.Builder.newMolecule())); model.SetOfMolecules = moleculeSet; return model; } else { throw new CDKException("Only supported is ChemModel, and not " + object_Renamed.GetType().FullName + "."); } }
/// <summary> get the IAtom which is mapped /// /// </summary> /// <param name="reaction"> The IReaction which contains the mapping /// </param> /// <param name="chemObject">The IChemObject which will be searched its mapped IChemObject /// </param> /// <returns> The mapped IChemObject /// </returns> public static IChemObject getMappedChemObject(IReaction reaction, IChemObject chemObject) { IMapping[] mappings = reaction.Mappings; for (int i = 0; i < mappings.Length; i++) { IMapping mapping = mappings[i]; IChemObject[] map = mapping.RelatedChemObjects; if (map[0].Equals(chemObject)) { return map[1]; } else if (map[1].Equals(chemObject)) return map[0]; } return null; }
private void BuildNodes(TreeNode rootNode, IChemObject[] objects) { foreach (IChemObject obj in objects) { TreeNode node; if (obj is IChemSequence) { IChemSequence seq = (IChemSequence)obj; node = new TreeNode(obj.GetType().Name + ":" + seq.ID); BuildNodes(node, seq.ChemModels); } else if (obj is IChemModel) { IChemModel mdl = (IChemModel)obj; node = new TreeNode(mdl.GetType().Name + ":" + mdl.ID); if (mdl.Crystal != null) node.Nodes.Add(mdl.Crystal.GetType().Name + ":" + mdl.Crystal.ID); else node.Nodes.Add("ICrystal:null"); if (mdl.RingSet != null) node.Nodes.Add(mdl.RingSet.GetType().Name + ":" + mdl.RingSet.ID); else node.Nodes.Add("IRingSet:null"); if (mdl.SetOfReactions != null) node.Nodes.Add(mdl.SetOfReactions.GetType().Name + ":" + mdl.SetOfReactions.ID); else node.Nodes.Add("ISetOfReactions:null"); BuildNodes(node, mdl.SetOfMolecules.Molecules); } else if (obj is IMolecule) { IMolecule mol = (IMolecule)obj; node = new TreeNode(mol.GetType().Name + ":" + mol.ID); BuildNodes(node, mol.Atoms); BuildNodes(node, mol.Bonds); } else if (obj is IAtom) { IAtom atom = (IAtom)obj; node = new TreeNode(atom.GetType().Name + ":" + atom.ID); } else if (obj is IBond) { IBond bond = (IBond)obj; node = new TreeNode(bond.GetType().Name + ":" + bond.ID); } else node = new TreeNode(obj.GetType().Name + ":" + obj.ID); rootNode.Nodes.Add(node); } }
/// <summary> reads the content from a XYZ input. It can only return a /// IChemObject of type ChemFile /// /// </summary> /// <param name="object">class must be of type ChemFile /// /// </param> /// <seealso cref="IChemFile"> /// </seealso> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) { return (IChemObject)readChemFile((IChemFile)object_Renamed); } else { throw new CDKException("Only supported is reading of ChemFile objects."); } }
/// <summary> Takes an object which subclasses IChemObject, e.g. Molecule, and will read /// this (from file, database, internet etc). If the specific implementation /// does not support a specific IChemObject it will throw an Exception. /// /// </summary> /// <param name="object">The object that subclasses IChemObject /// </param> /// <returns> The IChemObject read /// </returns> /// <exception cref="CDKException"> /// </exception> public override IChemObject read(IChemObject object_Renamed) { customizeJob(); try { if (object_Renamed is IChemSequence) { return readReactions(false); } else if (object_Renamed is IChemModel) { return readReactions(true); } else if (object_Renamed is IChemFile) { IChemFile chemFile = object_Renamed.Builder.newChemFile(); chemFile.addChemSequence((ChemSequence)readReactions(false)); return chemFile; } } catch (System.IO.IOException exception) { //UPGRADE_ISSUE: Method 'java.io.LineNumberReader.getLineNumber' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioLineNumberReadergetLineNumber'" System.String message = "Error while reading file, line number: ";// +input.getLineNumber(); //logger.error(message); //logger.debug(exception); throw new CDKException(message, exception); } throw new CDKException("Only supported are ChemSequence and ChemModel."); }
/// <summary> Returns a IChemObject of type object bye reading from /// the input. /// /// The function supports only reading of ChemFile's. /// /// </summary> /// <param name="object"> IChemObject that types the class to return. /// </param> /// <throws> Exception when a IChemObject is requested that cannot be read. </throws> public override IChemObject read(IChemObject object_Renamed) { if (object_Renamed is IChemFile) return (IChemObject)readChemFile((IChemFile)object_Renamed); else throw new CDKException("Only ChemFile objects can be read."); }
/// <summary> Description of the Method /// /// </summary> /// <param name="object">Description of the Parameter /// </param> /// <returns> Description of the Return Value /// </returns> /// <throws> CDKException Description of the Exception </throws> public override IChemObject read(IChemObject object_Renamed) { customizeJob(); if (object_Renamed is IChemFile) { IChemFile file = (IChemFile)object_Renamed; try { file = readChemFile(file); } catch (System.IO.IOException exception) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" throw new CDKException("Error while reading file: " + exception.ToString(), exception); } return file; } else { throw new CDKException("Reading of a " + object_Renamed.GetType().FullName + " is not supported."); } }