CCreator* CMIRIAMInfo::createCreator(const std::string & /* objectName */)
{
const CRDFSubject & Subject = mpRDFGraph->getAboutNode()->getSubject();
CRDFObject Object;
Object.setType(CRDFObject::BLANK_NODE);
std::string Id = mpRDFGraph->generatedNodeId();
Object.setBlankNodeId(Id);
CRDFTriplet Triplet =
mpRDFGraph->addTriplet(Subject,
CRDFPredicate::getURI(CRDFPredicate::dcterms_creator),
Object);
if (!Triplet)
return NULL;
CCreator * pCreator = new CCreator(Triplet);
if (!mCreators.add(pCreator, true))
{
delete pCreator;
return NULL;
}
return pCreator;
}
CRDFNode * CRDFNode::createMissingAncestors(const CRDFPredicate::Path & predicatePath,
const size_t & level)
{
CRDFNode * pNode = this;
size_t i, imax = predicatePath.size() - 1; // We only create the ancestors
for (i = level; i < imax; i++)
{
std::set< CRDFTriplet > Triplets =
getDescendantsWithPredicate(predicatePath[i]);
// Check whether the predicate exists.
if (Triplets.size() > 0)
{
pNode = Triplets.begin()->pObject;
}
else
{
CRDFObject object;
object.setType(CRDFObject::BLANK_NODE);
object.setBlankNodeId(mGraph.generatedNodeId());
CRDFTriplet Triplet =
mGraph.addTriplet(pNode->getSubject(), CRDFPredicate::getURI(predicatePath[i]), object);
if (!Triplet)
return NULL;
else
pNode = Triplet.pObject;
}
}
return pNode;
}
bool CRDFNode::setFieldValue(const CMIRIAMResourceObject & value,
const CRDFPredicate::ePredicateType & predicate,
const CRDFPredicate::Path & nodePath)
{
// If a node is associated with the resource we can just set the field value
if (value.getNode() != NULL)
return value.getNode()->setFieldValue(value.getURI(), predicate, nodePath);
// We have no node and the value is invalid, i.e., nothing to do.
if (!value.isValid())
return true;
// We need to create a node
// We build each missing ancestor as a blank node.
CRDFPredicate::sAllowedLocation const * pLocation = NULL;
CRDFNode * pParent = createMissingAncestors(nodePath, predicate, pLocation);
if (pParent == NULL) return false;
// Create the missing object
CRDFObject object;
object.setType(CRDFObject::RESOURCE);
object.setResource(value.getURI(), false);
bool success = true;
if (!mGraph.addTriplet(pParent->getSubject(), CRDFPredicate::getURI(predicate), object))
success = false;
return success;
}
CModification * CMIRIAMInfo::createModification(const std::string& dateTime)
{
const CRDFSubject & Subject = mpRDFGraph->getAboutNode()->getSubject();
CRDFObject Object;
Object.setType(CRDFObject::BLANK_NODE);
std::string Id = mpRDFGraph->generatedNodeId();
Object.setBlankNodeId(Id);
CRDFTriplet Triplet =
mpRDFGraph->addTriplet(Subject,
CRDFPredicate::getURI(CRDFPredicate::dcterms_modified),
Object);
if (!Triplet)
return NULL;
CModification * pModification = new CModification(Triplet);
if (dateTime.size())
pModification->setDate(dateTime);
if (!mModifications.add(pModification, true))
{
delete pModification;
return NULL;
}
return pModification;
}
CReference* CMIRIAMInfo::createReference(const std::string & /* objectName */)
{
const CRDFSubject & Subject = mpRDFGraph->getAboutNode()->getSubject();
CRDFObject Object;
Object.setType(CRDFObject::BLANK_NODE);
std::string Id = mpRDFGraph->generatedNodeId();
Object.setBlankNodeId(Id);
CRDFTriplet Triplet =
mpRDFGraph->addTriplet(Subject,
CRDFPredicate::getURI(CRDFPredicate::dcterms_bibliographicCitation),
Object);
if (!Triplet)
return NULL;
CReference * pReference = new CReference(Triplet);
if (!mReferences.add(pReference, true))
{
delete pReference;
return NULL;
}
return pReference;
}
CRDFTriplet CRDFNode::addEdge(const CRDFPredicate & predicate, CRDFNode * pObject)
{
CRDFTriplet Failed;
CRDFTriplet Triplet(this, predicate, pObject);
// We do not want any duplicate triplets;
if (mGraph.getTriplets().count(Triplet) > 0)
return Failed;
// If this is a bag node the only predicate allowed is rdf_li.
if (isBagNode() && predicate != CRDFPredicate::rdf_li)
return Failed;
// If the predicate is rdf:li and this is not a bag node we bagify it.
if (!isBagNode() && predicate == CRDFPredicate::rdf_li)
{
// Bagify the node.
CRDFObject Object;
Object.setType(CRDFObject::RESOURCE);
Object.setResource("http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag", false);
if (!mGraph.addTriplet(this->getSubject(), CRDFPredicate(CRDFPredicate::rdf_type), Object))
return Failed;
}
// We now can safely insert any edge with the predicate rdf_li
if (predicate == CRDFPredicate::rdf_li)
{
if (!addTripletToGraph(Triplet))
return Failed;
return Triplet;
}
if (!addTripletToGraph(Triplet))
return Failed;
return Triplet;
}
CBiologicalDescription* CMIRIAMInfo::createBiologicalDescription()
{
const CRDFSubject & Subject = mpRDFGraph->getAboutNode()->getSubject();
CRDFObject Object;
Object.setType(CRDFObject::RESOURCE);
Object.setResource("", false);
CRDFTriplet Triplet = mpRDFGraph->addTriplet(Subject, std::string("---"), Object);
if (!Triplet)
return NULL;
CBiologicalDescription * pBiologicalDescription =
new CBiologicalDescription(Triplet);
if (!mBiologicalDescriptions.add(pBiologicalDescription, true))
{
delete pBiologicalDescription;
return NULL;
}
return pBiologicalDescription;
}
void CMIRIAMInfo::setCreatedDT(const std::string& dt)
{
std::string Date = dt;
if (Date == "0000-00-00T00:00:00")
Date = ""; // This causes deletion of the edge
if (!mCreated)
{
const CRDFSubject & Subject = mTriplet.pObject->getSubject();
CRDFObject Object;
Object.setType(CRDFObject::BLANK_NODE);
std::string Id = mpRDFGraph->generatedNodeId();
Object.setBlankNodeId(Id);
mCreated = mpRDFGraph->addTriplet(Subject,
CRDFPredicate::getURI(CRDFPredicate::dcterms_created),
Object);
// Debugging
assert(!mCreated == false);
}
mCreated.pObject->setFieldValue(Date, CRDFPredicate::dcterms_W3CDTF, mCreated.pObject->getPath());
}
bool CRDFNode::setFieldValue(const std::string & value,
const CRDFPredicate::ePredicateType & predicate,
const CRDFPredicate::Path & nodePath)
{
std::set< CRDFTriplet > Triplets =
getDescendantsWithPredicate(predicate);
CRDFNode * pObject = NULL;
if (Triplets.size() > 0)
pObject = Triplets.begin()->pObject;
// Check whether the value is not empty.
if (value != "")
{
// We do not have an object
if (pObject == NULL)
{
// We build each missing ancestor as a blank node.
CRDFPredicate::sAllowedLocation const * pLocation = NULL;
CRDFNode * pParent = createMissingAncestors(nodePath, predicate, pLocation);
if (pParent == NULL) return false;
// Create the missing object
CRDFObject object;
object.setType(pLocation->Type);
if (object.getType() == CRDFObject::BLANK_NODE)
object.setBlankNodeId(mGraph.generatedNodeId());
CRDFTriplet Triplet =
mGraph.addTriplet(pParent->getSubject(), CRDFPredicate::getURI(predicate), object);
if (!Triplet)
return false;
pObject = Triplet.pObject;
// Debugging
assert(pObject != NULL);
}
// Now we finally can save the information.
CRDFObject & Object = pObject->getObject();
switch (Object.getType())
{
case CRDFObject::LITERAL:
{
CRDFLiteral & Literal = Object.getLiteral();
Literal.setType(CRDFLiteral::PLAIN);
Literal.setLexicalData(value);
}
break;
case CRDFObject::RESOURCE:
Object.setResource(value, false);
break;
case CRDFObject::BLANK_NODE:
fatalError();
break;
}
}
else if (pObject != NULL)
removeTripletFromGraph(*Triplets.begin());
return true;
}
// static
void CRDFParser::TripleHandler(void * pGraph, const raptor_statement * pTriple)
{
// We need to create a CRDFSubject, Predicate, and CRDFObject
CRDFSubject Subject;
std::string Predicate;
CRDFObject Object;
CRDFLiteral Literal;
switch (pTriple->subject_type)
{
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
Subject.setType(CRDFSubject::RESOURCE);
Subject.setResource((char *) raptor_uri_as_string((raptor_uri *) pTriple->subject),
CRaptorInit::isLocalURI((raptor_uri *) pTriple->subject));
break;
case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS:
Subject.setType(CRDFSubject::BLANK_NODE);
Subject.setBlankNodeId((char *) pTriple->subject);
break;
default:
fatalError();
}
switch (pTriple->predicate_type)
{
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
Predicate = (char *) raptor_uri_as_string((raptor_uri *) pTriple->predicate);
break;
default:
fatalError();
}
switch (pTriple->object_type)
{
case RAPTOR_IDENTIFIER_TYPE_ORDINAL:
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
Object.setType(CRDFObject::RESOURCE);
Object.setResource((char *) raptor_uri_as_string((raptor_uri *) pTriple->object),
CRaptorInit::isLocalURI((raptor_uri *) pTriple->object));
break;
case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS:
Object.setType(CRDFObject::BLANK_NODE);
Object.setBlankNodeId((char *) pTriple->object);
break;
case RAPTOR_IDENTIFIER_TYPE_LITERAL:
Object.setType(CRDFObject::LITERAL);
if (pTriple->object_literal_datatype != NULL)
{
Literal.setType(CRDFLiteral::TYPED);
Literal.setDataType((const char *) raptor_uri_as_string(pTriple->object_literal_datatype));
}
else
{
Literal.setType(CRDFLiteral::PLAIN);
if (pTriple->object_literal_language != NULL)
Literal.setLanguage((const char *) pTriple->object_literal_language);
}
Literal.setLexicalData((char *) pTriple->object);
Object.setLiteral(Literal);
break;
default:
fatalError();
}
// Add the triplet to the graph
static_cast<CRDFGraph *>(pGraph)->addTriplet(Subject, Predicate, Object);
}
