/** @cond doxygenLibsbmlInternal */
void
ListOfGlobalRenderInformation::writeXMLNS (XMLOutputStream& stream) const
{
XMLNamespaces xmlns;
xmlns.add(getURI(), getPrefix());
stream << 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);
}
bool
SedNamespaces::isValidCombination()
{
bool valid = true;
bool sedmlDeclared = false;
std::string declaredURI("");
unsigned int version = getVersion();
XMLNamespaces *xmlns = getNamespaces();
if (xmlns != NULL)
{
int numNS = 0;
if (xmlns->hasURI(SEDML_XMLNS_L1V1))
{
++numNS;
declaredURI.assign(SEDML_XMLNS_L1V1);
}
// checks if the SEDML Namespace is explicitly defined.
for (int i=0; i < xmlns->getLength(); i++)
{
if (!declaredURI.empty() &&
xmlns->getURI(i) == declaredURI)
{
sedmlDeclared = true;
break;
}
}
}
switch (getLevel())
{
case 1:
switch (version)
{
case 1:
// the namespaces contains the sedml namespaces
// check it is the correct ns for the level/version
if (sedmlDeclared)
{
if (declaredURI != string(SEDML_XMLNS_L1V1))
{
valid = false;
}
}
break;
default:
valid = false;
break;
}
break;
default:
valid = false;
break;
}
return valid;
}
void
ASTBase::loadASTPlugins(SBMLNamespaces * sbmlns)
{
if (sbmlns == NULL)
{
unsigned int numPkgs = SBMLExtensionRegistry::getNumRegisteredPackages();
for (unsigned int i=0; i < numPkgs; i++)
{
const std::string &uri = SBMLExtensionRegistry::getRegisteredPackageName(i);
const SBMLExtension* sbmlext = SBMLExtensionRegistry::getInstance().getExtensionInternal(uri);
if (sbmlext && sbmlext->isEnabled())
{
//const std::string &prefix = xmlns->getPrefix(i);
ASTBasePlugin* astPlugin = const_cast<ASTBasePlugin*>(sbmlext->getASTBasePlugin());
if (astPlugin != NULL)
{
//// need to give the plugin infomrtaion about itself
//astPlugin->setSBMLExtension(sbmlext);
//astPlugin->connectToParent(this);
mPlugins.push_back(astPlugin->clone());
}
}
}
}
else
{
XMLNamespaces *xmlns = sbmlns->getNamespaces();
if (xmlns)
{
int numxmlns= xmlns->getLength();
for (int i=0; i < numxmlns; i++)
{
const std::string &uri = xmlns->getURI(i);
const SBMLExtension* sbmlext = SBMLExtensionRegistry::getInstance().getExtensionInternal(uri);
if (sbmlext && sbmlext->isEnabled())
{
ASTBasePlugin* astPlugin = const_cast<ASTBasePlugin*>(sbmlext->getASTBasePlugin());
if (astPlugin != NULL)
{
astPlugin->setSBMLExtension(sbmlext);
astPlugin->setPrefix(xmlns->getPrefix(i));
astPlugin->connectToParent(this);
mPlugins.push_back(astPlugin->clone());
}
}
}
}
}
}
/** @cond doxygenLibsbmlInternal */
int
CompFlatteningConverter::stripPackages()
{
mPkgsToStrip = new IdList(getPackagesToStrip());
unsigned int num = mPkgsToStrip->size();
if (num == 0)
{
return LIBSBML_OPERATION_SUCCESS;
}
XMLNamespaces *ns = mDocument->getSBMLNamespaces()->getNamespaces();
for (int i = 0; i < ns->getLength(); i++)
{
std::string nsURI = ns->getURI(i);
std::string package = ns->getPrefix(i);
if (package.empty() == true)
{
continue;
}
else if (mPkgsToStrip->contains(package) == true)
{
mDocument->enablePackage(nsURI, package, false);
mDisabledPackages.insert(make_pair(nsURI, package));
}
}
unsigned int count = 0;
for (unsigned int i = 0; i < num; i++)
{
if (mDocument->isPackageEnabled(mPkgsToStrip->at((int)i)) == false)
{
count++;
}
}
// setup callback that will disable the packages on submodels
Submodel::addProcessingCallback(&DisablePackageOnChildDocuments, mPkgsToStrip);
if (num == count)
{
return LIBSBML_OPERATION_SUCCESS;
}
else
{
return LIBSBML_OPERATION_FAILED;
}
}
/*
* 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;
}
/** @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;
}
/*
* 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;
}
/*
* 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;
}
/*
* 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;
}
/** @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 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;
}
/*
* 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;
}
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;
}
/*
* 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;
}
void
SBMLLevelVersionConverter::updatePackages(unsigned int targetVersion)
{
// this will only work if we have a package with version 1 for both l3v1 and l3v2
//std::string sbml = writeSBMLToStdString(mDocument);
//SBMLDocument *tempdoc = readSBMLFromString(sbml.c_str());
//if (!tempdoc->getErrorLog()->contains(InvalidPackageLevelVersion))
//{
// delete tempdoc;
// return;
//}
//delete tempdoc;
// const SBMLExtension* sbmlext = NULL;
XMLNamespaces *xmlns = mDocument->getNamespaces();
int numxmlns = xmlns->getLength();
for (int i = numxmlns - 1; i >= 0; i--)
{
const std::string &prefix = xmlns->getPrefix(i);
if (!prefix.empty())
mDocument->updateSBMLNamespace(prefix, 3, targetVersion);
}
}
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;
}
// simple callback disabling packages on child documents
int DisablePackageOnChildDocuments(Model* m, SBMLErrorLog *, void* userdata)
{
if (m == NULL) return LIBSBML_OPERATION_FAILED;
IdList *pkgsToStrip = static_cast<IdList*>(userdata);
XMLNamespaces *ns = m->getSBMLNamespaces()->getNamespaces();
for (int i = 0; i < ns->getLength(); i++)
{
std::string nsURI = ns->getURI(i);
std::string package = ns->getPrefix(i);
if (package.empty() == true)
{
continue;
}
else if (pkgsToStrip->contains(package) == true)
{
m->enablePackageInternal(nsURI, package, false);
}
}
return LIBSBML_OPERATION_SUCCESS;
}
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);
}
/** @cond doxygenLibsbmlInternal */
void
CompFlatteningConverter::analyseDocument()
{
XMLNamespaces * ns = mDocument->getSBMLNamespaces()->getNamespaces();
bool required = true;
bool known = true;
bool flattenable = true;
for (int i = 0; i < ns->getNumNamespaces(); i++)
{
std::string package = ns->getPrefix(i);
std::string uri = ns->getURI(i);
// exclude the code namespace
if (uri == SBMLNamespaces::getSBMLNamespaceURI(mDocument->getLevel(),
mDocument->getVersion()))
{
continue;
}
// required flag
if (mDocument->getPackageRequired(uri) == true)
{
required= true;
}
else
{
required = false;
}
// known status
if (mDocument->isPkgURIEnabled(uri) == true)
{
known = true;
// flattenable status
if (static_cast<SBMLDocumentPlugin*>
(mDocument->getPlugin(uri))->isCompFlatteningImplemented() == true)
{
flattenable = true;
}
else
{
flattenable = false;
}
}
else
{
// if we dont know it we ceratinly cannot flatten it !
known = false;
flattenable = false;
}
// add the values into the map
ValueSet values;
values.push_back(required);
values.push_back(known);
values.push_back(flattenable);
mPackageValues.insert(pair<const std::string, ValueSet>(package, values));
}
}
/** @cond doxygenLibsbmlInternal */
void
CompFlatteningConverter::stripUnflattenablePackages()
{
XMLNamespaces *ns = mDocument->getSBMLNamespaces()->getNamespaces();
for (int i = 0; i < ns->getLength(); i++)
{
std::string nsURI = ns->getURI(i);
std::string package = ns->getPrefix(i);
if (package.empty() == true)
{
continue;
}
// need to be enabled in order to flatten so need to check both
bool flattenable = getFlattenableStatus(package) &&
SBMLExtensionRegistry::getInstance().isEnabled(package);
// if we can flatten we dont need to strip
if (flattenable == true)
{
continue;
}
bool required = getRequiredStatus(package);
bool known = getKnownStatus(package);
std::string message = "The ";
if (required == true)
{
message += "required ";
}
message += "package ";
message += package;
message += " has been stripped from the resulting flat model.";
unsigned int errorId;
if (required == true)
{
if (known == true)
{
errorId = CompFlatteningNotImplementedReqd;
}
else
{
errorId = CompFlatteningNotRecognisedReqd;
}
}
else
{
if (known == true)
{
errorId = CompFlatteningNotImplementedNotReqd;
}
else
{
errorId = CompFlatteningNotRecognisedNotReqd;
}
}
//need to look at abortIfFlattenable option
// not if option is all and there are any unflattenable packages
// we will already have aborted
if (getAbortForNone() == true)
{
// disable all
mDocument->enablePackage(nsURI, package, false);
mDisabledPackages.insert(make_pair(nsURI, package));
mDocument->getErrorLog()->logPackageError("comp", errorId,
mDocument->getPlugin("comp")->getPackageVersion(),
mDocument->getLevel(), mDocument->getVersion(), message,
mDocument->getLine(), mDocument->getColumn());
mPkgsToStrip->append(package);
}
else if (getAbortForRequired() == true)
{
// disable unrequired packages only
if (required == false)
{
mDocument->enablePackage(nsURI, package, false);
mDisabledPackages.insert(make_pair(nsURI, package));
mDocument->getErrorLog()->logPackageError("comp", errorId,
mDocument->getPlugin("comp")->getPackageVersion(),
mDocument->getLevel(), mDocument->getVersion(), message,
mDocument->getLine(), mDocument->getColumn());
mPkgsToStrip->append(package);
}
}
// setup callback that will disable the packages on submodels
Submodel::addProcessingCallback(&DisablePackageOnChildDocuments, mPkgsToStrip);
}
}
/*
* Sets the level and version of this NUMLDocument. Valid
* combinations are currently:
*
* @li Level 1 Version 1
*
*
*/
bool
NUMLDocument::setLevelAndVersion (unsigned int level, unsigned int version,
bool strict)
{
/* since this function will write to the error log we should
* clear anything in the log first
*/
getErrorLog()->clearLog();
bool conversionSuccess = false;
unsigned char origValidators = mApplicableValidators;
mApplicableValidators = mApplicableValidatorsForConversion;
/* if strict = true we will only convert a valid model
* to a valid model with a valid internal representation
*/
/* see whether the unit validator is on */
if (strict)
{
/* use validators that the user has selected
*/
/* hack to catch errors caught at read time */
NUMLDocument *d = readNUMLFromString(writeNUMLToString(this));
unsigned int errors = d->getNumErrors();
for (unsigned int i = 0; i < errors; i++)
{
mErrorLog.add(*(d->getError(i)));
}
delete d;
// errors += checkConsistency();
errors = getErrorLog()->getNumFailsWithSeverity(LIBNUML_SEV_ERROR);
/* if the current model is not valid dont convert
*/
if (errors > 0)
{
return conversionSuccess;
}
getErrorLog()->clearLog();
}
//mLevel = level;
//mVersion = version;
//mNUMLNamespaces->setLevel(mLevel);
//mNUMLNamespaces->setVersion(mVersion);
/* restore original value */
mApplicableValidators = origValidators;
mLevel = level;
mVersion = version;
if (mNUMLNamespaces == 0)
mNUMLNamespaces = new NUMLNamespaces(mLevel, mVersion);;
/**
* check for the case where the numl namespace has been expicitly declared
* as well as being the default
*/
bool numlDecl = false;
int index;
for (index = 0; index < mNUMLNamespaces->getNamespaces()->getLength();
index++)
{
if (!mNUMLNamespaces->getNamespaces()->getPrefix(index).empty()
&& mNUMLNamespaces->getNamespaces()->getPrefix(index)=="numl")
{
numlDecl = true;
break;
}
}
if (numlDecl)
{
XMLNamespaces * copyNamespaces = mNUMLNamespaces->getNamespaces()->clone();
mNUMLNamespaces->getNamespaces()->clear();
for (int i = 0; i < copyNamespaces->getLength(); i++)
{
if ( i != index)
mNUMLNamespaces->getNamespaces()->add(copyNamespaces->getURI(i),
copyNamespaces->getPrefix(i));
}
delete copyNamespaces;
}
if (mLevel == 1)
{
if (numlDecl)
mNUMLNamespaces->getNamespaces()->add("http://www.numl.org/numl/level1/version1", "numl");
mNUMLNamespaces->getNamespaces()->add("http://www.numl.org/numl/level1/version1");
}
mNUMLNamespaces->setLevel(mLevel);
mNUMLNamespaces->setVersion(mVersion);
return conversionSuccess;
}
/*
*
* 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;
}
}
// 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;
}
bool
SBMLNamespaces::isValidCombination()
{
bool valid = true;
bool sbmlDeclared = false;
std::string declaredURI("");
unsigned int version = getVersion();
XMLNamespaces *xmlns = getNamespaces();
if (xmlns != NULL)
{
//
// checks defined SBML XMLNamespace
// returns false if different SBML XMLNamespaces
// (e.g. SBML_XMLNS_L2V1 and SBML_XMLNS_L2V3) are defined.
//
int numNS = 0;
if (xmlns->hasURI(SBML_XMLNS_L3V1))
{
++numNS;
declaredURI.assign(SBML_XMLNS_L3V1);
}
if (xmlns->hasURI(SBML_XMLNS_L2V4))
{
if (numNS > 0) return false;
++numNS;
declaredURI.assign(SBML_XMLNS_L2V4);
}
if (xmlns->hasURI(SBML_XMLNS_L2V3))
{
// checks different SBML XMLNamespaces
if (numNS > 0) return false;
++numNS;
declaredURI.assign(SBML_XMLNS_L2V3);
}
if (xmlns->hasURI(SBML_XMLNS_L2V2))
{
// checks different SBML XMLNamespaces
if (numNS > 0) return false;
++numNS;
declaredURI.assign(SBML_XMLNS_L2V2);
}
if (xmlns->hasURI(SBML_XMLNS_L2V1))
{
// checks different SBML XMLNamespaces
if (numNS > 0) return false;
++numNS;
declaredURI.assign(SBML_XMLNS_L2V1);
}
if (xmlns->hasURI(SBML_XMLNS_L1))
{
// checks different SBML XMLNamespaces
if (numNS > 0) return false;
++numNS;
declaredURI.assign(SBML_XMLNS_L1);
}
// checks if the SBML Namespace is explicitly defined.
for (int i=0; i < xmlns->getLength(); i++)
{
if (!declaredURI.empty() &&
xmlns->getURI(i) == declaredURI)
{
sbmlDeclared = true;
break;
}
}
}
switch (getLevel())
{
case 1:
switch (version)
{
case 1:
case 2:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L1))
{
valid = false;
}
}
break;
default:
valid = false;
break;
}
break;
case 2:
switch (version)
{
case 1:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L2V1))
{
valid = false;
}
}
break;
case 2:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L2V2))
{
valid = false;
}
}
break;
case 3:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L2V3))
{
valid = false;
}
}
break;
case 4:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L2V4))
{
valid = false;
}
}
break;
default:
valid = false;
break;
}
break;
case 3:
switch (version)
{
case 1:
// the namespaces contains the sbml namespaces
// check it is the correct ns for the level/version
if (sbmlDeclared)
{
if (declaredURI != string(SBML_XMLNS_L3V1))
{
valid = false;
}
}
break;
default:
valid = false;
break;
}
break;
default:
valid = false;
break;
}
return valid;
}
/* 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;
}
