/*
*
* Subclasses should override this method to write their xmlns attriubutes
* (if any) to the XMLOutputStream. Be sure to call your parents implementation
* of this method as well.
*
*/
void
SedDocument::writeXMLNS (XMLOutputStream& stream) const
{
// need to check that we have indeed a namespace set!
XMLNamespaces * thisNs = this->getNamespaces();
// the sbml namespace is missing - add it
if (thisNs == NULL)
{
XMLNamespaces xmlns;
xmlns.add(SEDML_XMLNS_L1);
mSedNamespaces->setNamespaces(&xmlns);
thisNs = getNamespaces();
}
else if (thisNs->getLength() == 0)
{
thisNs->add(SEDML_XMLNS_L1);
}
else
{
// check that there is an sbml namespace
std::string sedmlURI = SedNamespaces::getSedNamespaceURI(mLevel, mVersion);
std::string sedmlPrefix = thisNs->getPrefix(sedmlURI);
if (thisNs->hasNS(sedmlURI, sedmlPrefix) == false)
{
// the sbml ns is not present
std::string other = thisNs->getURI(sedmlPrefix);
if (other.empty() == false)
{
// there is another ns with the prefix that the sbml ns expects to have
//remove the this ns, add the sbml ns and
//add the new ns with a new prefix
thisNs->remove(sedmlPrefix);
thisNs->add(sedmlURI, sedmlPrefix);
thisNs->add(other, "addedPrefix");
}
else
{
thisNs->add(sedmlURI, sedmlPrefix);
}
}
}
XMLNamespaces * xmlns = thisNs->clone();
if (xmlns != NULL)
{
stream << *(xmlns);
delete xmlns;
}
}
void
RenderCubicBezier::writeXMLNS (XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
xmlns.add(LayoutExtension::getXmlnsXSI(), "xsi");
stream << xmlns;
}
/*
* Subclasses should override this method to write their XML attributes
* to the XMLOutputStream. Be sure to call your parents implementation
* of this method as well.
*/
void
NUMLDocument::writeAttributes (XMLOutputStream& stream) const
{
if (mNUMLNamespaces->getNamespaces() == 0)
{
XMLNamespaces xmlns;
if (mLevel == 1)
{
xmlns.add("http://www.numl.org/numl/level1/version1");
}
stream << xmlns;
mNUMLNamespaces->setNamespaces(&xmlns);
}
NMBase::writeAttributes(stream);
//
// level: positiveInteger { use="required" fixed="1" } (L1v1)
stream.writeAttribute("level", mLevel);
stream.writeAttribute("version", mVersion);
}
/** @cond doxygenLibsbmlInternal */
void
ListOfGlobalRenderInformation::writeXMLNS (XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
xmlns.add(getURI(), getPrefix());
stream << xmlns;
}
/*
* Write the namespace for the Sed package.
*/
void
SedListOfChanges::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
if (getNamespaces() != NULL && !getNamespaces()->hasURI(SEDML_XMLNS_L1) && !getNamespaces()->hasURI(SEDML_XMLNS_L1V2))
{
if (getVersion() == 2) xmlns.add(SEDML_XMLNS_L1V2,prefix);
else xmlns.add(SEDML_XMLNS_L1V2,prefix);
}
}
stream << xmlns;
}
/*
* Writes the namespace for the Render package
*/
void
ListOfGlobalRenderInformation::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
const XMLNamespaces* thisxmlns = getNamespaces();
if (thisxmlns && thisxmlns->hasURI(RenderExtension::getXmlnsL3V1V1()))
{
xmlns.add(RenderExtension::getXmlnsL3V1V1(), prefix);
}
}
else
{
xmlns.add(getURI(), getPrefix());
}
stream << xmlns;
}
/*
* Writes the namespace for the Spatial package
*/
void
ListOfCoordinateComponents::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
const XMLNamespaces* thisxmlns = getNamespaces();
if (thisxmlns && thisxmlns->hasURI(SpatialExtension::getXmlnsL3V1V1()))
{
xmlns.add(SpatialExtension::getXmlnsL3V1V1(), prefix);
}
}
stream << xmlns;
}
/*
* Creates an XMLNode that represents the layoutId annotation of the species reference from the given SpeciesReference object.
*
* (TODO)
*
*/
LIBSBML_EXTERN
XMLNode* parseLayoutId(const SimpleSpeciesReference* sr)
{
if (!sr || !sr->isSetId()) return 0;
XMLToken ann_token = XMLToken(XMLTriple("annotation", "", ""), XMLAttributes());
XMLNode* pNode = new XMLNode(ann_token);
XMLNamespaces xmlns = XMLNamespaces();
xmlns.add("http://projects.eml.org/bcb/sbml/level2", "");
XMLTriple triple = XMLTriple("layoutId", "", "");
XMLAttributes id_att = XMLAttributes();
id_att.add("id", sr->getId());
XMLToken token = XMLToken(triple, id_att, xmlns);
XMLNode node(token);
pNode->addChild(node);
return pNode;
}
/*
* Writes the namespace for the Groups package
*/
void
ListOfGroups::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
XMLNamespaces* thisxmlns = getNamespaces();
if (thisxmlns && thisxmlns->hasURI(GroupsExtension::getXmlnsL3V1V1()))
{
xmlns.add(GroupsExtension::getXmlnsL3V1V1(), prefix);
}
}
stream << xmlns;
}
/** @cond doxygenLibsbmlInternal */
void
ListOfExternalModelDefinitions::writeXMLNS (XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
if (getNamespaces()->hasURI(CompExtension::getXmlnsL3V1V1()))
{
xmlns.add(CompExtension::getXmlnsL3V1V1(),prefix);
}
}
stream << xmlns;
}
/** @cond doxygenLibsbmlInternal */
void
ListOfFluxBounds::writeXMLNS (XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
if (getNamespaces()->hasURI(FbcExtension::getXmlnsL3V1V1()))
{
xmlns.add(FbcExtension::getXmlnsL3V1V1(),prefix);
}
}
stream << xmlns;
}
/*
* Write the namespace for the Sed package.
*/
void
SedListOfTasks::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
if (getNamespaces() != NULL && !getNamespaces()->hasURI(SEDML_XMLNS_L1))
{
xmlns.add(SEDML_XMLNS_L1,prefix);
}
}
stream << xmlns;
}
/*
* Write the namespace for the Multi package.
*/
void
ListOfSpeciesTypeComponentMapInProducts::writeXMLNS(XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
std::string prefix = getPrefix();
if (prefix.empty())
{
XMLNamespaces* thisxmlns = getNamespaces();
if (thisxmlns && thisxmlns->hasURI(MultiExtension::getXmlnsL3V1V1()))
{
xmlns.add(MultiExtension::getXmlnsL3V1V1(),prefix);
}
}
stream << xmlns;
}
XMLNode*
UncertMLNode::constructXMLNode() const
{
/* create the top level UncertML element */
/* create Namespaces*/
XMLNamespaces xmlns = XMLNamespaces();
xmlns.add("http://www.uncertml.org/3.0");
XMLTriple top_triple = XMLTriple("UncertML",
"http://www.uncertml.org/3.0", "");
XMLAttributes blank_att = XMLAttributes();
XMLNode * xml = new XMLNode(top_triple, blank_att, xmlns);
xml->addChild(*(reconstructXML()));
return xml;
}
LIBSBML_EXTERN XMLNode getXmlNodeForSBase(const SBase* object)
{
char* rawsbml = const_cast<SBase*>(object)->toSBML();
SBMLNamespaces *sbmlns = object->getSBMLNamespaces();
XMLNamespaces* xmlns = sbmlns->getNamespaces()->clone();
// in rare cases the above returns a package element with default namespace, however the
// XMLNamespaces would then assign the actual default namespace, which is in most cases
// the SBML namespace. In that case we adjust the default namespace here
ISBMLExtensionNamespaces *extns = dynamic_cast<ISBMLExtensionNamespaces*>(sbmlns);
if (extns != NULL)
{
xmlns->remove("");
xmlns->add(xmlns->getURI(extns->getPackageName()), "");
}
XMLNode* tmp = XMLNode::convertStringToXMLNode(rawsbml, xmlns);
if (tmp == NULL) return XMLNode();
XMLNode result(*tmp);
delete tmp;
delete xmlns;
free(rawsbml);
return result;
}
XMLNode *
RDFAnnotationParser::createRDFAnnotation()
{
/* create Namespaces - these go on the RDF element */
XMLNamespaces xmlns = XMLNamespaces();
xmlns.add("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf");
xmlns.add("http://purl.org/dc/elements/1.1/", "dc");
xmlns.add("http://purl.org/dc/terms/", "dcterms");
xmlns.add("http://www.w3.org/2001/vcard-rdf/3.0#", "vCard");
xmlns.add("http://biomodels.net/biology-qualifiers/", "bqbiol");
xmlns.add("http://biomodels.net/model-qualifiers/", "bqmodel");
XMLTriple RDF_triple = XMLTriple("RDF",
"http://www.w3.org/1999/02/22-rdf-syntax-ns#",
"rdf");
XMLAttributes blank_att = XMLAttributes();
XMLToken RDF_token = XMLToken(RDF_triple, blank_att, xmlns);
return new XMLNode(RDF_token);
}
// simple callback enabling packages on main doc
int EnablePackageOnParentDocument(Model* m, SBMLErrorLog *, void* userdata)
{
if (m == NULL) return LIBSBML_OPERATION_FAILED;
// pull information out of userdata
disable_info * info = static_cast<disable_info*>(userdata);
SBMLDocument *mainDoc = static_cast<SBMLDocument*>(info->doc);
std::set<std::pair<std::string, std::string> > disabled =
static_cast<std::set <std::pair <std::string, std::string> > >(info->disabledPkgs);
if (mainDoc == NULL) return LIBSBML_OPERATION_FAILED;
XMLNamespaces *mainNS = mainDoc->getSBMLNamespaces()->getNamespaces();
XMLNamespaces *ns = m->getSBMLNamespaces()->getNamespaces();
for (int i = 0; i < ns->getLength(); i++)
{
std::string nsURI = ns->getURI(i);
std::string prefix = ns->getPrefix(i);
if (prefix.empty() == true)
{
continue;
}
else if (mainNS->containsUri(nsURI) == false)
{
bool alreadyDisabled = false;
for (set<pair<string, string> >::iterator pkg = disabled.begin();
pkg != disabled.end(); pkg++)
{
if ((*pkg).first == nsURI)
{
alreadyDisabled = true;
break;
}
}
// just in case
if (m->getSBMLDocument() == NULL)
{
continue;
}
if (m->isPackageEnabled(prefix) == true)
{
mainNS->add(nsURI, prefix);
mainDoc->enablePackage(nsURI, prefix, true);
mainDoc->setPackageRequired(prefix,
m->getSBMLDocument()->getPackageRequired(prefix));
// we also need to make sure that if m was a modelDefinition
// that we enable the package on its parent model
Model * parent = dynamic_cast<Model*>(m->getAncestorOfType(SBML_MODEL));
if (parent != NULL)
{
parent->enablePackageInternal(nsURI, prefix, true);
}
}
else if (m->getSBMLDocument()->hasUnknownPackage(nsURI) == true)
{
// here we are dealing with an unknown package
// need to decide whether to add the ns or not
bool addNS = true;
// if it was listed to be stripped do not add
if (info->strippedPkgs.contains(prefix) == true)
{
addNS = false;
}
// if it has already been disabled do not add
else if (alreadyDisabled == true)
{
addNS = false;
}
// if it is an unflattenable package and flags dicatate do not add
else if (info->stripUnflattenable == true)
{
if (info->abortForRequiredOnly == false)
{
addNS = false;
}
else if (m->getSBMLDocument()->getPackageRequired(nsURI) == true)
{
addNS = false;
}
}
if (addNS == true)
{
// we have an unknown package so we cannot enable it
// but we do tell the parent doc about it
mainNS->add(nsURI, prefix);
mainDoc->addUnknownPackageRequired(nsURI, prefix,
m->getSBMLDocument()->getPackageRequired(nsURI));
}
}
}
}
return LIBSBML_OPERATION_SUCCESS;
}
/* Sets the message from a string optionally wrapping in xhtml tags
*/
int
Constraint::setMessage (const std::string& message,
bool addXHTMLMarkup)
{
int success = LIBSBML_OPERATION_FAILED;
if (message.empty())
{
success = unsetMessage();
}
else
{
XMLNode* message_xmln;
// you might not have a document !!
if (getSBMLDocument() != NULL)
{
XMLNamespaces* xmlns = getSBMLDocument()->getNamespaces();
message_xmln = XMLNode::convertStringToXMLNode(message,xmlns);
}
else
{
message_xmln = XMLNode::convertStringToXMLNode(message);
}
if(message_xmln != NULL)
{
if (addXHTMLMarkup == true)
{
// just say the user passed a string that did not represent xhtml
// the xmlnode will not get set as it is invalid
if (message_xmln->getNumChildren() == 0
&& message_xmln->isStart() == false
&& message_xmln->isEnd() == false
&& message_xmln->isText() == true)
{
//create a parent node of xhtml type p
XMLAttributes blank_att = XMLAttributes();
XMLTriple triple = XMLTriple("p", "http://www.w3.org/1999/xhtml", "");
XMLNamespaces xmlns = XMLNamespaces();
xmlns.add("http://www.w3.org/1999/xhtml", "");
XMLNode *xmlnode = new XMLNode(XMLToken(triple, blank_att, xmlns));
// create a text node from the text given
xmlnode->addChild(*message_xmln);
success = setMessage(xmlnode);
delete xmlnode;
}
else
{
success = setMessage(message_xmln);
}
}
else
{
success = setMessage(message_xmln);
}
delete message_xmln;
}
}
return success;
}
