CRDFGraphConverter Class Reference

#include <CRDFGraphConverter.h>

Collaboration diagram for CRDFGraphConverter:

Classes
struct	sChange

Static Public Member Functions
static bool	SBML2Copasi (std::string &XML)

Static Private Member Functions
static bool	convert (CRDFGraph *pGraph, const sChange *changes)
static bool	convert (CRDFGraph *pGraph, const CRDFTriplet &triplet, const CRDFPredicate::Path &newPath)

Static Private Attributes
static sChange	SBML2CopasiChanges []

Detailed Description

Definition at line 29 of file CRDFGraphConverter.h.

Member Function Documentation

bool CRDFGraphConverter::convert ( CRDFGraph *  pGraph, const sChange *  changes  )

staticprivate

Definition at line 171 of file CRDFGraphConverter.cpp.

References CRDFPredicate::end, CRDFGraph::getTriplets(), CRDFGraphConverter::sChange::Source, and CRDFGraphConverter::sChange::Target.

Referenced by convert(), and SBML2Copasi().

{
  bool success = true;

  std::set< CRDFTriplet> Triplets;
  std::set< CRDFTriplet>::iterator it;
  std::set< CRDFTriplet>::iterator end;

  const sChange * pChange = changes;

  // We iterate over each predicate which needs to be changed.
  for (; pChange->Source != CRDFPredicate::end; ++pChange)
    {
      std::set< CRDFTriplet > Failed;

      // Create the new path
      CRDFPredicate::Path NewPath;
      const CRDFPredicate::ePredicateType * pNewPath = pChange->Target;

      while (*pNewPath != CRDFPredicate::end)
        NewPath.push_back(*pNewPath++);

      // Each change may break the triplets, i.e. we need to refresh every time
      while ((Triplets = pGraph->getTriplets(pChange->Source, false)).size() > Failed.size())
        {
          // Skip all failed triplets
          for (it = Triplets.begin(), end = Triplets.end(); it != end; ++it)
            if (Failed.find(*it) == Failed.end())
              break;

          if (!convert(pGraph, *it, NewPath))
            {
              Failed.insert(*it);
              success = false;
            }
        }
    }

  return success;
}

bool CRDFGraphConverter::convert ( CRDFGraph *  pGraph, const CRDFTriplet &  triplet, const CRDFPredicate::Path &  newPath  )

staticprivate

Definition at line 213 of file CRDFGraphConverter.cpp.

References CRDFNode::addEdge(), CRDFGraph::addTriplet(), CRDFObject::BLANK_NODE, C_INVALID_INDEX, convert(), CRDFGraph::generatedNodeId(), CRDFPredicate::getAllowedLocationList(), CRDFNode::getDescendantsWithPredicate(), CRDFNode::getPath(), CRDFNode::getSubject(), CRDFPredicate::getSubPathIndex(), CRDFPredicate::getURI(), CRDFNode::isBagNode(), CRDFGraph::moveTriplet(), CRDFTriplet::pObject, CRDFTriplet::Predicate, CRDFTriplet::pSubject, CRDFPredicate::rdf_li, CRDFPredicate::rdf_type, CRDFNode::removeEdge(), CRDFGraph::removeTriplet(), CRDFObject::RESOURCE, CRDFObject::setBlankNodeId(), CRDFObject::setResource(), and CRDFObject::setType().

