/** @cond doxygenLibsbmlInternal */
SBase*
SBaseRef::createObject (XMLInputStream& stream)
{
SBase* object = NULL;
const std::string& name = stream.peek().getName();
const XMLNamespaces& xmlns = stream.peek().getNamespaces();
const std::string& prefix = stream.peek().getPrefix();
const std::string& targetPrefix = (xmlns.hasURI(mURI)) ? xmlns.getPrefix(mURI) : getPrefix();
if (prefix == targetPrefix)
{
SBMLErrorLog* errlog = getErrorLog();
if (mSBaseRef != NULL && (name =="sBaseRef" || name=="sbaseRef")) {
if (errlog != NULL) {
errlog->logPackageError(getPackageName(), CompOneSBaseRefOnly,
getPackageVersion(), getLevel(), getVersion());
}
object = mSBaseRef;
}
else if ( name == "sBaseRef" ) {
COMP_CREATE_NS(compns, getSBMLNamespaces());
mSBaseRef = new SBaseRef(compns);
object = mSBaseRef;
object->connectToParent(this);
delete compns;
}
else if ( name == "sbaseRef" ) {
if (errlog != NULL) {
errlog->logPackageError(getPackageName(), CompDeprecatedSBaseRefSpelling,
getPackageVersion(), getLevel(), getVersion());
}
COMP_CREATE_NS(compns, getSBMLNamespaces());
mSBaseRef = new SBaseRef(compns);
object = mSBaseRef;
object->connectToParent(this);
delete compns;
}
}
return object;
}
/*
* Reads the expected attributes into the member data variables
*/
void
ClassOne::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("vers", VersClassOneAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("vers", VersClassOneAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
if (pkgVersion == 1)
{
readV1Attributes(attributes);
}
else
{
readV2Attributes(attributes);
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
ClassOne::readV2Attributes(const XMLAttributes& attributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
bool assigned = false;
unsigned int pkgVersion = getPackageVersion();
SBMLErrorLog* log = getErrorLog();
unsigned int numErrs;
//
// id SId (use = "required" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<ClassOne>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(VersIdSyntaxRule, level, version, "The id '" + mId + "' does not "
"conform to the syntax.");
}
}
else
{
std::string message = "Vers attribute 'id' is missing from the <ClassOne> "
"element.";
log->logPackageError("vers", VersClassOneAllowedAttributes, pkgVersion,
level, version, message);
}
//
// att2 bool (use = "optional" )
//
mIsSetAtt2 = attributes.readInto("att2", mAtt2);
}
int CompModelPlugin::saveAllReferencedElements(set<SBase*> uniqueRefs, set<SBase*> replacedBys)
{
SBMLDocument* doc = getSBMLDocument();
Model* model = static_cast<Model*>(getParentSBMLObject());
if (model==NULL) {
if (doc) {
string error = "Unable to discover any referenced elements in CompModelPlugin::saveAllReferencedElements: no Model parent of the 'comp' model plugin.";
doc->getErrorLog()->logPackageError("comp", CompModelFlatteningFailed, getPackageVersion(), getLevel(), getVersion(), error);
}
return LIBSBML_OPERATION_FAILED;
}
int ret = LIBSBML_OPERATION_SUCCESS;
//Get a list of everything, pull out anything that's a deletion, replacement, or port, and save what they're pointing to.
//At the same time, make sure that no two things point to the same thing.
set<SBase*> RE_deletions = set<SBase*>(); //Deletions only point to things in the same model.
List* allElements = model->getAllElements();
string modname = "the main model in the document";
if (model->isSetId()) {
modname = "the model '" + model->getId() + "'";
}
set<SBase*> todelete;
for (unsigned int el=0; el<allElements->getSize(); el++) {
SBase* element = static_cast<SBase*>(allElements->get(el));
int type = element->getTypeCode();
if (type==SBML_COMP_DELETION ||
type==SBML_COMP_REPLACEDBY ||
type==SBML_COMP_REPLACEDELEMENT ||
type==SBML_COMP_PORT) {
//Don't worry about SBML_COMP_SBASEREF because they're all children of one of the above types.
SBaseRef* reference = static_cast<SBaseRef*>(element);
ReplacedElement* re = static_cast<ReplacedElement*>(element);
ret = reference->saveReferencedElement();
if (ret != LIBSBML_OPERATION_SUCCESS)
{
if (type != SBML_COMP_REPLACEDBY && doc)
{
SBMLErrorLog* errlog = doc->getErrorLog();
SBMLError* lasterr = const_cast<SBMLError*>
(doc->getErrorLog()->getError(doc->getNumErrors()-1));
if ( (errlog->contains(UnrequiredPackagePresent) ||
errlog->contains(RequiredPackagePresent)))
{
if ( lasterr->getErrorId() == CompIdRefMustReferenceObject)
{
//Change the error into a warning
string fullmsg = lasterr->getMessage()
+ " However, this may be because of the unrecognized "
+ "package present in this document: ignoring this "
+ "element and flattening anyway.";
errlog->remove(lasterr->getErrorId());
errlog->logPackageError("comp",
CompIdRefMayReferenceUnknownPackage, getPackageVersion(),
getLevel(), getVersion(), fullmsg, element->getLine(),
element->getColumn(), LIBSBML_SEV_WARNING);
}
else if ( lasterr->getErrorId() == CompMetaIdRefMustReferenceObject)
{
//Change the error into a warning
string fullmsg = lasterr->getMessage()
+ " However, this may be because of the unrecognized "
+ "package present in this document: ignoring this "
+ "element and flattening anyway.";
errlog->remove(lasterr->getErrorId());
errlog->logPackageError("comp",
CompMetaIdRefMayReferenceUnknownPkg, getPackageVersion(),
getLevel(), getVersion(), fullmsg, element->getLine(),
element->getColumn(), LIBSBML_SEV_WARNING);
}
}
//Whether or not we could figure out the error, we can always still continue flattening.
todelete.insert(element);
continue;
}
else {
delete allElements;
return ret;
}
}
SBase* direct = reference->getDirectReference();
bool adddirect = true;
if (type == SBML_COMP_REPLACEDBY) {
SBase* rbParent = reference->getParentSBMLObject();
if (uniqueRefs.insert(rbParent).second == false) {
if (doc) {
string error = "Error discovered in CompModelPlugin::saveAllReferencedElements when checking " + modname + ": a <" + rbParent->getElementName() + "> ";
if (direct->isSetId()) {
error += "with the id '" + rbParent->getId() + "'";
if (rbParent->isSetMetaId()) {
error += ", and the metaid '" + rbParent->getMetaId() + "'";
}
}
else if (rbParent->isSetMetaId()) {
error += "with the metaId '" + rbParent->getMetaId() + "'";
}
error += " has a <replacedBy> child and is also pointed to by a <port>, <deletion>, <replacedElement>, or one or more <replacedBy> objects.";
doc->getErrorLog()->logPackageError("comp", CompNoMultipleReferences, getPackageVersion(), getLevel(), getVersion(), error);
}
delete allElements;
return LIBSBML_OPERATION_FAILED;
}
adddirect = replacedBys.insert(direct).second;
}
if (type==SBML_COMP_REPLACEDELEMENT && re->isSetDeletion()) {
adddirect = RE_deletions.insert(direct).second;
}
if (adddirect) {
if (uniqueRefs.insert(direct).second == false) {
if (doc) {
string error = "Error discovered in CompModelPlugin::saveAllReferencedElements when checking " + modname + ": ";
if (replacedBys.find(direct) != replacedBys.end()) {
error += "one or more <replacedBy> elements, plus a <deletion>, <replacedElement>, or <port> element";
}
else if (RE_deletions.find(direct) != RE_deletions.end()) {
error += "one or more <replacedElement> elements using a 'deletion' attribute, plus a <deletion>, <replacedElement>, or <port> element";
}
else {
error += "multiple <deletion>, <replacedElement>, and/or <port> elements";
}
error += " point directly to the <" + direct->getElementName() + "> ";
if (direct->isSetId()) {
error += "with the id '" + direct->getId() + "'";
if (direct->isSetMetaId()) {
error += ", and the metaid '" + direct->getMetaId() + "'";
}
error += ".";
}
else if (direct->isSetMetaId()) {
error += "with the metaId '" + direct->getMetaId() + "'.";
}
doc->getErrorLog()->logPackageError("comp", CompNoMultipleReferences, getPackageVersion(), getLevel(), getVersion(), error);
}
delete allElements;
return LIBSBML_OPERATION_FAILED;
}
}
}
}
for(set<SBase*>::iterator el=todelete.begin(); el != todelete.end(); el++) {
(*el)->removeFromParentAndDelete();
}
delete allElements;
//Now call saveAllReferencedElements for all instantiated submodels.
for (unsigned long sm=0; sm<getNumSubmodels(); ++sm) {
Model* sub = getSubmodel((unsigned int)sm)->getInstantiation();
if (sub==NULL) {
return LIBSBML_OPERATION_FAILED;
}
CompModelPlugin* subplug = static_cast<CompModelPlugin*>(sub->getPlugin(getPrefix()));
if (subplug==NULL) {
return LIBSBML_OPERATION_FAILED;
}
ret = subplug->saveAllReferencedElements(uniqueRefs, replacedBys);
if (ret != LIBSBML_OPERATION_SUCCESS) {
return ret;
}
}
return LIBSBML_OPERATION_SUCCESS;
}
/*
* Reads the expected attributes into the member data variables
*/
void
CoordinateComponent::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes&
expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
if (static_cast<ListOfCoordinateComponents*>(getParentSBMLObject())->size() <
2)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial",
SpatialGeometryLOCoordinateComponentsAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial",
SpatialGeometryLOCoordinateComponentsAllowedCoreAttributes, pkgVersion,
level, version, details);
}
}
}
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial",
SpatialCoordinateComponentAllowedAttributes, pkgVersion, level, version,
details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial",
SpatialCoordinateComponentAllowedCoreAttributes, pkgVersion, level,
version, details);
}
}
//
// id SId (use = "required" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<CoordinateComponent>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(SpatialIdSyntaxRule, level, version, "The id '" + mId + "' does "
"not conform to the syntax.");
}
}
else
{
std::string message = "Spatial attribute 'id' is missing from the "
"<CoordinateComponent> element.";
log->logPackageError("spatial",
SpatialCoordinateComponentAllowedAttributes, pkgVersion, level, version,
message);
}
//
// type enum (use = "required" )
//
std::string type;
assigned = attributes.readInto("type", type);
if (assigned == true)
{
if (type.empty() == true)
{
logEmptyString(type, level, version, "<CoordinateComponent>");
}
else
{
mType = CoordinateKind_fromString(type.c_str());
if (CoordinateKind_isValid(mType) == 0)
{
std::string msg = "The type on the <CoordinateComponent> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + type + "', which is not a valid option.";
log->logPackageError("spatial",
SpatialCoordinateComponentTypeMustBeCoordinateKindEnum, pkgVersion,
level, version, msg);
}
}
}
else
{
std::string message = "Spatial attribute 'type' is missing.";
log->logPackageError("spatial",
SpatialCoordinateComponentAllowedAttributes, pkgVersion, level, version,
message);
}
//
// unit UnitSIdRef (use = "optional" )
//
assigned = attributes.readInto("unit", mUnit);
if (assigned == true)
{
if (mUnit.empty() == true)
{
logEmptyString(mUnit, level, version, "<CoordinateComponent>");
}
else if (SyntaxChecker::isValidSBMLSId(mUnit) == false)
{
logError(SpatialCoordinateComponentUnitMustBeUnitSId, level, version,
"The attribute unit='" + mUnit + "' does not conform to the syntax.");
}
}
}
LIBSBML_CPP_NAMESPACE_BEGIN
#ifdef __cplusplus
static void
parseChemicalFormula(std::string& chemicalFormula,
SBMLErrorLog& errLog, unsigned int packageVersion,
unsigned int level, unsigned int version)
{
std::vector< std::pair< std::string, int > > chemicalSymbols;
int chemicalNumber;
size_t index = 0;
size_t sizeStr = chemicalFormula.size();
char c = chemicalFormula[index];
while (index < sizeStr)
{
stringstream elementName;
stringstream elementCount;
if (isupper(c) == 0)
{
std::string message = "Encountered '";
message += c;
message += "' when expecting a capital letter.";
errLog.logPackageError("fbc", FbcSpeciesFormulaMustBeString,
packageVersion, level, version, message);
// at this point we already *know* the formula is bad, at this point
// the map generated woudl be invalid in any case, so we quit here.
return;
}
else
{
elementName << c;
index++;
}
// next char
if (index < sizeStr)
{
c = chemicalFormula[index];
// is it a letter
while (islower(c) != 0 && index < sizeStr)
{
elementName << c;
index++;
if (index < sizeStr)
{
c = chemicalFormula[index];
}
else
{
break;
}
}
// is the next char a number
while (isdigit(c) != 0 && index < sizeStr)
{
elementCount << c;
index++;
if (index < sizeStr)
{
c = chemicalFormula[index];
}
else
{
break;
}
}
}
const string& chemicalName = elementName.str();
const string& chemicalNum = elementCount.str();
// create the pair
if (chemicalNum.empty() == true)
{
chemicalNumber = 1;
}
else
{
chemicalNumber = atoi(chemicalNum.c_str());
}
chemicalSymbols.push_back(make_pair(chemicalName, chemicalNumber));
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
Group::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
if (static_cast<ListOfGroups*>(getParentSBMLObject())->size() < 2)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("groups", GroupsGroupAllowedAttributes,
pkgVersion, level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("groups",
GroupsModelLOGroupsAllowedCoreAttributes, pkgVersion, level, version,
details);
}
}
}
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("groups", GroupsGroupAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("groups", GroupsGroupAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
//
// id SId (use = "optional" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<Group>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
log->logPackageError("groups", GroupsIdSyntaxRule,
pkgVersion, level, version, "The id on the <"
+ getElementName() + "> is '" + mId + "', which does not conform to the syntax.",
getLine(), getColumn());
}
}
//
// name string (use = "optional" )
//
assigned = attributes.readInto("name", mName);
if (assigned == true)
{
if (mName.empty() == true)
{
logEmptyString(mName, level, version, "<Group>");
}
}
//
// kind enum (use = "required" )
//
std::string kind;
assigned = attributes.readInto("kind", kind);
if (assigned == true)
{
if (kind.empty() == true)
{
logEmptyString(kind, level, version, "<Group>");
}
else
{
mKind = GroupKind_fromString(kind.c_str());
if (GroupKind_isValid(mKind) == 0)
{
std::string msg = "The kind on the <Group> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + kind + "', which is not a valid option.";
log->logPackageError("groups", GroupsGroupKindMustBeGroupKindEnum,
pkgVersion, level, version, msg);
}
}
}
else
{
std::string message = "Groups attribute 'kind' is missing.";
log->logPackageError("groups", GroupsGroupAllowedAttributes, pkgVersion,
level, version, message);
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
Uncertainty::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("distrib", DistribUncertaintyAllowedAttributes,
pkgVersion, level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("distrib", DistribUncertaintyAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
//
// id SId (use = "optional" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<Uncertainty>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(DistribIdSyntaxRule, level, version, "The id '" + mId + "' does "
"not conform to the syntax.");
}
}
//
// name string (use = "optional" )
//
assigned = attributes.readInto("name", mName);
if (assigned == true)
{
if (mName.empty() == true)
{
logEmptyString(mName, level, version, "<Uncertainty>");
}
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
AnalyticVolume::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
if (static_cast<ListOfAnalyticVolumes*>(getParentSBMLObject())->size() < 2)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial",
SpatialAnalyticGeometryLOAnalyticVolumesAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial",
SpatialAnalyticGeometryLOAnalyticVolumesAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
}
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial", SpatialAnalyticVolumeAllowedAttributes,
pkgVersion, level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial",
SpatialAnalyticVolumeAllowedCoreAttributes, pkgVersion, level, version,
details);
}
}
//
// id SId (use = "required" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<AnalyticVolume>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(SpatialIdSyntaxRule, level, version, "The id '" + mId + "' does "
"not conform to the syntax.");
}
}
else
{
std::string message = "Spatial attribute 'id' is missing from the "
"<AnalyticVolume> element.";
log->logPackageError("spatial", SpatialAnalyticVolumeAllowedAttributes,
pkgVersion, level, version, message);
}
//
// functionType enum (use = "required" )
//
std::string functiontype;
assigned = attributes.readInto("functionType", functiontype);
if (assigned == true)
{
if (functiontype.empty() == true)
{
logEmptyString(functiontype, level, version, "<AnalyticVolume>");
}
else
{
mFunctionType = FunctionKind_fromString(functiontype.c_str());
if (FunctionKind_isValid(mFunctionType) == 0)
{
std::string msg = "The functionType on the <AnalyticVolume> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + functiontype + "', which is not a valid option.";
log->logPackageError("spatial",
SpatialAnalyticVolumeFunctionTypeMustBeFunctionKindEnum, pkgVersion,
level, version, msg);
}
}
}
else
{
std::string message = "Spatial attribute 'functionType' is missing.";
log->logPackageError("spatial", SpatialAnalyticVolumeAllowedAttributes,
pkgVersion, level, version, message);
}
//
// ordinal int (use = "optional" )
//
numErrs = log->getNumErrors();
mIsSetOrdinal = attributes.readInto("ordinal", mOrdinal);
if ( mIsSetOrdinal == false)
{
if (log->getNumErrors() == numErrs + 1 &&
log->contains(XMLAttributeTypeMismatch))
{
log->remove(XMLAttributeTypeMismatch);
std::string message = "Spatial attribute 'ordinal' from the "
"<AnalyticVolume> element must be an integer.";
log->logPackageError("spatial",
SpatialAnalyticVolumeOrdinalMustBeInteger, pkgVersion, level, version,
message);
}
}
//
// domainType SIdRef (use = "required" )
//
assigned = attributes.readInto("domainType", mDomainType);
if (assigned == true)
{
if (mDomainType.empty() == true)
{
logEmptyString(mDomainType, level, version, "<AnalyticVolume>");
}
else if (SyntaxChecker::isValidSBMLSId(mDomainType) == false)
{
logError(SpatialAnalyticVolumeDomainTypeMustBeDomainType, level, version,
"The attribute domainType='" + mDomainType + "' does not conform to the "
"syntax.");
}
}
else
{
std::string message = "Spatial attribute 'domainType' is missing from the "
"<AnalyticVolume> element.";
log->logPackageError("spatial", SpatialAnalyticVolumeAllowedAttributes,
pkgVersion, level, version, message);
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
ListOfGlobalRenderInformation::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes&
expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
SBMLErrorLog* log = getErrorLog();
ListOf::readAttributes(attributes, expectedAttributes);
if (log)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("render",
RenderListOfLayoutsLOGlobalRenderInformationAllowedAttributes,
pkgVersion, level, version, details, getLine(), getColumn());
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("render",
RenderListOfLayoutsLOGlobalRenderInformationAllowedCoreAttributes,
pkgVersion, level, version, details, getLine(), getColumn());
}
}
}
//
// majorVersion uint (use = "optional" )
//
if (log)
{
numErrs = log->getNumErrors();
}
mIsSetMajorVersion = attributes.readInto("versionMajor", mMajorVersion);
if ( mIsSetMajorVersion == false && log)
{
if (log->getNumErrors() == numErrs + 1 &&
log->contains(XMLAttributeTypeMismatch))
{
log->remove(XMLAttributeTypeMismatch);
std::string message = "Render attribute 'versionMajor' from the "
"<ListOfGlobalRenderInformation> element must be an integer.";
log->logPackageError("render",
RenderListOfLayoutsVersionMajorMustBeNonNegativeInteger, pkgVersion,
level, version, message, getLine(), getColumn());
}
}
//
// minorVersion uint (use = "optional" )
//
if (log)
{
numErrs = log->getNumErrors();
}
mIsSetMinorVersion = attributes.readInto("versionMinor", mMinorVersion);
if ( mIsSetMinorVersion == false && log)
{
if (log->getNumErrors() == numErrs + 1 &&
log->contains(XMLAttributeTypeMismatch))
{
log->remove(XMLAttributeTypeMismatch);
std::string message = "Render attribute 'versionMinor' from the "
"<ListOfGlobalRenderInformation> element must be an integer.";
log->logPackageError("render",
RenderListOfLayoutsVersionMinorMustBeNonNegativeInteger, pkgVersion,
level, version, message, getLine(), getColumn());
}
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
CSGNode::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
if (static_cast<ListOfCSGNodes*>(getParentSBMLObject())->size() < 2)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial",
SpatialCSGObjectLOCSGNodesAllowedAttributes, pkgVersion, level,
version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial",
SpatialCSGObjectLOCSGNodesAllowedCoreAttributes, pkgVersion, level,
version, details);
}
}
}
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("spatial", SpatialCSGNodeAllowedAttributes,
pkgVersion, level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("spatial", SpatialCSGNodeAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
//
// id SId (use = "optional" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<CSGNode>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(SpatialIdSyntaxRule, level, version, "The id '" + mId + "' does "
"not conform to the syntax.");
}
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
GraphicalPrimitive2D::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes&
expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
GraphicalPrimitive1D::readAttributes(attributes, expectedAttributes);
//
// fill string (use = "optional" )
//
assigned = attributes.readInto("fill", mFill);
if (assigned == true)
{
if (mFill.empty() == true && log)
{
logEmptyString(mFill, level, version, "<GraphicalPrimitive2D>");
}
}
//
// fill-rule enum (use = "optional" )
//
std::string fillRule;
assigned = attributes.readInto("fill-rule", fillRule);
if (assigned == true)
{
if (fillRule.empty() == true && log)
{
logEmptyString(fillRule, level, version, "<GraphicalPrimitive2D>");
}
else
{
mFillRule = FillRule_fromString(fillRule.c_str());
if (FillRule_isValid((FillRule_t)(mFillRule)) == 0)
{
std::string msg = "The fill-rule on the <GraphicalPrimitive2D> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + fillRule + "', which is not a valid option.";
if (log)
{
log->logPackageError("render",
RenderGraphicalPrimitive2DFillRuleMustBeFillRuleEnum, pkgVersion,
level, version, msg, getLine(), getColumn());
}
}
}
}
else
{
mFillRule = FILL_RULE_UNSET;
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
ClassThree::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("test", TestClassThreeAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("test", TestClassThreeAllowedCoreAttributes,
pkgVersion, level, version, details);
}
}
//
// number enum (use = "required" )
//
std::string number;
assigned = attributes.readInto("number", number);
if (assigned == true)
{
if (number.empty() == true)
{
logEmptyString(number, level, version, "<ClassThree>");
}
else
{
mNumber = Enum_fromString(number.c_str());
if (Enum_isValid(mNumber) == 0)
{
std::string msg = "The number on the <ClassThree> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + number + "', which is not a valid option.";
log->logPackageError("test", TestClassThreeNumberMustBeEnumEnum,
pkgVersion, level, version, msg);
}
}
}
else
{
std::string message = "Test attribute 'number' is missing.";
log->logPackageError("test", TestClassThreeAllowedAttributes, pkgVersion,
level, version, message);
}
//
// name enum (use = "required" )
//
std::string name;
assigned = attributes.readInto("name", name);
if (assigned == true)
{
if (name.empty() == true)
{
logEmptyString(name, level, version, "<ClassThree>");
}
else
{
mName = Fred_fromString(name.c_str());
if (Fred_isValid(mName) == 0)
{
std::string msg = "The name on the <ClassThree> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + name + "', which is not a valid option.";
log->logPackageError("test", TestClassThreeNameMustBeFredEnum,
pkgVersion, level, version, msg);
}
}
}
else
{
std::string message = "Test attribute 'name' is missing.";
log->logPackageError("test", TestClassThreeAllowedAttributes, pkgVersion,
level, version, message);
}
//
// badName enum (use = "optional" )
//
std::string badname;
assigned = attributes.readInto("badName", badname);
if (assigned == true)
{
if (badname.empty() == true)
{
logEmptyString(badname, level, version, "<ClassThree>");
}
else
{
mBadName = Fred_fromString(badname.c_str());
if (Fred_isValid(mBadName) == 0)
{
std::string msg = "The badName on the <ClassThree> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + badname + "', which is not a valid option.";
log->logPackageError("test", TestClassThreeBadNameMustBeFredEnum,
pkgVersion, level, version, msg);
}
}
}
//
// otherNum enum (use = "optional" )
//
std::string othernum;
assigned = attributes.readInto("otherNum", othernum);
if (assigned == true)
{
if (othernum.empty() == true)
{
logEmptyString(othernum, level, version, "<ClassThree>");
}
else
{
mOtherNum = Enum_fromString(othernum.c_str());
if (Enum_isValid(mOtherNum) == 0)
{
std::string msg = "The otherNum on the <ClassThree> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + othernum + "', which is not a valid option.";
log->logPackageError("test", TestClassThreeOtherNumMustBeEnumEnum,
pkgVersion, level, version, msg);
}
}
}
}
/** @cond doxygenLibsbmlInternal */
int
CompFlatteningConverter::validateFlatDocument(Model * flatmodel,
unsigned int pkgVersion, unsigned int level, unsigned int version)
{
int result;
// create a dummyDocument that will mirror what the user options are
// we need the dummyDoc to know things about unknown packages
// but dont want the original model/error log
SBMLDocument dummy = SBMLDocument(*(mDocument));
dummy.setModel(NULL);
dummy.getErrorLog()->clearLog();
// Otherwise, transfer only errors 1090107->1090110
SBMLErrorLog* log = mDocument->getErrorLog();
for (unsigned int en=0; en<log->getNumErrors(); en++)
{
unsigned int errid = mDocument->getError(en)->getErrorId();
if (errid == CompFlatteningNotRecognisedNotReqd ||
errid == CompFlatteningNotRecognisedReqd ||
errid == CompFlatteningNotImplementedNotReqd ||
errid == CompFlatteningNotImplementedReqd)
{
dummy.getErrorLog()->add(*(mDocument->getError(en)));
}
}
log->clearLog();
result = reconstructDocument(flatmodel, dummy, true );
if (result != LIBSBML_OPERATION_SUCCESS)
{
//delete flatmodel;
restoreNamespaces();
return result;
}
//Now check to see if the flat model is valid
// run regular validation on the flattened document if requested.
// override comp flattening if necessary
CompSBMLDocumentPlugin * dummyPlugin = static_cast<CompSBMLDocumentPlugin*>
(dummy.getPlugin("comp"));
if (dummyPlugin != NULL)
{
dummyPlugin->setOverrideCompFlattening(true);
}
std::string sbml = writeSBMLToStdString(&dummy);
SBMLDocument *tempdoc = readSBMLFromString(sbml.c_str());
unsigned int errors =
tempdoc->getErrorLog()->getNumFailsWithSeverity(LIBSBML_SEV_ERROR);
// take out the error about a requiredpackage
// if the user has specified to not abort for any packages
// NOTE: we cannot actually remove it since the flattening code
// uses it to check whether references might come from
// other packages
if (getAbortForNone() == true)
{
if (tempdoc->getErrorLog()->contains(RequiredPackagePresent))
{
errors--;
}
}
if (errors > 0)
{
// we have serious errors so we are going to bail on the
// flattening - log ONLY the errors
//Transfer the errors to mDocument and don't reset the model.
if (log->contains(CompLineNumbersUnreliable) == false)
{
log->logPackageError("comp", CompLineNumbersUnreliable,
pkgVersion, level, version);
}
std::string message = "Errors that follow relate to the flattened ";
message += "document produced using the CompFlatteningConverter.";
log->logPackageError("comp", CompFlatModelNotValid,
pkgVersion, level, version);
unsigned int nerrors = tempdoc->getErrorLog()->getNumErrors();
for (unsigned int n = 0; n < nerrors; n++)
{
const SBMLError* error = tempdoc->getError(n);
if (error->getSeverity() >= LIBSBML_SEV_ERROR)
{
log->add( *(error) );
}
if (error->getErrorId() >= CompFlatteningNotRecognisedNotReqd &&
error->getErrorId() <= CompFlatteningNotImplementedReqd)
{
log->add( *(error) );
}
else if (error->getErrorId() == UnrequiredPackagePresent ||
error->getErrorId() == RequiredPackagePresent)
{
log->add( *(error) );
}
}
//delete flatmodel;
restoreNamespaces();
delete tempdoc;
return LIBSBML_CONV_INVALID_SRC_DOCUMENT;
}
else
{
delete tempdoc;
}
dummy.checkConsistency();
if (dummyPlugin != NULL)
{
dummyPlugin->setOverrideCompFlattening(false);
}
errors = dummy.getErrorLog()->getNumFailsWithSeverity(LIBSBML_SEV_ERROR);
if (errors > 0)
{
// we have serious errors so we are going to bail on the
// flattening - log ONLY the errors
//Transfer the errors to mDocument and don't reset the model.
if (log->contains(CompLineNumbersUnreliable) == false)
{
log->logPackageError("comp", CompLineNumbersUnreliable,
pkgVersion, level, version);
}
std::string message = "Errors that follow relate to the flattened ";
message += "document produced using the CompFlatteningConverter.";
log->logPackageError("comp", CompFlatModelNotValid,
pkgVersion, level, version);
unsigned int nerrors = dummy.getErrorLog()->getNumErrors();
for (unsigned int n = 0; n < nerrors; n++)
{
const SBMLError* error = dummy.getError(n);
if (error->getSeverity() >= LIBSBML_SEV_ERROR)
{
log->add( *(error) );
}
if (error->getErrorId() >= CompFlatteningNotRecognisedNotReqd &&
error->getErrorId() <= CompFlatteningNotImplementedReqd)
{
log->add( *(error) );
}
else if (error->getErrorId() == UnrequiredPackagePresent ||
error->getErrorId() == RequiredPackagePresent)
{
log->add( *(error) );
}
}
//delete flatmodel;
restoreNamespaces();
return LIBSBML_CONV_INVALID_SRC_DOCUMENT;
}
else
{
// put any warnings into the document that will be have the
// flat model
unsigned int nerrors = dummy.getErrorLog()->getNumErrors();
for (unsigned int n = 0; n < nerrors; n++)
{
const SBMLError* error = dummy.getError(n);
log->add( *(error) );
}
return LIBSBML_OPERATION_SUCCESS;
}
}
/*
* Reads the expected attributes into the member data variables
*/
void
Output::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes)
{
unsigned int level = getLevel();
unsigned int version = getVersion();
unsigned int pkgVersion = getPackageVersion();
unsigned int numErrs;
bool assigned = false;
SBMLErrorLog* log = getErrorLog();
if (static_cast<ListOfOutputs*>(getParentSBMLObject())->size() < 2)
{
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("qual", QualTransitionLOOutputsAllowedAttributes,
pkgVersion, level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("qual",
QualTransitionLOOutputsAllowedCoreAttributes, pkgVersion, level,
version, details);
}
}
}
SBase::readAttributes(attributes, expectedAttributes);
numErrs = log->getNumErrors();
for (int n = numErrs-1; n >= 0; n--)
{
if (log->getError(n)->getErrorId() == UnknownPackageAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownPackageAttribute);
log->logPackageError("qual", QualOutputAllowedAttributes, pkgVersion,
level, version, details);
}
else if (log->getError(n)->getErrorId() == UnknownCoreAttribute)
{
const std::string details = log->getError(n)->getMessage();
log->remove(UnknownCoreAttribute);
log->logPackageError("qual", QualOutputAllowedCoreAttributes, pkgVersion,
level, version, details);
}
}
//
// id SId (use = "optional" )
//
assigned = attributes.readInto("id", mId);
if (assigned == true)
{
if (mId.empty() == true)
{
logEmptyString(mId, level, version, "<Output>");
}
else if (SyntaxChecker::isValidSBMLSId(mId) == false)
{
logError(QualIdSyntaxRule, level, version, "The id '" + mId + "' does not "
"conform to the syntax.");
}
}
//
// qualitativeSpecies SIdRef (use = "required" )
//
assigned = attributes.readInto("qualitativeSpecies", mQualitativeSpecies);
if (assigned == true)
{
if (mQualitativeSpecies.empty() == true)
{
logEmptyString(mQualitativeSpecies, level, version, "<Output>");
}
else if (SyntaxChecker::isValidSBMLSId(mQualitativeSpecies) == false)
{
logError(QualOutputQualitativeSpeciesMustBeQualitativeSpecies, level,
version, "The attribute qualitativeSpecies='" + mQualitativeSpecies + "' "
"does not conform to the syntax.");
}
}
else
{
std::string message = "Qual attribute 'qualitativeSpecies' is missing from "
"the <Output> element.";
log->logPackageError("qual", QualOutputAllowedAttributes, pkgVersion,
level, version, message);
}
//
// transitionEffect enum (use = "required" )
//
std::string transitioneffect;
assigned = attributes.readInto("transitionEffect", transitioneffect);
if (assigned == true)
{
if (transitioneffect.empty() == true)
{
logEmptyString(transitioneffect, level, version, "<Output>");
}
else
{
mTransitionEffect =
TransitionOutputEffect_fromString(transitioneffect.c_str());
if (TransitionOutputEffect_isValid(mTransitionEffect) == 0)
{
std::string msg = "The transitionEffect on the <Output> ";
if (isSetId())
{
msg += "with id '" + getId() + "'";
}
msg += "is '" + transitioneffect + "', which is not a valid option.";
log->logPackageError("qual",
QualOutputTransitionEffectMustBeTransitionOutputEffectEnum, pkgVersion,
level, version, msg);
}
}
}
else
{
std::string message = "Qual attribute 'transitionEffect' is missing.";
log->logPackageError("qual", QualOutputAllowedAttributes, pkgVersion,
level, version, message);
}
//
// name string (use = "optional" )
//
assigned = attributes.readInto("name", mName);
if (assigned == true)
{
if (mName.empty() == true)
{
logEmptyString(mName, level, version, "<Output>");
}
}
//
// outputLevel int (use = "optional" )
//
numErrs = log->getNumErrors();
mIsSetOutputLevel = attributes.readInto("outputLevel", mOutputLevel);
if ( mIsSetOutputLevel == false)
{
if (log->getNumErrors() == numErrs + 1 &&
log->contains(XMLAttributeTypeMismatch))
{
log->remove(XMLAttributeTypeMismatch);
std::string message = "Qual attribute 'outputLevel' from the <Output> "
"element must be an integer.";
log->logPackageError("qual", QualOutputOutputLevelMustBeInteger,
pkgVersion, level, version, message);
}
}
}
