CRDFUtilities Class Reference

#include <CRDFUtilities.h>

Public Member Functions
	CRDFUtilities ()
virtual	~CRDFUtilities ()

Static Public Member Functions
static bool	findNextElement (const std::string &rdfXml, const std::string &elementName, std::string::size_type &start, std::string::size_type &end)
static unsigned C_INT32	fixLocalFileAboutReference (std::string &rdfXml, const std::string &newId, const std::string &oldId)
static unsigned C_INT32	fixSBMLRdf (std::string &rdfXml)
static std::string	getNameSpaceQualifier (const std::string &rdfXml, const std::string &nameSpace)

Detailed Description

Definition at line 19 of file CRDFUtilities.h.

Constructor & Destructor Documentation

CRDFUtilities::CRDFUtilities

(

)

Constructor

Definition at line 259 of file CRDFUtilities.cpp.

{}

CRDFUtilities::~CRDFUtilities ( )

virtual

Destructor

Definition at line 262 of file CRDFUtilities.cpp.

{}

Member Function Documentation

bool CRDFUtilities::findNextElement ( const std::string &  rdfXml, const std::string &  elementName, std::string::size_type &  start, std::string::size_type &  end  )

static

Find the the next XML element with the given name (either start or end).

Parameters

const	std::string & rdfXml
const	std::string & elementName
std::string::size_type	& start
std::string::size_type	& end

Returns

bool found

Definition at line 181 of file CRDFUtilities.cpp.

Referenced by fixLocalFileAboutReference(), and fixSBMLRdf().

{
  static std::string WhiteSpace = "\x20\x09\x0D\x0A";

  bool ignore = false;
  bool ignoreDouble = false;
  bool ignoreSingle = false;

  if (end >= rdfXml.length())
    return false;

  std::string::const_iterator it = rdfXml.begin() + end;
  std::string::const_iterator itEnd = rdfXml.end();

  if (*it == '>' && it < itEnd) ++it;

  start = std::string::npos;
  end = std::string::npos;

  while (true)
    {
      for (; it < itEnd && end == std::string::npos; ++it)
        {
          switch (*it)
            {
            case '\'':
              if (!ignoreDouble)
                {
                  ignore = !ignore;
                  ignoreSingle = !ignoreSingle;
                }
              break;

            case '\"':
              if (!ignoreSingle)
                {
                  ignore = !ignore;
                  ignoreDouble = !ignoreDouble;
                }
              break;

            case '<':
              if (!ignore)
                start = it - rdfXml.begin();
              break;

            case '>':
              if (!ignore && start != std::string::npos)
                end = it - rdfXml.begin();
              break;

            default:
              break;
            }
        }

      if (end == std::string::npos)
        return false;

      if (elementName == "")
        return true;

      std::string::size_type NameStart = rdfXml.find_first_not_of(WhiteSpace, start + 1);
      std::string::size_type NameEnd = rdfXml.find_first_of(WhiteSpace + "/>", NameStart);

      if (rdfXml.substr(NameStart, NameEnd - NameStart) == elementName)
        return true;

      start = std::string::npos;
      end = std::string::npos;
    }

  return false;
}

unsigned C_INT32 CRDFUtilities::fixLocalFileAboutReference ( std::string &  rdfXml, const std::string &  newId, const std::string &  oldId  )

static

Fix local rdf:about attributes of the rdf:Description element. It returned the number of replacements made.

Parameters

std::string	& rdfXml
const	std::string & newId
const	std::string & oldId

Returns

unsigned C_INT32 replacements

Definition at line 21 of file CRDFUtilities.cpp.

References C_INT32, findNextElement(), and getNameSpaceQualifier().

Referenced by CAnnotation::operator==(), CAnnotation::setMiriamAnnotation(), and CSBMLExporter::updateMIRIAMAnnotation().

{
  // Nothing to do
  if (newId == oldId || rdfXml == "")
    return 0;

  // Determine the name space qualifier for http://www.w3.org/1999/02/22-rdf-syntax-ns#
  std::string Qualifier =
    getNameSpaceQualifier(rdfXml, "http://www.w3.org/1999/02/22-rdf-syntax-ns#");

  // Find all Qualifier:Description elements where the Qualifier:about attribute is
  // "#oldId"
  std::string::size_type start = 0;
  std::string::size_type end = 0;
  unsigned C_INT32 count = 0;

  // Find the next Qualifier:Description element.
  while (findNextElement(rdfXml, Qualifier + "Description", start, end))
    {
      // Determine the end of the element, i.e, a > which is not enclosed in " or '
      std::string::size_type pos = start;

      // Check whether we have a Qualifier:about attribute
      pos = rdfXml.find(Qualifier + "about=", start);
      if (pos < end && pos != std::string::npos)
        {
          pos += Qualifier.length() + 6;
          const char Quote = rdfXml[pos];
          pos++; // advance past Quote

          // Check whether we have a local id indicate by #
          if (rdfXml[pos] == '#')
            {
              pos++; // advance past #
              std::string::size_type len = rdfXml.find(Quote, pos) - pos;

              // Check whether we have a local file reference to the old id
              // or the old id was not given
              if (oldId == "" ||
                  rdfXml.substr(pos, len) == oldId)
                {
                  rdfXml.replace(pos, len, newId);
                  count++;
                }
            }
        }
    }

  return count;
}