{
  CRDFPredicate::Path CurrentPath = triplet.pObject->getPath();

  size_t SubPathIndex = C_INVALID_INDEX;

  while (SubPathIndex == C_INVALID_INDEX && SubPathIndex > 0)
    {
      // We differ at least at the final predicate.
      CurrentPath.pop_back();
      SubPathIndex = CRDFPredicate::getSubPathIndex(newPath, CurrentPath);
    }

  if (SubPathIndex == 0)
    return false;

  CurrentPath = triplet.pObject->getPath();

  bool success = true;

  CRDFTriplet Triplet;

  if (CurrentPath.size() < newPath.size())
    {
      // We need to create the additional node pointed to by newPath[SubPathIndex]
      // Verify that the node to be created is a blank node.
      CRDFPredicate::AllowedLocationList List =
        CRDFPredicate::getAllowedLocationList(newPath[SubPathIndex]);
      CRDFPredicate::AllowedLocationList::const_iterator it = List.begin();
      CRDFPredicate::AllowedLocationList::const_iterator end = List.end();

      for (; it != end; ++it)
        {
          if (it->Type == CRDFObject::BLANK_NODE &&
              CRDFPredicate::getSubPathIndex(newPath, it->Location))
            break;
        }

      if (it == end)
        return false;

      // We are now sure that the new predicate points to a blank node.
      CRDFObject Object;
      Object.setType(CRDFObject::BLANK_NODE);
      Object.setBlankNodeId(pGraph->generatedNodeId());

      Triplet = pGraph->addTriplet(triplet.pSubject->getSubject(),
                                   CRDFPredicate::getURI(newPath[SubPathIndex]),
                                   Object);

      // We need to address the issue when a bag has to be moved.
      if (Triplet)
        {
          if (triplet.pObject->isBagNode())
            {
              std::set< CRDFTriplet> Triplets = triplet.pObject->getDescendantsWithPredicate(CRDFPredicate::rdf_li);

              if (Triplets.size() == 0)
                {
                  pGraph->removeTriplet(Triplet.pSubject, Triplet.Predicate, Triplet.pObject);

                  return false;
                }

              // Bagify the node.
              CRDFObject Object;
              Object.setType(CRDFObject::RESOURCE);
              Object.setResource("http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag", false);
              pGraph->addTriplet(Triplet.pObject->getSubject(), CRDFPredicate(CRDFPredicate::rdf_type), Object);

              // Now we move each li element with the current predicate
              std::set< CRDFTriplet>::iterator it = Triplets.begin();
              std::set< CRDFTriplet>::iterator end = Triplets.end();

              for (; it != end; ++it)
                {
                  CRDFObject Object;
                  Object.setType(CRDFObject::BLANK_NODE);
                  Object.setBlankNodeId(pGraph->generatedNodeId());

                  CRDFTriplet LiTriplet = pGraph->addTriplet(Triplet.pObject->getSubject(),
                                          CRDFPredicate(CRDFPredicate::rdf_li),
                                          Object);

                  if (LiTriplet)
                    {
                      success &= LiTriplet.pObject->addEdge(triplet.Predicate, it->pObject);
                      it->pSubject->removeEdge(CRDFPredicate(CRDFPredicate::rdf_li), it->pObject);
                    }
                  else
                    {
                      success = false;
                    }
                }

              // We have handled the triplet it can be removed from the graph.
              pGraph->removeTriplet(triplet.pSubject, triplet.Predicate, triplet.pObject);

              return success;
            }
          else
            {
              Triplet = pGraph->moveTriplet(Triplet.pObject, triplet);
            }
        }
    }
  else if (CurrentPath.size() > newPath.size())
    {
      // TODO This needs to be implemented
      // Removing an edge will always result in loosing information!
    }
  else
    {
      // We just have to rename the predicate
      success &= triplet.pSubject->addEdge(newPath[SubPathIndex], triplet.pObject);
      triplet.pSubject->removeEdge(CurrentPath[SubPathIndex], triplet.pObject);

      if (success)
        {
          Triplet = triplet;
          Triplet.Predicate = newPath[SubPathIndex];
        }
    }

  if (!Triplet)
    return false;

  // Check whether we are finished
  if (SubPathIndex == newPath.size() - 1)
    return success;

  return convert(pGraph, Triplet, newPath);
}

bool CRDFGraphConverter::SBML2Copasi ( std::string &  XML )

static

Definition at line 119 of file CRDFGraphConverter.cpp.

References CRDFGraph::clean(), convert(), CRDFUtilities::fixSBMLRdf(), CCopasiMessage::getLastMessage(), CRDFParser::graphFromXml(), MCSBML, SBML2CopasiChanges, CCopasiMessage::size(), CRDFGraph::updateNamespaces(), CCopasiMessage::WARNING_FILTERED, and CRDFWriter::xmlFromGraph().

Referenced by SBMLImporter::importMIRIAM(), and test000092::test_miriam_export_7().

{
  // Fix the the broken SBML RDF
  if (CRDFUtilities::fixSBMLRdf(XML))
    CCopasiMessage(CCopasiMessage::WARNING_FILTERED, MCSBML + 75);

  // Create the RDF graph
  CRDFGraph * pGraph = CRDFParser::graphFromXml(XML);

  if (pGraph == NULL)
    return false;

  // Convert the graph.
  bool success = convert(pGraph, SBML2CopasiChanges);

  // Serialize the graph
  pGraph->clean();
  pGraph->updateNamespaces();

  XML = CRDFWriter::xmlFromGraph(pGraph);

  if (pGraph != NULL)
    {
      delete pGraph;
      pGraph = NULL;
    }

  // It is possible that the graph is still corrupt due secondary errors.
  // Another parse and write should take care of this.
  size_t Size = CCopasiMessage::size();

  pGraph = CRDFParser::graphFromXml(XML);

  if (pGraph == NULL)
    return false;

  XML = CRDFWriter::xmlFromGraph(pGraph);

  if (pGraph != NULL)
    {
      delete pGraph;
      pGraph = NULL;
    }

  // Remove error messages created by the second parse as these are secondary.
  while (CCopasiMessage::size() > Size)
    CCopasiMessage::getLastMessage();

  return success;
}

Member Data Documentation

CRDFGraphConverter::sChange CRDFGraphConverter::SBML2CopasiChanges

staticprivate

Definition at line 41 of file CRDFGraphConverter.h.

Referenced by SBML2Copasi().

---

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

• CRDFGraphConverter.h
• CRDFGraphConverter.cpp