/**
* Sets the type of an ASTNode based on the given MathML <cn> element.
* Errors will be logged in the stream's SBMLErrorLog object.
*/
static void
setTypeCN (ASTNode& node, const XMLToken& element, XMLInputStream& stream)
{
string type = "real";
element.getAttributes().readInto("type", type);
// here is the only place we might encounter the sbml:units attribute
string units = "";
element.getAttributes().readInto("units", units);
if (type == "real")
{
double value = 0;
istringstream isreal;
isreal.str( stream.next().getCharacters() );
isreal >> value;
node.setValue(value);
if (isreal.fail()
|| node.isInfinity()
|| node.isNegInfinity()
)
{
static_cast <SBMLErrorLog*>
(stream.getErrorLog())->logError(FailedMathMLReadOfDouble,
stream.getSBMLNamespaces()->getLevel(),
stream.getSBMLNamespaces()->getVersion());
}
}
/**
* Sets the type of an ASTNode based on the given MathML <ci> element.
* Errors will be logged in the stream's SBMLErrorLog object.
*/
static void
setTypeCI (ASTNode& node, const XMLToken& element, XMLInputStream& stream)
{
if (element.getName() == "csymbol")
{
string url;
element.getAttributes().readInto("definitionURL", url);
if ( url == URL_DELAY ) node.setType(AST_FUNCTION_DELAY);
else if ( url == URL_TIME ) node.setType(AST_NAME_TIME);
else if ( url == URL_AVOGADRO ) node.setType(AST_NAME_AVOGADRO);
else
{
static_cast <SBMLErrorLog*>
(stream.getErrorLog())->logError(BadCsymbolDefinitionURLValue,
stream.getSBMLNamespaces()->getLevel(),
stream.getSBMLNamespaces()->getVersion());
}
}
else if (element.getName() == "ci")
{
node.setDefinitionURL(element.getAttributes());
}
const string name = trim( stream.next().getCharacters() );
node.setName( name.c_str() );
}
void
ASTCnBase::addExpectedAttributes(ExpectedAttributes& attributes,
XMLInputStream& stream)
{
ASTBase::addExpectedAttributes(attributes, stream);
if (stream.getSBMLNamespaces() != NULL
&& stream.getSBMLNamespaces()->getLevel() > 2)
{
attributes.add("units");
}
attributes.add("type");
}
bool
AnalyticVolume::readOtherXML (XMLInputStream& stream)
{
bool read = false;
const string& name = stream.peek().getName();
if (name == "math")
{
const XMLToken elem = stream.peek();
const std::string prefix = checkMathMLNamespace(elem);
if (stream.getSBMLNamespaces() == NULL)
{
stream.setSBMLNamespaces(new SBMLNamespaces(getLevel(), getVersion()));
}
delete mMath;
mMath = readMathML(stream, prefix);
read = true;
}
if (SBase::readOtherXML(stream))
{
read = true;
}
return read;
}
bool
ASTCnBase::read(XMLInputStream& stream, const std::string& )
{
bool read = false;
const XMLToken element = stream.next ();
ExpectedAttributes expectedAttributes;
addExpectedAttributes(expectedAttributes, stream);
read = readAttributes(element.getAttributes(), expectedAttributes,
stream, element);
string prefix;
if (isSetUnits() == true)
{
prefix = element.getAttrPrefix(
element.getAttrIndex("units", stream.getSBMLNamespaces()->getURI()));
setUnitsPrefix(prefix);
}
//return ASTBase::read(stream, reqd_prefix);
return read;
}
void
ASTBase::logError (XMLInputStream& stream, const XMLToken& element, SBMLErrorCode_t code,
const std::string& msg)
{
SBMLNamespaces* ns = stream.getSBMLNamespaces();
if (ns != NULL)
{
static_cast <SBMLErrorLog*>
(stream.getErrorLog())->logError(
code,
ns->getLevel(),
ns->getVersion(),
msg,
element.getLine(),
element.getColumn());
}
else
{
static_cast <SBMLErrorLog*>
(stream.getErrorLog())->logError(
code,
SBML_DEFAULT_LEVEL,
SBML_DEFAULT_VERSION,
msg,
element.getLine(),
element.getColumn());
}
}
void
ASTCiNumberNode::addExpectedAttributes(ExpectedAttributes& attributes,
XMLInputStream& stream)
{
ASTBase::addExpectedAttributes(attributes, stream);
SBMLNamespaces * sbmlns = stream.getSBMLNamespaces();
if (sbmlns != NULL)
{
if (sbmlns->getLevel() > 2)
{
attributes.add("definitionURL");
}
else if (sbmlns->getLevel() == 2 && sbmlns->getVersion() == 5)
{
attributes.add("definitionURL");
}
}
}
bool
ASTBase::readAttributes(const XMLAttributes& attributes,
const ExpectedAttributes& expectedAttributes,
XMLInputStream& stream, const XMLToken& element)
{
bool read = true;
//
// check that all attributes are expected
//
for (int i = 0; i < attributes.getLength(); i++)
{
std::string name = attributes.getName(i);
std::string uri = attributes.getURI(i);
std::string prefix = attributes.getPrefix(i);
//
// To allow prefixed attribute whose namespace doesn't belong to
// core or extension package.
//
// (e.g. xsi:type attribute in Curve element in layout extension)
//
if (!prefix.empty())
{
if ( expectedAttributes.hasAttribute(prefix + ":" + name) ) continue;
}
if (!expectedAttributes.hasAttribute(name))
{
std::string message = "The attribute '" + name + "' is not permitted" +
" on a <" + element.getName() + "> element.";
if (name == "type")
{
logError(stream, element, DisallowedMathTypeAttributeUse, message);
}
else if (name == "encoding")
{
logError(stream, element, DisallowedMathMLEncodingUse, message);
}
else if (name == "definitionURL")
{
logError(stream, element, DisallowedDefinitionURLUse, message);
}
else if (name == "units")
{
if (stream.getSBMLNamespaces() != NULL
&& stream.getSBMLNamespaces()->getLevel() > 2)
{
logError(stream, element, DisallowedMathUnitsUse, message);
}
else
{
message = "The 'units' attribute was introduced in SBML Level 3.";
logError(stream, element, InvalidMathMLAttribute, message);
}
}
else
{
logError(stream, element, InvalidMathElement, message);
}
// not sufficient to make the read bad
//return false;
}
}
string id;
string className;
string style;
attributes.readInto( "id" , id );
attributes.readInto( "class" , className );
attributes.readInto( "style" , style );
if (!id.empty())
{
if (setId(id) != LIBSBML_OPERATION_SUCCESS)
{
read = false;
}
}
if (!className.empty())
{
if (setClass(className) != LIBSBML_OPERATION_SUCCESS)
{
read = false;
}
}
if (!style.empty())
{
if (setStyle(style) != LIBSBML_OPERATION_SUCCESS)
{
read = false;
}
}
unsigned int i = 0;
while (read == true && i < getNumPlugins())
{
read = getPlugin(i)->readAttributes(attributes, expectedAttributes,
stream, element, getExtendedType());
i++;
}
return read;
}