unsigned C_INT32 CRDFUtilities::fixSBMLRdf ( std::string &  rdfXml )

static

Fix broken SBML RDF: <dc:creator rdf:parseType="Resource"> <rdf:Bag> It is not allowed to use the attribute rdf:parseType="Resource" and <rdf:Bag> simultaneously

Parameters

std::string

& rdfXml

Returns

unsigned C_INT32 corrections

Definition at line 75 of file CRDFUtilities.cpp.

References C_INT32, findNextElement(), getNameSpaceQualifier(), and min.

Referenced by CRDFGraphConverter::SBML2Copasi().

{

  // Nothing to do
  if (rdfXml == "")
    return 0;

  std::string::size_type start = 0;
  std::string::size_type end = 0;
  std::string::size_type pos = 0;
  unsigned C_INT32 count = 0;

  // Fix broken SBML RDF:
  // <dc:creator rdf:parseType="Resource">
  //   <rdf:Bag>
  // It is not allowed to use the attribute rdf:parseType="Resource" and <rdf:Bag> simultaneously

  // Determine the rdf name space qualifier for:
  std::string RDFQualifier =
    getNameSpaceQualifier(rdfXml, "http://www.w3.org/1999/02/22-rdf-syntax-ns#");

  // We first look for all elements having the attribute rdf:parseType="Resource"
  while (findNextElement(rdfXml, "", start, end))
    {
      if ((pos = std::min(rdfXml.find(RDFQualifier + "parseType=\"Resource\"", start),
                          rdfXml.find(RDFQualifier + "parseType='Resource'", start))) > end)
        continue;

      // We found the attribute.
      // Check whether the next element is an rdf:Bag
      // Remember the current candidate
      std::string::size_type currentStart = start;
      std::string::size_type currentEnd = end;
      if (findNextElement(rdfXml, "", start, end) &&
          findNextElement(rdfXml, RDFQualifier + "Bag", currentStart, currentEnd) &&
          start == currentStart &&
          end == currentEnd)
        {
          // The next element is a bag element. We therefore have to remove the attribute.
          rdfXml.erase(pos, RDFQualifier.length() + 20);
          end -= RDFQualifier.length() + 20;

          count++;
        }
    }

  start = 0;
  end = 0;
  pos = 0;

  // Fix broken SBML RDF:
  // <vCard:ORG>
  //  <vCard:Orgname>ORGANIZATION_NAME</vCard:Orgname>
  // </vCard:ORG>
  // The <vCard:ORG> element must have the attribute rdf:parseType="Resource".

  // Determine the vcard name space qualifier for:
  std::string VCardQualifier =
    getNameSpaceQualifier(rdfXml, "http://www.w3.org/2001/vcard-rdf/3.0#");

  // We first look for all elements having the attribute rdf:parseType="Resource"
  while (findNextElement(rdfXml, VCardQualifier + "ORG", start, end))
    {
      // Check whether the attribute rdf:parseType="Resource" is present.
      if ((pos = std::min(rdfXml.find(RDFQualifier + "parseType=\"Resource\"", start),
                          rdfXml.find(RDFQualifier + "parseType='Resource'", start))) < end)
        continue;

      // The attribute is missing we insert it.
      rdfXml.insert(end, " " + RDFQualifier + "parseType=\"Resource\"");
      count++;
    }
  return count;
}

std::string CRDFUtilities::getNameSpaceQualifier ( const std::string &  rdfXml, const std::string &  nameSpace  )

static

Find the qualifier for the given name space. Please note the qualifier if found has a ':' already appended.

Parameters

const	std::string & rdfXml
const	std::string & nameSpace

Returns

std::string qualifier

Definition at line 151 of file CRDFUtilities.cpp.

Referenced by fixLocalFileAboutReference(), and fixSBMLRdf().

{
  std::string::size_type start = 0;
  std::string::size_type end = 0;

  while (true)
    {
      // Locate first name space declaration
      start = rdfXml.find("xmlns:", end);
      if (start == std::string::npos)
        break;

      start += 6;
      end = rdfXml.find("=", start);
      if (end == std::string::npos)
        break;

      if (rdfXml.compare(end + 1, nameSpace.length() + 2, "\"" + nameSpace + "\"") &&
          rdfXml.compare(end + 1, nameSpace.length() + 2, "'" + nameSpace + "'"))
        continue;

      // We have the qualifier
      return rdfXml.substr(start, end - start) + ":";
    }

  return "";
}

---

The documentation for this class was generated from the following files:

• CRDFUtilities.h
• CRDFUtilities.cpp