/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return CMLAttribute */ public CMLAttribute getFormatAttribute() { return (CMLAttribute) getAttribute("format"); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @param reactionStep child to add */ public void addReactionStep(AbstractReactionStep reactionStep) { reactionStep.detach(); this.appendChild(reactionStep); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return CMLElements<CMLLabel> */ public CMLElements<CMLLabel> getLabelElements() { Elements elements = this.getChildElements("label", CMLConstants.CML_NS); return new CMLElements<CMLLabel>(elements); } // element: reactionStep
/** null * @return String */ public String getDictRef() { DictRefAttribute att = (DictRefAttribute) this.getDictRefAttribute(); if (att == null) { return null; } return att.getString(); } /** null
/** null * @return String */ public String getRef() { RefAttribute att = (RefAttribute) this.getRefAttribute(); if (att == null) { return null; } return att.getString(); } /** null
/** A title on an element. * No controlled value. * @return String */ public String getTitle() { StringSTAttribute att = (StringSTAttribute) this.getTitleAttribute(); if (att == null) { return null; } return att.getString(); } /** A title on an element.
/** null * @return String */ public String getId() { IdAttribute att = (IdAttribute) this.getIdAttribute(); if (att == null) { return null; } return att.getString(); } /** null
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return String */ public String getFormat() { StringSTAttribute att = (StringSTAttribute) this.getFormatAttribute(); if (att == null) { return null; } return att.getString(); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @param reactionStepList child to add */ public void addReactionStepList(AbstractReactionStepList reactionStepList) { reactionStepList.detach(); this.appendChild(reactionStepList); } /** Format of the reaction component.
/** A reference to a convention. * There is no controlled vocabulary for conventions, but the author must ensure that the semantics are openly available and that there are mechanisms for implementation. The convention is inherited by all the subelements, * so that a convention for molecule would by default extend to its bond and atom children. This can be overwritten * if necessary by an explicit convention. * It may be useful to create conventions with namespaces (e.g. iupac:name). * Use of convention will normally require non-STMML semantics, and should be used with * caution. We would expect that conventions prefixed with "ISO" would be useful, * such as ISO8601 for dateTimes. * There is no default, but the conventions of STMML or the related language (e.g. CML) will be assumed. * @return String */ public String getConvention() { StringSTAttribute att = (StringSTAttribute) this.getConventionAttribute(); if (att == null) { return null; } return att.getString(); } /** A reference to a convention.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @param label child to add */ public void addLabel(AbstractLabel label) { label.detach(); this.appendChild(label); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return CMLElements<CMLMetadataList> */ public CMLElements<CMLMetadataList> getMetadataListElements() { Elements elements = this.getChildElements("metadataList", CMLConstants.CML_NS); return new CMLElements<CMLMetadataList>(elements); } // element: name
/** null * @return CMLAttribute */ public CMLAttribute getRefAttribute() { return (CMLAttribute) getAttribute("ref"); } /** null
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @param metadataList child to add */ public void addMetadataList(AbstractMetadataList metadataList) { metadataList.detach(); this.appendChild(metadataList); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return CMLElements<CMLReactionStep> */ public CMLElements<CMLReactionStep> getReactionStepElements() { Elements elements = this.getChildElements("reactionStep", CMLConstants.CML_NS); return new CMLElements<CMLReactionStep>(elements); } /** overrides addAttribute(Attribute)
/** Type of the object. * A qualifier which may affect the semantics of the object. * @return CMLAttribute */ public CMLAttribute getTypeAttribute() { return (CMLAttribute) getAttribute("type"); } /** Type of the object.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @param name child to add */ public void addName(AbstractName name) { name.detach(); this.appendChild(name); } /** Format of the reaction component.
/** Format of the reaction component. * Indicates how the components of reactionScheme, reactionStepList, etc. should be processed. No controlled vocabulary. One example is format="cmlSnap" asserts that the processor can assume that the reactants and products can be rendered using the CMLSnap design. Note that the reaction can be interpreted without reference to the format, which is primarily a processing instruction. * @return CMLElements<CMLName> */ public CMLElements<CMLName> getNameElements() { Elements elements = this.getChildElements("name", CMLConstants.CML_NS); return new CMLElements<CMLName>(elements); } // element: label
/** null * @return CMLAttribute */ public CMLAttribute getIdAttribute() { return (CMLAttribute) getAttribute("id"); } /** null
/** A title on an element. * No controlled value. * @return CMLAttribute */ public CMLAttribute getTitleAttribute() { return (CMLAttribute) getAttribute("title"); } /** A title on an element.