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()); } } } } } }
/* * * 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; } }
/** @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; } }
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); } }
// 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; }
/* * 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; }
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; }
// 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; }
/** @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); } }