/** @cond doxygenLibsbmlInternal */ void RenderPoint::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes, expectedAttributes); std::string s; if(attributes.readInto("x",s, getErrorLog(), false, getLine(), getColumn())) { this->mXOffset=RelAbsVector(s); } else { this->mXOffset=RelAbsVector(std::numeric_limits<double>::quiet_NaN(),std::numeric_limits<double>::quiet_NaN()); } if(attributes.readInto("y",s, getErrorLog(), false, getLine(), getColumn())) { this->mYOffset=RelAbsVector(s); } else { this->mYOffset=RelAbsVector(std::numeric_limits<double>::quiet_NaN(),std::numeric_limits<double>::quiet_NaN()); } if(attributes.readInto("z",s, getErrorLog(), false, getLine(), getColumn())) { this->mZOffset=RelAbsVector(s); } else { this->mZOffset=RelAbsVector(0.0,0.0); } }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void CompositeDescription::readAttributes (const XMLAttributes& attributes) { NMBase::readAttributes(attributes); const unsigned int level = NMBase::getLevel (); const unsigned int version = NMBase::getVersion(); std::vector<std::string> expectedAttributes; expectedAttributes.clear(); expectedAttributes.push_back("metaid"); expectedAttributes.push_back("id"); expectedAttributes.push_back("name"); expectedAttributes.push_back("ontologyTerm"); expectedAttributes.push_back("indexType"); // check that all attributes are expected for (int i = 0; i < attributes.getLength(); i++) { std::vector<std::string>::const_iterator end = expectedAttributes.end(); std::vector<std::string>::const_iterator begin = expectedAttributes.begin(); std::string name = attributes.getName(i); if (std::find(begin, end, name) == end) { logUnknownAttribute(name, level, version, "<compositeDescription>"); } } attributes.readInto("id", mId); attributes.readInto("name", mName); attributes.readInto("ontologyTerm", mOntologyTerm); attributes.readInto("indexType", mIndexType); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void Trigger::readL3Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); // // initailValue { use="required"} (L3v1 ->) // mIsSetInitialValue = attributes.readInto("initialValue", mInitialValue, getErrorLog(), false, getLine(), getColumn()); if (!mIsSetInitialValue) { logError(AllowedAttributesOnTrigger, level, version, "The required attribute 'initialValue' is missing."); } // // persistent { use="required"} (L3v1 ->) // mIsSetPersistent = attributes.readInto("persistent", mPersistent, getErrorLog(), false, getLine(), getColumn()); if (!mIsSetPersistent) { logError(AllowedAttributesOnTrigger, level, version, "The required attribute 'persistent' is missing."); } }
/* * Read values from the given XMLAttributes set into their specific fields. */ void SedSubTask::readAttributes(const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SedBase::readAttributes(attributes, expectedAttributes); bool assigned = false; // // order int ( use = "required" ) // mIsSetOrder = attributes.readInto("order", mOrder, getErrorLog(), true); // // task SIdRef ( use = "required" ) // assigned = attributes.readInto("task", mTask, getErrorLog(), true); if (assigned == true) { // check string is not empty and correct syntax if (mTask.empty() == true) { logEmptyString(mTask, getLevel(), getVersion(), "<SedSubTask>"); } else if (SyntaxChecker::isValidSBMLSId(mTask) == false) { logError(SedInvalidIdSyntax); } } }
/** @cond doxygenLibsbmlInternal */ void GeneAssociation::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes,expectedAttributes); const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); bool assigned = attributes.readInto("id", mId, getErrorLog(), true, getLine(), getColumn()); if (assigned && mId.empty()) { logEmptyString(mId, sbmlLevel, sbmlVersion, "<geneAssociation>"); } if (!SyntaxChecker::isValidSBMLSId(mId)) logError(InvalidIdSyntax, sbmlLevel, sbmlVersion, "The id '" + mId + "' does not conform to the syntax."); assigned = attributes.readInto("reaction", mReaction, getErrorLog(), true, getLine(), getColumn()); if (assigned && mReaction.empty()) { logEmptyString(mReaction, sbmlLevel, sbmlVersion, "<geneAssociation>"); } if (!SyntaxChecker::isValidSBMLSId(mReaction)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute reaction='" + mReaction + "' does not conform."); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void Domain::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes,expectedAttributes); const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); bool assigned = attributes.readInto("spatialId", mSpatialId, getErrorLog(), true, getLine(), getColumn()); if (assigned && mSpatialId.empty()) { logEmptyString(mSpatialId, sbmlLevel, sbmlVersion, "<Domain>"); } if (!SyntaxChecker::isValidSBMLSId(mSpatialId)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute spatialId='" + mSpatialId + "' does not conform."); assigned = attributes.readInto("domainType", mDomainType, getErrorLog(), true, getLine(), getColumn()); if (assigned && mDomainType.empty()) { logEmptyString(mDomainType, sbmlLevel, sbmlVersion, "<Domain>"); } if (!SyntaxChecker::isValidSBMLSId(mDomainType)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute domainType='" + mDomainType + "' does not conform."); }
/* * Read values from the given XMLAttributes set into their specific fields. */ void SedRepeatedTask::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SedTask::readAttributes(attributes, expectedAttributes); bool assigned = false; // // rangeId SIdRef ( use = "optional" ) // assigned = attributes.readInto("range", mRangeId, getErrorLog(), false); if (assigned == true) { // check string is not empty and correct syntax if (mRangeId.empty() == true) { logEmptyString(mRangeId, getLevel(), getVersion(), "<SedRepeatedTask>"); } else if (SyntaxChecker::isValidSBMLSId(mRangeId) == false) { logError(SedInvalidIdSyntax); } } // // resetModel bool ( use = "optional" ) // mIsSetResetModel = attributes.readInto("resetModel", mResetModel, getErrorLog(), false); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void DomainType::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes,expectedAttributes); const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); bool assigned = attributes.readInto("spatialId", mSpatialId, getErrorLog(), true, getLine(), getColumn()); if (assigned && mSpatialId.empty()) { logEmptyString(mSpatialId, sbmlLevel, sbmlVersion, "<DomainType>"); } if (!SyntaxChecker::isValidSBMLSId(mSpatialId)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute spatialId='" + mSpatialId + "' does not conform."); // // spatialDimensions { maxInclusive="3" minInclusive="0" use="optional" // default="3" } (L2v1 ->) // spatialDimensions { use="optional"} (L3v1 ->) // mIsSetSpatialDimensions= attributes.readInto("spatialDimensions", mSpatialDimensions, getErrorLog(), false, getLine(), getColumn()); if (mSpatialDimensions > 3) { std::string message = "The spatialDimensions attribute on "; message += "a <DomainType> may only have values 0, 1, 2 or 3."; getErrorLog()->logError(NotSchemaConformant, sbmlLevel, sbmlVersion, message); } }
/** @cond doxygenLibsbmlInternal */ void RenderCurve::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { GraphicalPrimitive1D::readAttributes(attributes, expectedAttributes); std::string s; attributes.readInto("startHead", this->mStartHead, getErrorLog(), false, getLine(), getColumn()); attributes.readInto("endHead", this->mEndHead, getErrorLog(), false, getLine(), getColumn()); }
/* * Read values from the given XMLAttributes set into their specific fields. */ void SedUniformTimeCourse::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SedSimulation::readAttributes(attributes, expectedAttributes); bool assigned = false; // // initialTime double ( use = "required" ) // mIsSetInitialTime = attributes.readInto("initialTime", mInitialTime, getErrorLog(), true); // // outputStartTime double ( use = "required" ) // mIsSetOutputStartTime = attributes.readInto("outputStartTime", mOutputStartTime, getErrorLog(), true); // // outputEndTime double ( use = "required" ) // mIsSetOutputEndTime = attributes.readInto("outputEndTime", mOutputEndTime, getErrorLog(), true); // // numberOfPoints int ( use = "required" ) // mIsSetNumberOfPoints = attributes.readInto("numberOfPoints", mNumberOfPoints, getErrorLog(), true); }
void SpeciesReferenceGlyph::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { GraphicalObject::readAttributes(attributes,expectedAttributes); const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); bool assigned = attributes.readInto("speciesReference", mSpeciesReference); if (assigned && mSpeciesReference.empty()) { logEmptyString(mSpeciesReference, sbmlLevel, sbmlVersion, "<" + getElementName() + ">"); } if (!SyntaxChecker::isValidInternalSId(mSpeciesReference)) logError(InvalidIdSyntax); assigned = attributes.readInto("speciesGlyph", mSpeciesGlyph); if (assigned && mSpeciesGlyph.empty()) { logEmptyString(mSpeciesGlyph, sbmlLevel, sbmlVersion, "<" + getElementName() + ">"); } if (!SyntaxChecker::isValidInternalSId(mSpeciesGlyph)) logError(InvalidIdSyntax); std::string role; if(attributes.readInto("role", role)) { this->setRole(role); } else { this->setRole(SPECIES_ROLE_UNDEFINED); } }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void DiffusionCoefficient::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes,expectedAttributes); const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); bool assigned = attributes.readInto("variable", mVariable, getErrorLog(), true, getLine(), getColumn()); if (assigned && mVariable.empty()) { logEmptyString(mVariable, sbmlLevel, sbmlVersion, "<DiffusionCoefficient>"); } if (!SyntaxChecker::isValidSBMLSId(mVariable)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute variable='" + mVariable + "' does not conform."); mIsSetCoordinateIndex = attributes.readInto("coordinateIndex", mCoordinateIndex, getErrorLog(), false, getLine(), getColumn()); /*if (mCoordinateIndex < 0) { std::string message = "The coordinateIndex attribute on "; message += "a <DiffusionCoefficient> can only have values > 0."; getErrorLog()->logError(NotSchemaConformant, sbmlLevel, sbmlVersion, message); }*/ }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. * * @param attributes the XMLAttributes object to use */ void Parameter::readL3Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); // id: SId { use="required" } (L2v1, L2v2) // bool assigned = attributes.readInto("id", mId, getErrorLog(), false, getLine(), getColumn()); if (!assigned) { if (this->getTypeCode() == SBML_PARAMETER) { logError(AllowedAttributesOnParameter, level, version); } else { logError(AllowedAttributesOnLocalParameter, level, version); } } if (assigned && mId.size() == 0) { logEmptyString("id", level, version, "<parameter>"); } if (!SyntaxChecker::isValidInternalSId(mId)) logError(InvalidIdSyntax); // // value: double { use="optional" } (L1v2->) // mIsSetValue = attributes.readInto("value", mValue, getErrorLog(), false, getLine(), getColumn()); // // units: SId { use="optional" } (L2v1, L2v2) // assigned = attributes.readInto("units", mUnits, getErrorLog(), false, getLine(), getColumn()); if (assigned && mUnits.size() == 0) { logEmptyString("units", level, version, "<parameter>"); } if (!SyntaxChecker::isValidInternalUnitSId(mUnits)) { logError(InvalidUnitIdSyntax); } // // name: string { use="optional" } (L2v1 ->) // attributes.readInto("name", mName, getErrorLog(), false, getLine(), getColumn()); if (this->getTypeCode() == SBML_PARAMETER) { mIsSetConstant = attributes.readInto("constant", mConstant, getErrorLog(), false, getLine(), getColumn()); if (!mIsSetConstant) { logError(AllowedAttributesOnParameter, level, version); } } }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void SpeciesReference::readL1Attributes (const XMLAttributes& attributes) { // // stoichiometry: integer { use="optional" default="1" } (L1v1, L1v2) // stoichiometry: double { use="optional" default="1" } (L2v1->) // mIsSetStoichiometry = attributes.readInto("stoichiometry", mStoichiometry, getErrorLog(), false, getLine(), getColumn()); if (!mIsSetStoichiometry) { // // setting default value // mStoichiometry = 1; mIsSetStoichiometry = true; } else { mExplicitlySetStoichiometry = true; } // // denominator: integer { use="optional" default="1" } (L1v1, L1v2) // mExplicitlySetDenominator = attributes.readInto("denominator", mDenominator,getErrorLog(), false, getLine(), getColumn()); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void SpeciesReference::readL3Attributes (const XMLAttributes& attributes) { const unsigned int level = 3; const unsigned int version = getVersion(); // // stoichiometry: double { use="optional" default="1" } (L2v1->) // mIsSetStoichiometry = attributes.readInto("stoichiometry", mStoichiometry, getErrorLog(), false, getLine(), getColumn()); string elplusid = "<" + getElementName() + ">"; if (!mId.empty()) { elplusid += " with the id '" + mId + "'"; } SBase* rxn = getAncestorOfType(SBML_REACTION); if (rxn && rxn->isSetId()) { elplusid += " from the <reaction> with the id '" + rxn->getId() + "'"; } // // constant: bool { use="required" } (L3v1 -> ) // mIsSetConstant = attributes.readInto("constant", mConstant, getErrorLog(), false, getLine(), getColumn()); if (!mIsSetConstant && !isModifier()) { logError(AllowedAttributesOnSpeciesReference, level, version, "The required attribute 'constant' is missing from the " + elplusid + "."); } }
/** @cond doxygenLibsbmlInternal */ void ColorDefinition::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes,expectedAttributes); std::string valueString; attributes.readInto("id", mId, getErrorLog(), false, getLine(), getColumn()); attributes.readInto("value", valueString, getErrorLog(), false, getLine(), getColumn()); this->setColorValue(valueString); }
/** @cond doxygenLibsbmlInternal */ void Style::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBase::readAttributes(attributes, expectedAttributes); attributes.readInto("id", mId, getErrorLog(), false, getLine(), getColumn()); attributes.readInto("name", mName, getErrorLog(), false, getLine(), getColumn()); readListOfRoles(attributes); readListOfTypes(attributes); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void CSGScale::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { CSGTransformation::readAttributes(attributes,expectedAttributes); mIsSetScaleX = attributes.readInto("scaleX", mScaleX, getErrorLog(), true, getLine(), getColumn()); mIsSetScaleY = attributes.readInto("scaleY", mScaleY, getErrorLog(), true, getLine(), getColumn()); mIsSetScaleZ = attributes.readInto("scaleZ", mScaleZ, getErrorLog(), true, getLine(), getColumn()); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void Event::readL2Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel(); const unsigned int version = getVersion(); // // id: SId { use="optional" } (L2v1 ->) // bool assigned = attributes.readInto("id", mId, getErrorLog(), false, getLine(), getColumn()); if (assigned && mId.size() == 0) { logEmptyString("id", level, version, "<event>"); } if (!SyntaxChecker::isValidInternalSId(mId)) logError(InvalidIdSyntax); // // name: string { use="optional" } (L2v1 ->) // attributes.readInto("name", mName, getErrorLog(), false, getLine(), getColumn()); // // timeUnits: SId { use="optional" } (L2v1, L2v2) // removed in l2v3 // if (version < 3) { assigned = attributes.readInto("timeUnits", mTimeUnits, getErrorLog(), false, getLine(), getColumn()); if (assigned && mTimeUnits.size() == 0) { logEmptyString("timeUnits", level, version, "<event>"); } if (!SyntaxChecker::isValidInternalUnitSId(mTimeUnits)) { logError(InvalidUnitIdSyntax); } } // // sboTerm: SBOTerm { use="optional" } (L2v2 ->) // if (version == 2) mSBOTerm = SBO::readTerm(attributes, this->getErrorLog(), level, version, getLine(), getColumn()); // // useValuesFromTriggerTime: bool {use="optional" default="true"} (L2V4 ->) // useValuesFromTriggerTime: bool {use="optional" } (L3 ->) // if (version == 4) { mExplicitlySetUVFTT = attributes.readInto("useValuesFromTriggerTime", mUseValuesFromTriggerTime, getErrorLog(), false, getLine(), getColumn()); } }
void Point::readAttributes (const XMLAttributes& attributes) { SBase::readAttributes(attributes); attributes.readInto("x", mXOffset,this->getErrorLog(),true); attributes.readInto("y", mYOffset,this->getErrorLog(),true); if(!attributes.readInto("z", mZOffset)) { this->mZOffset=0.0; } }
/** @cond doxygenLibsbmlInternal */ void ReplacedElement::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); // look to see whether an unknown attribute error was logged // during the read of the ListOfReplacedElements - which will have // happened immediately prior to this read if (getErrorLog() != NULL && static_cast<ListOfReplacedElements*>(getParentSBMLObject())->size() < 2) { unsigned int numErrs = getErrorLog()->getNumErrors(); for (int n = numErrs-1; n >= 0; n--) { if (getErrorLog()->getError(n)->getErrorId() == UnknownPackageAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownPackageAttribute); getErrorLog()->logPackageError("comp", CompLOReplacedElementsAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details); } else if (getErrorLog()->getError(n)->getErrorId() == UnknownCoreAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownCoreAttribute); getErrorLog()->logPackageError("comp", CompLOReplacedElementsAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details); } } } XMLTriple tripleDeletion("deletion", mURI, getPrefix()); if (attributes.readInto(tripleDeletion, mDeletion, getErrorLog(), false, getLine(), getColumn())) { if (!SyntaxChecker::isValidSBMLSId(mDeletion)) { logInvalidId("comp:deletion", mDeletion); } } XMLTriple tripleConversionFactor("conversionFactor", mURI, getPrefix()); if(attributes.readInto(tripleConversionFactor, mConversionFactor, getErrorLog(), false, getLine(), getColumn())) { if (!SyntaxChecker::isValidSBMLSId(mConversionFactor)) { logInvalidId("comp:conversionFactor", mConversionFactor); } } //We call the base class version here because of the error checking for having set exactly one of the mutually-exclusive attributes, and two of them (deletion and conversionFactor) only exist for ReplacedElements, not SBaseRef. Replacing::readAttributes(attributes,expectedAttributes); }
void SpatialSpeciesRxnPlugin::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SBasePlugin::readAttributes(attributes, expectedAttributes); mIsSetSpatial = attributes.readInto("isSpatial", mIsSpatial, getErrorLog(), mParent != NULL && mParent->getTypeCode() == SBML_SPECIES, getLine(), getColumn()); mIsSetLocal = attributes.readInto("isLocal", mIsLocal, getErrorLog(), mParent != NULL && mParent->getTypeCode() == SBML_REACTION, getLine(), getColumn()); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. * * @param attributes the XMLAttributes object to use */ void Parameter::readL2Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); // id: SId { use="required" } (L2v1, L2v2) // bool assigned = attributes.readInto("id", mId, getErrorLog(), true, getLine(), getColumn()); if (assigned && mId.size() == 0) { logEmptyString("id", level, version, "<parameter>"); } if (!SyntaxChecker::isValidInternalSId(mId)) logError(InvalidIdSyntax); // // value: double { use="optional" } (L1v2->) // mIsSetValue = attributes.readInto("value", mValue, getErrorLog(), false, getLine(), getColumn()); // // units: SId { use="optional" } (L2v1, L2v2) // assigned = attributes.readInto("units", mUnits, getErrorLog(), false, getLine(), getColumn()); if (assigned && mUnits.size() == 0) { logEmptyString("units", level, version, "<parameter>"); } if (!SyntaxChecker::isValidInternalUnitSId(mUnits)) { logError(InvalidUnitIdSyntax); } // // name: string { use="optional" } (L2v1 ->) // attributes.readInto("name", mName, getErrorLog(), false, getLine(), getColumn()); // // constant: boolean { use="optional" default="true" } (L2v1->) // mExplicitlySetConstant = attributes.readInto("constant", mConstant, getErrorLog(), false, getLine(), getColumn()); // // sboTerm: SBOTerm { use="optional" } (L2v2->) // if (version == 2) mSBOTerm = SBO::readTerm(attributes, this->getErrorLog(), level, version, getLine(), getColumn()); }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void InitialAssignment::readL2Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); // // symbol: SId { use="required" } (L2v2 -> ) // bool assigned = attributes.readInto("symbol", mSymbol, getErrorLog(), true, getLine(), getColumn()); if (assigned && mSymbol.size() == 0) { logEmptyString("symbol", level, version, "<initialAssignment>"); } if (!SyntaxChecker::isValidInternalSId(mSymbol)) logError(InvalidIdSyntax, getLevel(), getVersion(), "The syntax of the attribute symbol='" + mSymbol + "' does not conform to the syntax."); // // sboTerm: SBOTerm { use="optional" } (L2v2 ->) // if (version == 2) mSBOTerm = SBO::readTerm(attributes, this->getErrorLog(), level, version, getLine(), getColumn()); }
/** @cond doxygenLibsbmlInternal */ void Replacing::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); XMLTriple tripleSubmodelRef("submodelRef", mURI, getPrefix()); bool assigned = attributes.readInto(tripleSubmodelRef, mSubmodelRef); if (assigned == false) { if (getElementName() == "replacedElement") { std::string message = "Comp attribute 'submodelRef' is missing."; getErrorLog()->logPackageError("comp", CompReplacedElementAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, message); } else { std::string message = "Comp attribute 'submodelRef' is missing."; getErrorLog()->logPackageError("comp", CompReplacedByAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, message); } } else { if (!SyntaxChecker::isValidSBMLSId(mSubmodelRef)) { logInvalidId("comp:submodelRef", mSubmodelRef); } } //We call the base class version here because of the error checking for having set exactly one of the mutually-exclusive attributes, and one of them (deletion) only exists for Replacings, not SBaseRef. SBaseRef::readAttributes(attributes,expectedAttributes); }
void SBMLDocumentPlugin::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { if (&attributes == NULL || &expectedAttributes == NULL ) return; SBasePlugin::readAttributes(attributes, expectedAttributes); if ( mSBMLExt->getLevel(mURI) > 2) { // check level of document version smaller than plugin // and report invalid if it is if (this->getSBMLDocument() != NULL && this->getSBMLDocument()->getLevel() < mSBMLExt->getLevel(mURI)) { // we should not have a package ns in an l2 document this->getSBMLDocument()->getErrorLog()->logError(L3PackageOnLowerSBML, this->getSBMLDocument()->getLevel(), this->getSBMLDocument()->getVersion()); } else { XMLTriple tripleRequired("required", mURI, mPrefix); if (attributes.readInto(tripleRequired, mRequired, getErrorLog(), true, getLine(), getColumn())) { mIsSetRequired = true; } } } }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void Rule::readL2Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); if (isAssignment() || isRate()) { // // variable: SId { use="required" } (L2v1 ->) // bool assigned = attributes.readInto("variable", mVariable, getErrorLog(), true, getLine(), getColumn()); if (assigned && mVariable.size() == 0) { logEmptyString("variable", level, version, "<rule>"); } if (!SyntaxChecker::isValidInternalSId(mVariable)) logError(InvalidIdSyntax, level, version, "The id '" + mVariable + "' does not conform to the syntax."); } // // sboTerm: SBOTerm { use="optional" } (L2v2 ->) // if (version == 2) mSBOTerm = SBO::readTerm(attributes, this->getErrorLog(), level, version, getLine(), getColumn()); }
bool ASTCnBase::readAttributes(const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes, XMLInputStream& stream, const XMLToken& element) { bool read = ASTBase::readAttributes(attributes, expectedAttributes, stream, element); if (read == false) { return read; } string units; attributes.readInto( "units" , units ); // cannot put up the prefix here as we need the stream // to establish the sbml ns uri if (!units.empty()) { setUnits(units); } return true; }
/* * Subclasses should override this method to read values from the given * XMLAttributes set into their specific fields. Be sure to call your * parents implementation of this method as well. */ void Rule::readL3Attributes (const XMLAttributes& attributes) { const unsigned int level = getLevel (); const unsigned int version = getVersion(); if (isAssignment() || isRate()) { // // variable: SId { use="required" } (L2v1 ->) // bool assigned = attributes.readInto("variable", mVariable, getErrorLog(), false, getLine(), getColumn()); if (!assigned) { if (isAssignment()) logError(AllowedAttributesOnAssignRule, level, version, "The required attribute 'variable' is missing."); else logError(AllowedAttributesOnRateRule, level, version, "The required attribute 'variable' is missing."); } if (assigned && mVariable.size() == 0) { logEmptyString("variable", level, version, "<rule>"); } if (!SyntaxChecker::isValidInternalSId(mVariable)) logError(InvalidIdSyntax, level, version, "The id '" + mVariable + "' does not conform to the syntax."); } }
/* * Read values from the given XMLAttributes set into their specific fields. */ void SedFunctionalRange::readAttributes(const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { SedRange::readAttributes(attributes, expectedAttributes); bool assigned = false; // // range SIdRef ( use = "required" ) // assigned = attributes.readInto("range", mRange, getErrorLog(), true); if (assigned == true) { // check string is not empty and correct syntax if (mRange.empty() == true) { logEmptyString(mRange, getLevel(), getVersion(), "<SedFunctionalRange>"); } else if (SyntaxChecker::isValidSBMLSId(mRange) == false) { logError(SedInvalidIdSyntax); } } }