Home >> All >> org >> xmlcml

•	org.xmlcml.cml.* (97)	•	org.xmlcml.cmlimpl.* (131)	•	org.xmlcml.jmol.* (1)	•	org.xmlcml.legacy.* (7)
•	org.xmlcml.molutil.* (2)	•	org.xmlcml.noncml.* (54)	•	org.xmlcml.simplecml.* (4)

Package Samples:

• org.xmlcml.cml.topology: CoreCML index  
• org.xmlcml.cml.metadata
• org.xmlcml.cml
• org.xmlcml.cml.mvc
• org.xmlcml.cml.normalise
• org.xmlcml.cml.query
• org.xmlcml.cml.style
• org.xmlcml.cml.subset
• org.xmlcml.cmlimpl.jumbo3
• org.xmlcml.cmlimpl.metadata
• org.xmlcml.cmlimpl.normalise
• org.xmlcml.cmlimpl.query
• org.xmlcml.cmlimpl.stereo
• org.xmlcml.cmlimpl.style
• org.xmlcml.cmlimpl.subset
• org.xmlcml.cmlimpl.topology
• org.xmlcml.cmlimpl
• org.xmlcml.jmol
• org.xmlcml.legacy

Classes:

• AbstractBase: The base class for all elementObjects mentioned in the CML DTD. Any CML element may have attributes: title id dictRef convention and convenience get/set methods are provided for all, through the interfaces AttributeTitle, AttributeId and AttributeConvention. An element (FOO) subclassed from a AbstractBase may be constructed in the following ways: FOO(). Creates a new empty element with null values of the attributes. Required for newInstance(), but use carefully since it has no tagName and no document associated with it. FOO(String tagName, Document document). Creates an empty element with null ...
• CMLBaseImpl: The base class for all elementObjects mentioned in the CML DTD. Any CML element may have attributes: title id dictRef convention and convenience get/set methods are provided for all, through the interfaces AttributeTitle, AttributeId and AttributeConvention. An element (FOO) subclassed from a AbstractBase may be constructed in the following ways: FOO(). Creates a new empty element with null values of the attributes. Required for newInstance(), but use carefully since it has no tagName and no document associated with it. FOO(String tagName, Document document). Creates an empty element with null ...
• JUMBOBaseImpl: The base class for all elementObjects mentioned in the CML DTD. Any CML element may have attributes: title id dictRef convention and convenience get/set methods are provided for all, through the interfaces AttributeTitle, AttributeId and AttributeConvention. An element (FOO) subclassed from a AbstractBase may be constructed in the following ways: FOO(). Creates a new empty element with null values of the attributes. Required for newInstance(), but use carefully since it has no tagName and no document associated with it. FOO(String tagName, Document document). Creates an empty element with null ...
• CMLLink: a link to an object - usually from org.xmlcml.cml - but could be anything uses XLink semantics where possible. CMLLink will normally refer to a locator. At present only a subset of Xlink is appropriate for chemical objects The link may mave a type associated which can be dereferenced to an object of that type. The link can have a count acting as a multiplier for the targeted Object. It will not normally create additional objects, and is more likely to be used like: <link type="molecule" href="#water" count="10"/> could occure in Sodium Sulfate (Na2SO4.10H20) License: This document may be freely ...
• CMLList: list is a generic container which has no predetermined children or attributes and use the DOM emthods to access them <list title="amide"> <link href="#c1/> <link href="#n1/> <link href="#o1/> </list> License: This document may be freely copied but not modified in any way without the permission of the author. For full license information CMLDocument all children and attributes are accessed using DOM methods
• CMLFormula: CORE Interface DTD Class Semantics being developed. Will certainly manage element counts, recursive. Although not defined in the DTD, the data model corresponds to: <formula> <formula> <string builtin="elementType" count="2">Na <string builtin="elementType">S <string builtin="elementType" count="4">O </formula> <formula count="10"> <string builtin="elementType" count="2">H <string builtin="elementType">O </formula> </formula> which corresponds to Na2SO4.10H2O. The counts can be non-integer.
• SimpleMolecule: SimpleMolecule manages a subset of CML functionality for molecules. It lacks many of the more sophisticated methods and exposes the atoms and bonds as public vectors It should only be used with SimpleBond and SimpleAtom. Typical code: SimpleMolecule mol = new SimpleMolecule(); SimpleAtom atom1 = new SimpleAtom(); atom1.elementType="C"; atom1.id="c1"; atomVector.addElement(atom1); SimpleAtom atom2 = new SimpleAtom(); atom2.elementType="O"; atom2.id="o2"; atomVector.addElement(atom2); SimpleBond bond = new SimpleBond(); bond.atomRef1 = atom1; bond.atomRef2 = atom2; bond.order = "T"; bondVector.a ...
• CMLEventHandler: SAX-like CML reader, hacked from David Megginson's AElfred demo; although this is deprecated, it is used to provide 1.02 compatibility also it is unlikely that its problems will be relevant in chemistry. Methods in this class are not called directly, but by Aelfred. Typical usage: try { CMLEventHandler evh = new CMLEventHandler(); evh.doParse(fileName); SimpleMolecule mol = evh.topMolecule; } catch (Exception e) { e.printStackTrace(); System.out.println("Failed to read file: "+e); } mol can then be used as a SimpleMolecule
• CMLMolecule: CORE Interface CMLMolecule is the basic container for Atoms, Bonds, Electrons Angles, CMLTorsion, Sequences, Features, CMLCrystal and other objects. Molecules may contain other Molecules. When objects such as CMLAtomArray are set or added they are deep-copied, to avoid unpleasant surprises later. In general CMLAtom, CMLAtomArray, CMLBond, CMLBondArray should not be shared between different molecules. A molecule has only one set of Atoms and Bonds - if a molecule is created with CMLAtomArray and an CMLAtom is subsequently added, the components are effectively merged.
• StyleableMolecule: CMLMolecule is the basic container for Atoms, Bonds, Electrons Angles, CMLTorsion, Sequences, Features, CMLCrystal and other objects. Molecules may contain other Molecules. When objects such as CMLAtomArray are set or added they are deep-copied, to avoid unpleasant surprises later. In general CMLAtom, CMLAtomArray, CMLBond, CMLBondArray should not be shared between different molecules. A molecule has only one set of Atoms and Bonds - if a molecule is created with CMLAtomArray and an CMLAtom is subsequently added, the components are effectively merged.
• MoleculeImpl: CMLMolecule is the basic container for Atoms, Bonds, Electrons Angles, CMLTorsion, Sequences, Features, CMLCrystal and other objects. Molecules may contain other Molecules. When objects such as CMLAtomArray are set or added they are deep-copied, to avoid unpleasant surprises later. In general CMLAtom, CMLAtomArray, CMLBond, CMLBondArray should not be shared between different molecules. A molecule has only one set of Atoms and Bonds - if a molecule is created with CMLAtomArray and an CMLAtom is subsequently added, the components are effectively merged.
• JUMBOMoleculeImpl: CMLMolecule is the basic container for Atoms, Bonds, Electrons Angles, CMLTorsion, Sequences, Features, CMLCrystal and other objects. Molecules may contain other Molecules. When objects such as CMLAtomArray are set or added they are deep-copied, to avoid unpleasant surprises later. In general CMLAtom, CMLAtomArray, CMLBond, CMLBondArray should not be shared between different molecules. A molecule has only one set of Atoms and Bonds - if a molecule is created with CMLAtomArray and an CMLAtom is subsequently added, the components are effectively merged.
• AbstractAtom: Base class for atomic information . Declares various static variables. Not directly used License: This document may be freely copied but not modified in any way without the permission of the author. For full license information CMLDocument
• SMILESAtom: parse a SMILES atom [....]. Interprets leading characters of a String as a SMILES atom (used for parsing SMILES. Typical usage: s = "[13C@H3-2]NOS" SMILESAtom sa = new SMILESAtom(s); String rest = s.substring(sa.getLength()); int isotope = sa.getIsotope(); String element = sa.getElementType(); String chiral = sa.getChiral(); int hCount = sa.getHydrogenCount(); int ch = sa.getFormalCharge() At present SMARTS is not supported
• AminoAcid: Provides the properties for a given aminoacid type; can retrieve these by 1- or 3(+)-letter codes; the latter has the capability of expanding to (say) HPRO, ORN, etc, whilst 1-letters are limited to one character. The term '3-letter' will refer to longer strings where necessary Note that this class has (say) 20 instances and is effectively a provider of reference data and resettable properties such as colours.
• SimpleBond: SimpleBond manages a subset of CML functionality for atoms. It lacks many of the more sophisticated setters and getters and exposes the bond children directly (e.g. order). It should only be used with SimpleMolecule and SimpleAtom. Typical code: SimpleAtom bond = new SimpleBond(); bond.atomRef1 = atom23; bond.atomRef2 = atom25; bond.order = "S";
• SimpleAtom: SimpleAtom manages a subset of CML functionality for atoms. It lacks many of the more sophisticated setters and getters and exposes the atom children directly (e.g. hydrogenCount). It should only be used with SimpleMolecule and SimpleBond. Typical code: SimpleAtom atom = new SimpleAtom(); atom.id = "a123"; atom.elementType="Na"; atom.formalCharge=1;
• CMLAtomParity: CORE Interface DTD Class interface supporting atom-based parity . It requires 3 or 4 atomRefs to define the parity. At present the values are doubles and only the sign is important (the values could be computed as chiral volumes)
• CML: a general top-level container. This is useful for indicating that there is an "island" of CML in a multinamespace document, e.g. <cml> <molecule> </molecule> <molecule> </molecule> </cml> It is never essential, and there are no semanmtics or meaningful Java code (yet).
• AtomSetImpl: a set of atoms. Counts number of times an atom has been added (e.g. for bonds). An AtomSet may have coordinates associated with it which may or may not be related to the molecule. This should make calcuation of fragment geometries easier and therefore assembly less painful
• MDLMol: class to read (? and write?) mdl-molfiles as described in chemical MIME. NOTE: I have not been able to find any public statement of the format and am unable to guarantee the correctness of any code which interprets Mol files.
• MDLMolImpl: class to read (? and write?) mdl-molfiles as described in chemical MIME. NOTE: I have not been able to find any public statement of the format and am unable to guarantee the correctness of any code which interprets Mol files.
• AttributeAtomRefs: some Objects (e.g. CMLBond, CMLAngle) have references to Atoms. If an CMLAtom is changed or deleted it may affect these Objects. The AttributeAtomRefs identifies these Objects and allows access to the Atoms
• CMLCrystal: CORE Interface DTD Class Supports a crystallographic unit cell (parameters and spacegroup). Provision for symmetry is limited
• CMLAtomArray: DTD Class this interface is only used if AtomArrays are stored as such in the DOM . It may become obsolete since atomArray is only a syntactic container

Home | Contact Us | Privacy Policy | Terms of Service