public void test_Parameter_createWithNS() { XMLNamespaces xmlns = new XMLNamespaces(); xmlns.add("http://www.sbml.org", "testsbml"); SBMLNamespaces sbmlns = new SBMLNamespaces(2, 1); sbmlns.addNamespaces(xmlns); Parameter object = new Parameter(sbmlns); assertTrue(object.getTypeCode() == libsbml.SBML_PARAMETER); assertTrue(object.getMetaId().equals("") == true); assertTrue(object.getNotes() == null); assertTrue(object.getAnnotation() == null); assertTrue(object.getLevel() == 2); assertTrue(object.getVersion() == 1); assertTrue(object.getNamespaces() != null); assertTrue(object.getNamespaces().getLength() == 2); object = null; }
/** * Returns <code>true</code> or <code>false</code> depending on whether the given {@link XMLNode} * object contains valid XHTML content. * * <p>In SBML, the content of the 'notes' subelement available on {@link SBase}, as well as the * 'message' subelement available on {@link Constraint}, must conform to <a target='_blank' * href='http://www.w3.org/TR/xhtml1/'>XHTML 1.0</a> (which is simply an XML-ized version of * HTML). However, the content cannot be <em>entirely</em> free-form; it must satisfy certain * requirements defined in the <a target='_blank' * href='http://sbml.org/Documents/Specifications'>SBML specifications</a> for specific SBML * Levels. This method implements a verification process that lets callers check whether the * content of a given {@link XMLNode} object conforms to the SBML requirements for 'notes' and * 'message' structure. * * <p>An aspect of XHTML validity is that the content is declared to be in the XML namespace for * XHTML 1.0. There is more than one way in which this can be done in XML. In particular, a * model might not contain the declaration within the 'notes' or 'message' subelement itself, but * might instead place the declaration on an enclosing element and use an XML namespace prefix * within the 'notes' element to refer to it. In other words, the following is valid: <div * class='fragment'> * * <pre> * <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3' * xmlns:xhtml='http://www.w3.org/1999/xhtml'> * <model> * <notes> * <xhtml:body> * <xhtml:center><xhtml:h2>A Simple Mitotic Oscillator</xhtml:h2></xhtml:center> * <xhtml:p>A minimal cascade model for the mitotic oscillator.</xhtml:p> * </xhtml:body> * </notes> * ... rest of model ... * </sbml> * </pre> * * </div> Contrast the above with the following, self-contained version, which places the XML * namespace declaration within the <code><notes></code> element itself: <div * class='fragment'> * * <pre> * <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'> * <model> * <notes> * <html xmlns='http://www.w3.org/1999/xhtml'> * <head> * <title/> * </head> * <body> * <center><h2>A Simple Mitotic Oscillator</h2></center> * A minimal cascade model for the mitotic oscillator.</p> * </body> * </html> * </notes> * ... rest of model ... * </sbml> * </pre> * * </div> * * <p>Both of the above are valid XML. The purpose of the <code>sbmlns</code> argument to this * method is to allow callers to check the validity of 'notes' and 'message' subelements whose XML * namespace declarations have been put elsewhere in the manner illustrated above. Callers can can * pass in the {@link SBMLNamespaces} object of a higher-level model component if the {@link * XMLNode} object does not itself have the XML namespace declaration for XHTML 1.0. * * <p> * * @param xhtml the {@link XMLNode} to be checked for conformance. * @param sbmlns the {@link SBMLNamespaces} associated with the object. * <p> * @return <code>true</code> if the {@link XMLNode} content conforms, <code>false</code> * otherwise. * <p> * @docnote The native C++ implementation of this method defines a default argument value. In the * documentation generated for different libSBML language bindings, you may or may not see * corresponding arguments in the method declarations. For example, in Java, a default * argument is handled by declaring two separate methods, with one of them having the argument * and the other one lacking the argument. However, the libSBML documentation will be * <em>identical</em> for both methods. Consequently, if you are reading this and do not see * an argument even though one is described, please look for descriptions of other variants of * this method near where this one appears in the documentation. */ public static boolean hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns) { return libsbmlJNI.SyntaxChecker_hasExpectedXHTMLSyntax__SWIG_0( XMLNode.getCPtr(xhtml), xhtml, SBMLNamespaces.getCPtr(sbmlns), sbmlns); }
/** * Creates a new {@link UnitDefinition} using the given {@link SBMLNamespaces} object <code>sbmlns * </code>. * * <p> * * <p>The {@link SBMLNamespaces} object encapsulates SBML Level/Version/namespaces information. It * is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition * to SBML Level 3 Core. A common approach to using libSBML's {@link SBMLNamespaces} * facilities is to create an {@link SBMLNamespaces} object somewhere in a program once, then hand * that object as needed to object constructors that accept {@link SBMLNamespaces} as arguments. * * <p> * * @param sbmlns an {@link SBMLNamespaces} object. * <p> * @throws SBMLConstructorException Thrown if the given <code>level</code> and <code>version * </code> combination, or this kind of SBML object, are either invalid or mismatched with * respect to the parent {@link SBMLDocument} object. * <p> * <p> * @note Attempting to add an object to an {@link SBMLDocument} having a different combination of * SBML Level, Version and XML namespaces than the object itself will result in an error at * the time a caller attempts to make the addition. A parent object must have compatible * Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML * namespaces than a child, but the reverse is not permitted.) The restriction is necessary to * ensure that an SBML model has a consistent overall structure. This requires callers to * manage their objects carefully, but the benefit is increased flexibility in how models can * be created by permitting callers to create objects bottom-up if desired. In situations * where objects are not yet attached to parents (e.g., {@link SBMLDocument}), knowledge of * the intented SBML Level and Version help libSBML determine such things as whether it is * valid to assign a particular value to an attribute. */ public UnitDefinition(SBMLNamespaces sbmlns) throws org.sbml.libsbml.SBMLConstructorException { this(libsbmlJNI.new_UnitDefinition__SWIG_1(SBMLNamespaces.getCPtr(sbmlns), sbmlns), true); }
/** * Creates a new {@link LocalParameter} object with the given {@link SBMLNamespaces} object <code> * sbmlns</code>. * * <p> * * <p>The {@link SBMLNamespaces} object encapsulates SBML Level/Version/namespaces information. It * is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition * to SBML Level 3 Core. A common approach to using libSBML's {@link SBMLNamespaces} * facilities is to create an {@link SBMLNamespaces} object somewhere in a program once, then hand * that object as needed to object constructors that accept {@link SBMLNamespaces} as arguments. * * <p>It is worth emphasizing that although this constructor does not take an identifier argument, * in SBML Level 2 and beyond, the 'id' (identifier) attribute of a {@link LocalParameter} is * required to have a value. Thus, callers are cautioned to assign a value after calling this * constructor if no identifier is provided as an argument. Setting the identifier can be * accomplished using the method setId(String id). * * <p> * * @param sbmlns an {@link SBMLNamespaces} object. * <p> * @throws SBMLConstructorException Thrown if the given <code>level</code> and <code>version * </code> combination, or this kind of SBML object, are either invalid or mismatched with * respect to the parent {@link SBMLDocument} object. * <p> * <p> * @note Upon the addition of a {@link Compartment} object to an {@link SBMLDocument} (e.g., using * {@link Model#addCompartment(Compartment c)}), the SBML Level, SBML Version and XML * namespace of the document <em>override</em> the values used when creating the {@link * Compartment} object via the {@link Compartment} constructors. This is necessary to ensure * that an SBML document has a consistent overall structure. Nevertheless, the ability to * supply the values at the time of creation of a {@link Compartment} is an important aid to * producing valid SBML. Knowledge of the intented SBML Level and Version determine whether it * is valid to assign a particular value to an attribute, or whether it is valid to add an * object to an existing {@link SBMLDocument}. */ public LocalParameter(SBMLNamespaces sbmlns) throws org.sbml.libsbml.SBMLConstructorException { this(libsbmlJNI.new_LocalParameter__SWIG_1(SBMLNamespaces.getCPtr(sbmlns), sbmlns), true); }
/** * Creates a new {@link ListOfSpeciesReferences} object. * * <p>The object is constructed such that it is valid for the SBML Level and Version combination * determined by the {@link SBMLNamespaces} object in <code>sbmlns</code>. * * <p> * * @param sbmlns an {@link SBMLNamespaces} object that is used to determine the characteristics of * the {@link ListOfSpeciesReferences} object to be created. */ public ListOfSpeciesReferences(SBMLNamespaces sbmlns) throws org.sbml.libsbml.SBMLConstructorException { this( libsbmlJNI.new_ListOfSpeciesReferences__SWIG_1(SBMLNamespaces.getCPtr(sbmlns), sbmlns), true); }
/** * Creates a new {@link Event} using the given {@link SBMLNamespaces} object <code>sbmlns</code>. * * <p> * * <p>The {@link SBMLNamespaces} object encapsulates SBML Level/Version/namespaces information. It * is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition * to SBML Level 3 Core. A common approach to using libSBML's {@link SBMLNamespaces} * facilities is to create an {@link SBMLNamespaces} object somewhere in a program once, then hand * that object as needed to object constructors that accept {@link SBMLNamespaces} as arguments. * * <p> * * @param sbmlns an {@link SBMLNamespaces} object. * <p> * @throws SBMLConstructorException Thrown if the given <code>level</code> and <code>version * </code> combination, or this kind of SBML object, are either invalid or mismatched with * respect to the parent {@link SBMLDocument} object. * <p> * <p> * @note Upon the addition of an {@link Event} object to an {@link SBMLDocument} (e.g., using * {@link Model#addEvent(Event e)}), the SBML Level, SBML Version and XML namespace of the * document <em>override</em> the values used when creating the {@link Event} object via this * constructor. This is necessary to ensure that an SBML document is a consistent structure. * Nevertheless, the ability to supply the values at the time of creation of an {@link Event} * is an important aid to producing valid SBML. Knowledge of the intented SBML Level and * Version determine whether it is valid to assign a particular value to an attribute, or * whether it is valid to add an object to an existing {@link SBMLDocument}. */ public Event(SBMLNamespaces sbmlns) throws org.sbml.libsbml.SBMLConstructorException { this(libsbmlJNI.new_Event__SWIG_1(SBMLNamespaces.getCPtr(sbmlns), sbmlns), true); }