public RDFTriple(RDFTriple triple)
{
if(triple==null)throw new ArgumentNullException("triple");
setSubject(triple.subject);
setPredicate(triple.predicate);
setObject(triple._object);
}
public RDFTriple(RDFTriple triple)
{
if (triple == null)
{
throw new ArgumentNullException("triple");
}
setSubject(triple.subject);
setPredicate(triple.predicate);
setObject(triple._object);
}
/**
* Replaces certain blank nodes with blank nodes whose
* names meet the N-Triples requirements
* @param triples A set of RDF triples
* @param bnodeLabels A mapping of blank node names
* already allocated. This method will modify this
* _object as needed to allocate new blank nodes.
*/
internal static void replaceBlankNodes(ISet<RDFTriple> triples,
IDictionary<string,RDFTerm> bnodeLabels)
{
if(bnodeLabels.Count==0)
return;
IDictionary<string,RDFTerm> newBlankNodes=new PeterO.Support.LenientDictionary<string,RDFTerm>();
IList<RDFTriple[]> changedTriples=new List<RDFTriple[]>();
int[] nodeindex=new int[]{0};
foreach(var triple in triples){
bool changed=false;
RDFTerm subj=triple.getSubject();
if(subj.getKind()==RDFTerm.BLANK){
string oldname=subj.getValue();
string newname=suggestBlankNodeName(oldname,nodeindex,bnodeLabels);
if(!newname.Equals(oldname)){
RDFTerm newNode=newBlankNodes[oldname];
if(newNode==null){
newNode=RDFTerm.fromBlankNode(newname);
bnodeLabels.Add(newname, newNode);
newBlankNodes.Add(oldname, newNode);
}
subj=newNode;
changed=true;
}
}
RDFTerm obj=triple.getObject();
if(obj.getKind()==RDFTerm.BLANK){
string oldname=obj.getValue();
string newname=suggestBlankNodeName(oldname,nodeindex,bnodeLabels);
if(!newname.Equals(oldname)){
RDFTerm newNode=newBlankNodes[oldname];
if(newNode==null){
newNode=RDFTerm.fromBlankNode(newname);
bnodeLabels.Add(newname, newNode);
newBlankNodes.Add(oldname, newNode);
}
obj=newNode;
changed=true;
}
}
if(changed){
RDFTriple[] newTriple=new RDFTriple[]{triple,
new RDFTriple(subj,triple.getPredicate(),obj)
};
changedTriples.Add(newTriple);
}
}
foreach(var triple in changedTriples){
triples.Remove(triple[0]);
triples.Add(triple[1]);
}
}
public override sealed bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
if (obj == null)
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
RDFTriple other = (RDFTriple)obj;
if (_object == null)
{
if (other._object != null)
{
return(false);
}
}
else if (!_object.Equals(other._object))
{
return(false);
}
if (predicate == null)
{
if (other.predicate != null)
{
return(false);
}
}
else if (!predicate.Equals(other.predicate))
{
return(false);
}
if (subject == null)
{
if (other.subject != null)
{
return(false);
}
}
else if (!subject.Equals(other.subject))
{
return(false);
}
return(true);
}
/**
* A lax comparer of RDF triples which doesn't compare
* blank node labels
*
* @param a
* @param b
*
*/
private static bool laxEqual(RDFTriple a, RDFTriple b)
{
if (a == null)
{
return(b == null);
}
if (a.Equals(b))
{
return(true);
}
if (a.getSubject().getKind() != b.getSubject().getKind())
{
return(false);
}
if (a.getObject().getKind() != b.getObject().getKind())
{
return(false);
}
if (!a.getPredicate().Equals(b.getPredicate()))
{
return(false);
}
if (a.getSubject().getKind() != RDFTerm.BLANK)
{
if (!a.getSubject().Equals(b.getSubject()))
{
return(false);
}
}
if (a.getObject().getKind() != RDFTerm.BLANK)
{
if (!a.getObject().Equals(b.getObject()))
{
return(false);
}
}
return(true);
}
private RDFTriple readTriples()
{
int mark = input.setHardMark();
int ch = input.read();
#if DEBUG
if (!((ch >= 0)))
{
throw new InvalidOperationException("ch>=0");
}
#endif
input.setMarkPosition(mark);
RDFTerm subject = readObject(false);
if (!skipWhitespace())
{
throw new ParserException();
}
if (input.read() != '<')
{
throw new ParserException();
}
RDFTerm predicate = RDFTerm.fromIRI(readIriReference());
if (!skipWhitespace())
{
throw new ParserException();
}
RDFTerm obj = readObject(true);
skipWhitespace();
if (input.read() != '.')
{
throw new ParserException();
}
skipWhitespace();
RDFTriple ret = new RDFTriple(subject, predicate, obj);
endOfLine(input.read());
return(ret);
}
/*
* Replaces certain blank nodes with blank nodes whose
* names meet the N-Triples requirements
* @param triples A set of RDF triples
* @param bnodeLabels A mapping of blank node names
* already allocated. This method will modify this
* _object as needed to allocate new blank nodes.
*/
//
internal static void replaceBlankNodes(ISet <RDFTriple> triples,
IDictionary <string, RDFTerm> bnodeLabels)
{
if (bnodeLabels.Count == 0)
{
return;
}
IDictionary <string, RDFTerm> newBlankNodes = new PeterO.Support.LenientDictionary <string, RDFTerm>();
IList <RDFTriple[]> changedTriples = new List <RDFTriple[]>();
int[] nodeindex = new int[] { 0 };
foreach (var triple in triples)
{
bool changed = false;
RDFTerm subj = triple.getSubject();
if (subj.getKind() == RDFTerm.BLANK)
{
string oldname = subj.getValue();
string newname = suggestBlankNodeName(oldname, nodeindex, bnodeLabels);
if (!newname.Equals(oldname))
{
RDFTerm newNode = newBlankNodes[oldname];
if (newNode == null)
{
newNode = RDFTerm.fromBlankNode(newname);
bnodeLabels.Add(newname, newNode);
newBlankNodes.Add(oldname, newNode);
}
subj = newNode;
changed = true;
}
}
RDFTerm obj = triple.getObject();
if (obj.getKind() == RDFTerm.BLANK)
{
string oldname = obj.getValue();
string newname = suggestBlankNodeName(oldname, nodeindex, bnodeLabels);
if (!newname.Equals(oldname))
{
RDFTerm newNode = newBlankNodes[oldname];
if (newNode == null)
{
newNode = RDFTerm.fromBlankNode(newname);
bnodeLabels.Add(newname, newNode);
newBlankNodes.Add(oldname, newNode);
}
obj = newNode;
changed = true;
}
}
if (changed)
{
RDFTriple[] newTriple = new RDFTriple[] { triple,
new RDFTriple(subj, triple.getPredicate(), obj) };
changedTriples.Add(newTriple);
}
}
foreach (var triple in changedTriples)
{
triples.Remove(triple[0]);
triples.Add(triple[1]);
}
}
private RDFTriple readTriples()
{
int mark=input.setHardMark();
int ch=input.read();
#if DEBUG
if(!((ch>=0) ))throw new InvalidOperationException("ch>=0");
#endif
input.setMarkPosition(mark);
RDFTerm subject=readObject(false);
if(!skipWhitespace())throw new ParserException();
if(input.read()!='<')throw new ParserException();
RDFTerm predicate=RDFTerm.fromIRI(readIriReference());
if(!skipWhitespace())throw new ParserException();
RDFTerm obj=readObject(true);
skipWhitespace();
if(input.read()!='.')throw new ParserException();
skipWhitespace();
RDFTriple ret=new RDFTriple(subject,predicate,obj);
endOfLine(input.read());
return ret;
}
/**
* A lax comparer of RDF triples which doesn't compare
* blank node labels
*
* @param a
* @param b
*
*/
private static bool laxEqual(RDFTriple a, RDFTriple b)
{
if(a==null)return (b==null);
if(a.Equals(b))return true;
if(a.getSubject().getKind()!=b.getSubject().getKind())
return false;
if(a.getObject().getKind()!=b.getObject().getKind())
return false;
if(!a.getPredicate().Equals(b.getPredicate()))
return false;
if(a.getSubject().getKind()!=RDFTerm.BLANK){
if(!a.getSubject().Equals(b.getSubject()))
return false;
}
if(a.getObject().getKind()!=RDFTerm.BLANK){
if(!a.getObject().Equals(b.getObject()))
return false;
}
return true;
}
