[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Dotgnu-libs-commits] CVS: dotgnu.rdf DotGNU.Rdf.cwm.n3,NONE,1.1 DotGNU.
|
From: |
James Michael DuPont <address@hidden> |
|
Subject: |
[Dotgnu-libs-commits] CVS: dotgnu.rdf DotGNU.Rdf.cwm.n3,NONE,1.1 DotGNU.Rdf.cwm.rdf,NONE,1.1 DotGNU.Rdf.dll,NONE,1.1 DotGNU.Rdf.il,NONE,1.1 DotGNU.Rdf.n3,NONE,1.1 DotGNU.Rdf.n3_clean,NONE,1.1 DotGNU.Rdf.n3_pure,NONE,1.1 DotGNU.Rdf.n3t,NONE,1.1 DotGNU.Rdf.rdf,NONE,1.1 DotGNURDF.WIKI,NONE,1.1 Makefile,NONE,1.1 api-update1.txt,NONE,1.1 api.txt,NONE,1.1 apt-update1.n3,NONE,1.1 apt-update1.rdf,NONE,1.1 apt-update1.txt,NONE,1.1 begin.html,NONE,1.1 build-stamp,NONE,1.1 configure-stamp,NONE,1.1 cs.files,NONE,1.1 docvs.sh,NONE,1.1 dotgnu.rdf.texi,NONE,1.1 dotgnu.rdf.xml,NONE,1.1 gmon.out,NONE,1.1 index.html,NONE,1.1 meeting.txt,NONE,1.1 namespaces.html,NONE,1.1 otherpredicates.txt,NONE,1.1 predicates.txt,NONE,1.1 test.log,NONE,1.1 test.n3,NONE,1.1 test2n3.pl,NONE,1.1 DotGNU.Rdf.build,1.9,1.10 RdfParser.cs,1.5,1.6 RdfParser_N3.cs,1.1,1.2 RdfTriple.cs,1.2,1.3 RdfWorld.cs,1.1,1.2 |
|
Date: |
Thu, 19 Jun 2003 16:16:09 -0400 |
Update of /cvsroot/dotgnu-libs/dotgnu.rdf
In directory subversions:/tmp/cvs-serv23740
Modified Files:
DotGNU.Rdf.build RdfParser.cs RdfParser_N3.cs RdfTriple.cs
RdfWorld.cs
Added Files:
DotGNU.Rdf.cwm.n3 DotGNU.Rdf.cwm.rdf DotGNU.Rdf.dll
DotGNU.Rdf.il DotGNU.Rdf.n3 DotGNU.Rdf.n3_clean
DotGNU.Rdf.n3_pure DotGNU.Rdf.n3t DotGNU.Rdf.rdf
DotGNURDF.WIKI Makefile api-update1.txt api.txt apt-update1.n3
apt-update1.rdf apt-update1.txt begin.html build-stamp
configure-stamp cs.files docvs.sh dotgnu.rdf.texi
dotgnu.rdf.xml gmon.out index.html meeting.txt namespaces.html
otherpredicates.txt predicates.txt test.log test.n3 test2n3.pl
Log Message:
small
--- NEW FILE ---
#Processed by Id: cwm.py,v 1.129 2003/04/08 16:12:43 timbl Exp
# using base
file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3
# Notation3 generation by
# notation3.py,v 1.138 2003/04/25 19:12:46 sandro Exp
# Base was: file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3
@prefix : <http://www.w3.org/2000/01/rdf-schema#> .
<DotGNU> :subClassOf <Namespace> .
<DotGNU.Rdf> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU>;
:subClassOf <Namespace> .
<N3-Design-Issues> :subClassOf
<http://www.w3.org/DesignIssues/Notation3.html> .
<N3-Primer> :subClassOf <http://www.w3.org/2000/10/swap/Primer> .
<NonStandardStatements> <http://www.w3.org/2002/07/owl#comment> "Here
are non standard statement types. These are not needed in the standard, but can
be considered for the class design" .
<RDF.NTriples> :isDefinedBy <N3-Design-Issues>,
<N3-Primer> .
<RDF.XML> :isDefinedBy <RDF.XML-Syntax-Specification> .
<RDF.XML-Syntax-Specification> :subClassOf
<http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/> .
<RDFCollections> :subClassOf <Namespace> .
<RDFTypedLiterals> :subClassOf <Namespace>;
<http://www.w3.org/2002/07/owl#label>
<DotGNU.Rdf.Values.TypedLiterals> .
<RDFValues> :subClassOf <Namespace>;
<http://www.w3.org/2002/07/owl#label> <DotGNU.Rdf.Values> .
<RdfAlt> :subClassOf <RdfCollection>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF Alt
collection. Derived from RdfCollection." .
<RdfBag> :subClassOf <RdfCollection>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF Bag
collection. Derived from RdfCollection" .
<RdfCollection> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is the base RDF
collection. Derived from RdfNode. All collections are dervied from here." .
<RdfEdge> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<RDFValues>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is an edge in the
RdfGraph or RdfModel. It is a Node that connects two Triples/Statements" .
<RdfGraph> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "An RDF graph. This will be a
labelled digraph that is recursively traversable." .
<RdfIterator> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is a interator over a
storage" .
<RdfLiteral> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<RDFValues>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is a literal in RDF.
Derived from RdfNode" .
<RdfLiteralFloat> <http://www.w3.org/2002/07/owl#comment> "This is a
Floating point literal in RDF. Derived from RdfLiteral." .
<RdfLiteralInteger> <http://www.w3.org/2002/07/owl#comment> "This is a
integer literal in RDF. Derived from RdfLiteral." .
<RdfModel> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "Same as an RdfGraph. This is
mainly a naming issue and this class can be removed." .
<RdfN3Parser> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "The main RdfParse that will
parse RDF/XML documents. Subclass of RdfParser." .
<RdfN3Storage>
<http://introspector.sf.net/2003/03/dro#ImplementsInterface> <RDF.NTriples>;
<http://introspector.sf.net/2003/03/dro#SubNameSpace> <DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "An RDF Storage class that
will store the N3 Serialization of RDF. Subclass of RdfStorage" .
<RdfNode> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<RDFValues>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is a node in the
RdfGraph or RdfModel. It is the base class of all values" .
<RdfNodeRole> :subClassOf <RdfNodeRole>,
<class>,
<member>,
<role>;
<http://www.w3.org/2002/07/owl#comment> "This is the base class for
members nodes. A node may play a Role for a certain period of time" .
<RdfObject> <http://introspector.sf.net/2003/03/dro#ParameterPosition>
<3>;
:label "object";
:subClassOf <RdfNodeRole>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF Object. Used
in reification. Derived from RdfNodeRole." .
<RdfPair> :subClassOf <NonStandardStatement>,
<RdfStatement>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF Pair where the
subject, predicate are Nodes." .
<RdfParser> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "The main RdfParse that will
parse RDF documents" .
<RdfParserFactory> :subClassOf <Factory>,
<ImplementationClass>,
<class>;
<http://www.w3.org/2002/07/owl#comment> "Factory class that generates
and returns RdfParser objects" .
<RdfPredicate>
<http://introspector.sf.net/2003/03/dro#ParameterPosition> <2>;
:label "predicate";
:subClassOf <RdfNodeRole>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF predicate.
Used in reification. Derived from RdfNodeRole." .
<RdfQuad> :subClassOf <RdfStatement>;
<http://www.w3.org/2002/07/owl#comment> "This is a non standard RDF
Quad where the subject, predicate, and object and context are in non standard
N4 format" .
<RdfSeq> :subClassOf <RdfCollection>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDFSeq collection.
Derived from RdfCollection." .
<RdfSerializer> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This generates RDF documents
to Storages" .
<RdfStatement> :subClassOf <classs>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF statement.
Used in reification. Base class for future statement types." .
<RdfStatements> :subClassOf <Namespace> .
<RdfStorage> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "An RDF Storage class that
will store the XML serialzation of RDF",
"An RDF Storage class that will store the XML serialzation, N3
Serialization or other formatted RDF document. It also allows an abstract
access to any RDF data that is stored in Memory.",
"The word storage better reflects the fact that it could be any
format, including a distributed database.";
<http://www.w3.org/2002/07/owl#sameClassAs> <Redland.RDFStorage> .
<RdfSubject> <http://introspector.sf.net/2003/03/dro#ParameterPosition>
<1>;
:label "subject";
:subClassOf <RdfNodeRole>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF subject. Used
in reification. Derived from RdfNodeRole." .
<RdfTriple> :subClassOf <RdfStatement>;
<http://www.w3.org/2002/07/owl#comment> "This is an RDF triple where
the subject, predicate and object are in N3 format." .
<RdfUri> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "This is a URI. Derived from
System.Uri" .
<RdfXMLStorage>
<http://introspector.sf.net/2003/03/dro#ImplementsInterface> <RDF.XML> .
<RdfXmlParser> :subClassOf <class>;
<http://www.w3.org/2002/07/owl#comment> "The main RdfParse that will
parse RDF/XML documents. Subclass of RdfParser." .
<RdfXmlStorage> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<DotGNU.Rdf>;
:subClassOf <class>;
<http://www.w3.org/2002/07/owl#subClassOf> <RdfStorage> .
#ENDS
--- NEW FILE ---
<!-- Processed by Id: cwm.py,v 1.129 2003/04/08 16:12:43 timbl Exp -->
<!-- using base
file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3-->
<rdf:RDF xmlns="http://www.w3.org/2000/01/rdf-schema#";
xmlns:log="http://www.w3.org/2000/10/swap/log#";
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#";>
<rdf:Description rdf:about="DotGNU">
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="DotGNU.Rdf">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU"/>
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="N3-Design-Issues">
<subClassOf
rdf:resource="http://www.w3.org/DesignIssues/Notation3.html"/>
</rdf:Description>
<rdf:Description rdf:about="N3-Primer">
<subClassOf rdf:resource="http://www.w3.org/2000/10/swap/Primer"/>
</rdf:Description>
<rdf:Description rdf:about="NonStandardStatements">
<comment xmlns="http://www.w3.org/2002/07/owl#";>Here are non standard
statement types. These are not needed in the standard, but can be considered
for the class design</comment>
</rdf:Description>
<rdf:Description rdf:about="RDF.NTriples">
<isDefinedBy rdf:resource="N3-Design-Issues"/>
<isDefinedBy rdf:resource="N3-Primer"/>
</rdf:Description>
<rdf:Description rdf:about="RDF.XML">
<isDefinedBy rdf:resource="RDF.XML-Syntax-Specification"/>
</rdf:Description>
<rdf:Description rdf:about="RDF.XML-Syntax-Specification">
<subClassOf
rdf:resource="http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/"/>
</rdf:Description>
<rdf:Description rdf:about="RDFCollections">
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="RDFTypedLiterals">
<subClassOf rdf:resource="Namespace"/>
<label xmlns="http://www.w3.org/2002/07/owl#";
rdf:resource="DotGNU.Rdf.Values.TypedLiterals"/>
</rdf:Description>
<rdf:Description rdf:about="RDFValues">
<subClassOf rdf:resource="Namespace"/>
<label xmlns="http://www.w3.org/2002/07/owl#";
rdf:resource="DotGNU.Rdf.Values"/>
</rdf:Description>
<rdf:Description rdf:about="RdfAlt">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF Alt
collection. Derived from RdfCollection.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfBag">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF Bag
collection. Derived from RdfCollection</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfCollection">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is the base RDF
collection. Derived from RdfNode. All collections are dervied from
here.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfEdge">
<PartOfNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an edge in the
RdfGraph or RdfModel. It is a Node that connects two
Triples/Statements</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfGraph">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>An RDF graph. This will
be a labelled digraph that is recursively traversable.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfIterator">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a interator
over a storage</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteral">
<PartOfNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a literal in
RDF. Derived from RdfNode</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteralFloat">
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a Floating
point literal in RDF. Derived from RdfLiteral.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteralInteger">
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a integer
literal in RDF. Derived from RdfLiteral.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfModel">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>Same as an RdfGraph.
This is mainly a naming issue and this class can be removed.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfN3Parser">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>The main RdfParse that
will parse RDF/XML documents. Subclass of RdfParser.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfN3Storage">
<ImplementsInterface xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="RDF.NTriples"/>
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>An RDF Storage class
that will store the N3 Serialization of RDF. Subclass of RdfStorage</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfNode">
<PartOfNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a node in the
RdfGraph or RdfModel. It is the base class of all values</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfNodeRole">
<subClassOf rdf:resource="RdfNodeRole"/>
<subClassOf rdf:resource="class"/>
<subClassOf rdf:resource="member"/>
<subClassOf rdf:resource="role"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is the base class
for members nodes. A node may play a Role for a certain period of time</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfObject">
<ParameterPosition xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="3"/>
<label>object</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF Object.
Used in reification. Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfPair">
<subClassOf rdf:resource="NonStandardStatement"/>
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF Pair
where the subject, predicate are Nodes.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfParser">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>The main RdfParse that
will parse RDF documents</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfParserFactory">
<subClassOf rdf:resource="Factory"/>
<subClassOf rdf:resource="ImplementationClass"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>Factory class that
generates and returns RdfParser objects</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfPredicate">
<ParameterPosition xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="2"/>
<label>predicate</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF
predicate. Used in reification. Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfQuad">
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a non standard
RDF Quad where the subject, predicate, and object and context are in non
standard N4 format</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfSeq">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDFSeq
collection. Derived from RdfCollection.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfSerializer">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This generates RDF
documents to Storages</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfStatement">
<subClassOf rdf:resource="classs"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF
statement. Used in reification. Base class for future statement
types.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfStatements">
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="RdfStorage">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>An RDF Storage class
that will store the XML serialzation of RDF</comment>
<comment xmlns="http://www.w3.org/2002/07/owl#";>An RDF Storage class
that will store the XML serialzation, N3 Serialization or other formatted RDF
document. It also allows an abstract access to any RDF data that is stored in
Memory.</comment>
<comment xmlns="http://www.w3.org/2002/07/owl#";>The word storage better
reflects the fact that it could be any format, including a distributed
database.</comment>
<sameClassAs xmlns="http://www.w3.org/2002/07/owl#";
rdf:resource="Redland.RDFStorage"/>
</rdf:Description>
<rdf:Description rdf:about="RdfSubject">
<ParameterPosition xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="1"/>
<label>subject</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF subject.
Used in reification. Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfTriple">
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is an RDF triple
where the subject, predicate and object are in N3 format.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfUri">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>This is a URI. Derived
from System.Uri</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfXMLStorage">
<ImplementsInterface xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="RDF.XML"/>
</rdf:Description>
<rdf:Description rdf:about="RdfXmlParser">
<subClassOf rdf:resource="class"/>
<comment xmlns="http://www.w3.org/2002/07/owl#";>The main RdfParse that
will parse RDF/XML documents. Subclass of RdfParser.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfXmlStorage">
<SubNameSpace xmlns="http://introspector.sf.net/2003/03/dro#";
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<subClassOf xmlns="http://www.w3.org/2002/07/owl#";
rdf:resource="RdfStorage"/>
</rdf:Description>
</rdf:RDF>
--- NEW FILE ---
MZ
$
z*
{
*
r7
*®(
r7
}
{
+
o
o
&o
-ë
Þ
Þ
{
+ o
[...2097 lines suppressed...]
--- NEW FILE ---
// Input: DotGNU.Rdf.dll
// Image type: DLL
// Native code present: No
// 32-bit only: No
// Length of IL data: 87552
.assembly extern 'mscorlib'
{
.ver 0:0:0:0
}
.assembly extern 'System'
{
.ver 0:0:0:0
}
.assembly extern 'System.Xml'
{
.ver 0:0:0:0
}
.assembly 'DotGNU.Rdf'
[...13856 lines suppressed...]
ldc.i4.0
ret
}
.method public virtual hidebysig instance bool 'GetFeature'(class
'DotGNU.Rdf'.'RdfUri' 'name') cil managed
{
// Start of method header: afb4
.maxstack 8
?Lafb5:
ldc.i4.0
ret
}
.method public virtual hidebysig instance void 'SerializeModel'(class
'System'.'String' 'filename', class 'DotGNU.Rdf'.'RdfModel' 'model', class
'DotGNU.Rdf'.'RdfUri' 'baseuri') cil managed
{
// Start of method header: afb8
.maxstack 8
?Lafb9:
ret
}
}
}
***** Error reading new file: [Errno 2] No such file or directory:
'DotGNU.Rdf.n3'
--- NEW FILE ---
<file:DotGNU.Rdf> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU> .
<file:DotGNU.Rdf> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:DotGNU> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:N3-Design-Issues> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<http://www.w3.org/DesignIssues/Notation3.html> .
<file:N3-Primer> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<http://www.w3.org/2000/10/swap/Primer> .
<file:NonStandardStatements> <http://www.w3.org/2002/07/owl#comment> "Here are
non standard statement types. These are not needed in the standard, but can be
considered for the class design" .
<file:RDF.NTriples> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy>
<file:N3-Design-Issues> .
<file:RDF.NTriples> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy>
<file:N3-Primer> .
<file:RDF.XML-Syntax-Specification>
<http://www.w3.org/2000/01/rdf-schema#subClassOf>
<http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/> .
<file:RDF.XML> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy>
<file:RDF.XML-Syntax-Specification> .
<file:RDFCollections> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:RDFTypedLiterals> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:RDFTypedLiterals> <http://www.w3.org/2002/07/owl#label>
<file:DotGNU.Rdf.Values.TypedLiterals> .
<file:RDFValues> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:RDFValues> <http://www.w3.org/2002/07/owl#label> <file:DotGNU.Rdf.Values>
.
<file:RdfAlt> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfCollection> .
<file:RdfAlt> <http://www.w3.org/2002/07/owl#comment> "This is an RDF Alt
collection. Derived from RdfCollection." .
<file:RdfBag> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfCollection> .
<file:RdfBag> <http://www.w3.org/2002/07/owl#comment> "This is an RDF Bag
collection. Derived from RdfCollection" .
<file:RdfCollection> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfCollection> <http://www.w3.org/2002/07/owl#comment> "This is the base
RDF collection. Derived from RdfNode. All collections are dervied from here." .
<file:RdfEdge> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<file:RDFValues> .
<file:RdfEdge> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<file:RDFValues> .
<file:RdfEdge> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class> .
<file:RdfEdge> <http://www.w3.org/2002/07/owl#comment> "This is an edge in the
RdfGraph or RdfModel. It is a Node that connects two Triples/Statements" .
<file:RdfGraph> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class> .
<file:RdfGraph> <http://www.w3.org/2002/07/owl#comment> "An RDF graph. This
will be a labelled digraph that is recursively traversable." .
<file:RdfIterator> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfIterator> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfIterator> <http://www.w3.org/2002/07/owl#comment> "This is a interator
over a storage" .
<file:RdfLiteral> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<file:RDFValues> .
<file:RdfLiteral> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfLiteral> <http://www.w3.org/2002/07/owl#comment> "This is a literal in
RDF. Derived from RdfNode" .
<file:RdfLiteralFloat> <http://www.w3.org/2002/07/owl#comment> "This is a
Floating point literal in RDF. Derived from RdfLiteral." .
<file:RdfLiteralInteger> <http://www.w3.org/2002/07/owl#comment> "This is a
integer literal in RDF. Derived from RdfLiteral." .
<file:RdfModel> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class> .
<file:RdfModel> <http://www.w3.org/2002/07/owl#comment> "Same as an RdfGraph.
This is mainly a naming issue and this class can be removed." .
<file:RdfN3Parser> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfN3Parser> <http://www.w3.org/2002/07/owl#comment> "The main RdfParse
that will parse RDF/XML documents. Subclass of RdfParser." .
<file:RdfN3Storage>
<http://introspector.sf.net/2003/03/dro#ImplementsInterface>
<file:RDF.NTriples> .
<file:RdfN3Storage> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfN3Storage> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfN3Storage> <http://www.w3.org/2002/07/owl#comment> "An RDF Storage
class that will store the N3 Serialization of RDF. Subclass of RdfStorage" .
<file:RdfNode> <http://introspector.sf.net/2003/03/dro#PartOfNameSpace>
<file:RDFValues> .
<file:RdfNode> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class> .
<file:RdfNode> <http://www.w3.org/2002/07/owl#comment> "This is a node in the
RdfGraph or RdfModel. It is the base class of all values" .
<file:RdfNodeRole> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfNodeRole> .
<file:RdfNodeRole> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfNodeRole> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:member> .
<file:RdfNodeRole> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:role> .
<file:RdfNodeRole> <http://www.w3.org/2002/07/owl#comment> "This is the base
class for members nodes. A node may play a Role for a certain period of time" .
<file:RdfObject> <http://introspector.sf.net/2003/03/dro#ParameterPosition>
<file:3> .
<file:RdfObject> <http://www.w3.org/2000/01/rdf-schema#label> "object" .
<file:RdfObject> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfNodeRole> .
<file:RdfObject> <http://www.w3.org/2002/07/owl#comment> "This is an RDF
Object. Used in reification. Derived from RdfNodeRole." .
<file:RdfPair> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:NonStandardStatement> .
<file:RdfPair> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:NonStandardStatement> .
<file:RdfPair> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfStatement> .
<file:RdfPair> <http://www.w3.org/2002/07/owl#comment> "This is an RDF Pair
where the subject, predicate are Nodes." .
<file:RdfParser> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfParser> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class>
.
<file:RdfParser> <http://www.w3.org/2002/07/owl#comment> "The main RdfParse
that will parse RDF documents" .
<file:RdfParserFactory> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Factory> .
<file:RdfParserFactory> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:ImplementationClass> .
<file:RdfParserFactory> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfParserFactory> <http://www.w3.org/2002/07/owl#comment> "Factory class
that generates and returns RdfParser objects" .
<file:RdfPredicate> <http://introspector.sf.net/2003/03/dro#ParameterPosition>
<file:2> .
<file:RdfPredicate> <http://www.w3.org/2000/01/rdf-schema#label> "predicate" .
<file:RdfPredicate> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfNodeRole> .
<file:RdfPredicate> <http://www.w3.org/2002/07/owl#comment> "This is an RDF
predicate. Used in reification. Derived from RdfNodeRole." .
<file:RdfQuad> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfStatement> .
<file:RdfQuad> <http://www.w3.org/2002/07/owl#comment> "This is a non standard
RDF Quad where the subject, predicate, and object and context are in non
standard N4 format" .
<file:RdfSeq> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfCollection> .
<file:RdfSeq> <http://www.w3.org/2002/07/owl#comment> "This is an RDFSeq
collection. Derived from RdfCollection." .
<file:RdfSerializer> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfSerializer> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfSerializer> <http://www.w3.org/2002/07/owl#comment> "This generates
RDF documents to Storages" .
<file:RdfStatement> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:classs> .
<file:RdfStatement> <http://www.w3.org/2002/07/owl#comment> "This is an RDF
statement. Used in reification. Base class for future statement types." .
<file:RdfStatements> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:Namespace> .
<file:RdfStorage> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfStorage> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfStorage> <http://www.w3.org/2002/07/owl#comment> "An RDF Storage class
that will store the XML serialzation of RDF" .
<file:RdfStorage> <http://www.w3.org/2002/07/owl#comment> "An RDF Storage class
that will store the XML serialzation, N3 Serialization or other formatted RDF
document. It also allows an abstract access to any RDF data that is stored in
Memory." .
<file:RdfStorage> <http://www.w3.org/2002/07/owl#comment> "The word storage
better reflects the fact that it could be any format, including a distributed
database." .
<file:RdfStorage> <http://www.w3.org/2002/07/owl#sameClassAs>
<file:Redland.RDFStorage> .
<file:RdfSubject> <http://introspector.sf.net/2003/03/dro#ParameterPosition>
<file:1> .
<file:RdfSubject> <http://www.w3.org/2000/01/rdf-schema#label> "subject" .
<file:RdfSubject> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfNodeRole> .
<file:RdfSubject> <http://www.w3.org/2002/07/owl#comment> "This is an RDF
subject. Used in reification. Derived from RdfNodeRole." .
<file:RdfTriple> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:RdfStatement> .
<file:RdfTriple> <http://www.w3.org/2002/07/owl#comment> "This is an RDF triple
where the subject, predicate and object are in N3 format." .
<file:RdfUri> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <file:class> .
<file:RdfUri> <http://www.w3.org/2002/07/owl#comment> "This is a URI. Derived
from System.Uri" .
<file:RdfXMLStorage>
<http://introspector.sf.net/2003/03/dro#ImplementsInterface> <file:RDF.XML> .
<file:RdfXmlParser> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfXmlParser> <http://www.w3.org/2002/07/owl#comment> "The main RdfParse
that will parse RDF/XML documents. Subclass of RdfParser." .
<file:RdfXmlStorage> <http://introspector.sf.net/2003/03/dro#SubNameSpace>
<file:DotGNU.Rdf> .
<file:RdfXmlStorage> <http://www.w3.org/2000/01/rdf-schema#subClassOf>
<file:class> .
<file:RdfXmlStorage> <http://www.w3.org/2002/07/owl#subClassOf>
<file:RdfStorage> .
--- NEW FILE ---
#Processed by Id: cwm.py,v 1.126 2003/02/14 17:48:08 sandro Exp
# using base
file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3
# Notation3 generation by
# notation3.py,v 1.133 2003/02/02 16:09:09 timbl Exp
# Base was: file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix dro: <http://introspector.sf.net/2003/03/dro#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
<DotGNU> <rdfs:subClassOf> <Namespace> .
<DotGNU.Rdf> <dro:SubNameSpace> <DotGNU>;
rdfs:subClassOf <Namespace> .
<N3-Design-Issues> rdfs:subClassOf
<http://www.w3.org/DesignIssues/Notation3.html> .
<N3-Primer> rdfs:subClassOf <http://www.w3.org/2000/10/swap/Primer> .
<NonStandardStatements> <owl:comment> "Here are non standard statement
types. These are not needed in the standard, but can be considered for the
class design" .
<RDF.NTriples> rdfs:isDefinedBy <N3-Design-Issues>,
<N3-Primer> .
<RDF.XML> rdfs:isDefinedBy <RDF.XML-Syntax-Specification> .
<RDF.XML-Syntax-Specification> rdfs:subClassOf
<http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/> .
<RDFCollections> rdfs:subClassOf <Namespace> .
<RDFTypedLiterals> rdfs:subClassOf <Namespace>;
<owl:label> <DotGNU.Rdf.Values.TypedLiterals> .
<RDFValues> rdfs:subClassOf <Namespace>;
<owl:label> <DotGNU.Rdf.Values> .
<RdfAlt> rdfs:subClassOf <RdfCollection>;
<owl:comment> "This is an RDF Alt collection. Derived from
RdfCollection." .
<RdfBag> rdfs:subClassOf <RdfCollection>;
<owl:comment> "This is an RDF Bag collection. Derived from
RdfCollection" .
<RdfCollection> rdfs:subClassOf <class>;
<owl:comment> "This is the base RDF collection. Derived from RdfNode.
All collections are dervied from here." .
<RdfEdge> <dro:PartOfNameSpace> <RDFValues>;
rdfs:subClassOf <class>;
<owl:comment> "This is an edge in the RdfGraph or RdfModel. It is a
Node that connects two Triples/Statements" .
<RdfGraph> rdfs:subClassOf <class>;
<owl:comment> "An RDF graph. This will be a labelled digraph that is
recursively traversable." .
<RdfIterator> <dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:comment> "This is a interator over a storage" .
<RdfLiteral> <dro:PartOfNameSpace> <RDFValues>;
rdfs:subClassOf <class>;
<owl:comment> "This is a literal in RDF. Derived from RdfNode" .
<RdfLiteralFloat> <owl:comment> "This is a Floating point literal in
RDF. Derived from RdfLiteral." .
<RdfLiteralInteger> <owl:comment> "This is a integer literal in RDF.
Derived from RdfLiteral." .
<RdfModel> rdfs:subClassOf <class>;
<owl:comment> "Same as an RdfGraph. This is mainly a naming issue and
this class can be removed." .
<RdfN3Parser> rdfs:subClassOf <class>;
<owl:comment> "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser." .
<RdfN3Storage> <dro:ImplementsInterface> <RDF.NTriples>;
<dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:comment> "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage" .
<RdfNode> <dro:PartOfNameSpace> <RDFValues>;
rdfs:subClassOf <class>;
<owl:comment> "This is a node in the RdfGraph or RdfModel. It is the
base class of all values" .
<RdfNodeRole> rdfs:subClassOf <RdfNodeRole>,
<class>,
<member>,
<role>;
<owl:comment> "This is the base class for members nodes. A node may
play a Role for a certain period of time" .
<RdfObject> <dro:ParameterPosition> <3>;
rdfs:label "object";
rdfs:subClassOf <RdfNodeRole>;
<owl:comment> "This is an RDF Object. Used in reification. Derived
from RdfNodeRole." .
<RdfPair> rdfs:subClassOf <NonStandardStatement>, <RdfStatement>;
<owl:comment> "This is an RDF Pair where the subject, predicate are
Nodes." .
<RdfParser> <dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:comment> "The main RdfParse that will parse RDF documents" .
<RdfParserFactory> rdfs:subClassOf <Factory>,
<ImplementationClass>,
<class>;
<owl:comment> "Factory class that generates and returns RdfParser
objects" .
<RdfPredicate> <dro:ParameterPosition> <2>;
rdfs:label "predicate";
rdfs:subClassOf <RdfNodeRole>;
<owl:comment> "This is an RDF predicate. Used in reification. Derived
from RdfNodeRole." .
<RdfQuad> rdfs:subClassOf <RdfStatement>;
<owl:comment> "This is a non standard RDF Quad where the subject,
predicate, and object and context are in non standard N4 format" .
<RdfSeq> rdfs:subClassOf <RdfCollection>;
<owl:comment> "This is an RDFSeq collection. Derived from
RdfCollection." .
<RdfSerializer> <dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:comment> "This generates RDF documents to Storages" .
<RdfStatement> rdfs:subClassOf <classs>;
<owl:comment> "This is an RDF statement. Used in reification. Base
class for future statement types." .
<RdfStatements> rdfs:subClassOf <Namespace> .
<RdfStorage> <dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:comment> "An RDF Storage class that will store the XML
serialzation of RDF",
"An RDF Storage class that will store the XML serialzation, N3
Serialization or other formatted RDF document. It also allows an abstract
access to any RDF data that is stored in Memory.",
"The word storage better reflects the fact that it could be any
format, including a distributed database.";
<owl:sameClassAs> <Redland.RDFStorage> .
<RdfSubject> <dro:ParameterPosition> <1>;
rdfs:label "subject";
rdfs:subClassOf <RdfNodeRole>;
<owl:comment> "This is an RDF subject. Used in reification. Derived
from RdfNodeRole." .
<RdfTriple> rdfs:subClassOf <RdfStatement>;
<owl:comment> "This is an RDF triple where the subject, predicate and
object are in N3 format." .
<RdfUri> rdfs:subClassOf <class>;
<owl:comment> "This is a URI. Derived from System.Uri" .
<RdfXMLStorage> <dro:ImplementsInterface> <RDF.XML> .
<RdfXmlParser> rdfs:subClassOf <class>;
<owl:comment> "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser." .
<RdfXmlStorage> <dro:SubNameSpace> <DotGNU.Rdf>;
rdfs:subClassOf <class>;
<owl:subClassOf> <RdfStorage> .
#ENDS
--- NEW FILE ---
DotGNU is-a Namespace
DotGNU.Rdf is-a Namespace
DotGNU.Rdf is-part-of DotGNU
N3-Design-Issues is http://www.w3.org/DesignIssues/Notation3.html
N3-Primer is http://www.w3.org/2000/10/swap/Primer
NonStandardStatements description "Here are non standard statement types. These
are not needed in the standard, but can be considered for the class design"
RDF.NTriples is-related-to N3-Design-Issues
RDF.NTriples is-related-to N3-Primer
RDF.XML is-related-to RDF.XML-Syntax-Specification
RDF.XML-Syntax-Specification is
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
RDFCollections is-a Namespace
RDFTypedLiterals is-a Namespace
RDFTypedLiterals is-named DotGNU.Rdf.Values.TypedLiterals
RDFValues is-a Namespace
RDFValues is-named DotGNU.Rdf.Values
RdfAlt description "This is an RDF Alt collection. Derived from RdfCollection."
RdfAlt is-a RdfCollection
RdfBag description "This is an RDF Bag collection. Derived from RdfCollection"
RdfBag is-a RdfCollection
RdfCollection description "This is the base RDF collection. Derived from
RdfNode. All collections are dervied from here."
RdfCollection is-a class
RdfEdge description "This is an edge in the RdfGraph or RdfModel. It is a Node
that connects two Triples/Statements"
RdfEdge is-a class
RdfEdge part-of RDFValues
RdfEdge part-of RDFValues
RdfGraph description "An RDF graph. This will be a labelled digraph that is
recursively traversable."
RdfGraph is-a class
RdfIterator description "This is a interator over a storage"
RdfIterator is-a class
RdfIterator is-part-of DotGNU.Rdf
RdfLiteral description "This is a literal in RDF. Derived from RdfNode"
RdfLiteral is-a class
RdfLiteral part-of RDFValues
RdfLiteralFloat description "This is a Floating point literal in RDF. Derived
from RdfLiteral."
RdfLiteralInteger description "This is a integer literal in RDF. Derived from
RdfLiteral."
RdfModel description "Same as an RdfGraph. This is mainly a naming issue and
this class can be removed."
RdfModel is-a class
RdfN3Parser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfN3Parser is-a class
RdfN3Storage description "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage"
RdfN3Storage implements RDF.NTriples
RdfN3Storage is-a class
RdfN3Storage is-part-of DotGNU.Rdf
RdfNode description "This is a node in the RdfGraph or RdfModel. It is the base
class of all values".
RdfNode is-a class
RdfNode part-of RDFValues
RdfNodeRole description "This is the base class for members nodes. A node may
play a Role for a certain period of time"
RdfNodeRole is-a RdfNodeRole
RdfNodeRole is-a class
RdfNodeRole is-a member
RdfNodeRole is-a role
RdfObject description "This is an RDF Object. Used in reification. Derived from
RdfNodeRole."
RdfObject is-a RdfNodeRole
RdfObject member-name "object"
RdfObject member-position 3
RdfPair description "This is an RDF Pair where the subject, predicate are
Nodes."
RdfPair is-a NonStandardStatement
RdfPair is-a NonStandardStatement
RdfPair is-a RdfStatement
RdfParser description "The main RdfParse that will parse RDF documents"
RdfParser is-a class
RdfParser is-part-of DotGNU.Rdf
RdfParserFactory description "Factory class that generates and returns
RdfParser objects"
RdfParserFactory is-a Factory
RdfParserFactory is-a ImplementationClass
RdfParserFactory is-a class
RdfPredicate description "This is an RDF predicate. Used in reification.
Derived from RdfNodeRole."
RdfPredicate is-a RdfNodeRole
RdfPredicate member-name "predicate"
RdfPredicate member-position 2
RdfQuad description "This is a non standard RDF Quad where the subject,
predicate, and object and context are in non standard N4 format"
RdfQuad is-a RdfStatement
RdfSeq description "This is an RDFSeq collection. Derived from RdfCollection."
RdfSeq is-a RdfCollection
RdfSerializer description "This generates RDF documents to Storages"
RdfSerializer is-a class
RdfSerializer is-part-of DotGNU.Rdf
RdfStatement description "This is an RDF statement. Used in reification. Base
class for future statement types."
RdfStatement is-a classs
RdfStatements is-a Namespace
RdfStorage analog Redland.RDFStorage
RdfStorage description "An RDF Storage class that will store the XML
serialzation of RDF".
RdfStorage description "An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory."
RdfStorage is-a class
RdfStorage is-part-of DotGNU.Rdf
RdfStorage meaning "The word storage better reflects the fact that it could be
any format, including a distributed database."
RdfSubject description "This is an RDF subject. Used in reification. Derived
from RdfNodeRole."
RdfSubject is-a RdfNodeRole
RdfSubject member-name "subject"
RdfSubject member-position 1
RdfTriple description "This is an RDF triple where the subject, predicate and
object are in N3 format."
RdfTriple is-a RdfStatement
RdfUri description "This is a URI. Derived from System.Uri"
RdfUri is-a class
RdfXMLStorage implements RDF.XML
RdfXmlParser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfXmlParser is-a class
RdfXmlStorage Subclass-of RdfStorage
RdfXmlStorage is-a class
RdfXmlStorage is-part-of DotGNU.Rdf
--- NEW FILE ---
<!-- Processed by Id: cwm.py,v 1.126 2003/02/14 17:48:08 sandro Exp -->
<!-- using base
file:/mnt/hda4/pnet/dotgnulibs/dotgnu.rdf-0.2/DotGNU.Rdf.n3_pure-->
<rdf:RDF xmlns="http://www.w3.org/2000/01/rdf-schema#";
xmlns:dro="http://introspector.sf.net/2003/03/dro#";
xmlns:log="http://www.w3.org/2000/10/swap/log#";
xmlns:owl="http://www.w3.org/2002/07/owl#";
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#";
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#";>
<rdf:Description rdf:about="DotGNU">
<subClassOf xmlns="rdfs:"
rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="DotGNU.Rdf">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU"/>
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="N3-Design-Issues">
<subClassOf
rdf:resource="http://www.w3.org/DesignIssues/Notation3.html"/>
</rdf:Description>
<rdf:Description rdf:about="N3-Primer">
<subClassOf rdf:resource="http://www.w3.org/2000/10/swap/Primer"/>
</rdf:Description>
<rdf:Description rdf:about="NonStandardStatements">
<comment xmlns="owl:">Here are non standard statement types. These are
not needed in the standard, but can be considered for the class design</comment>
</rdf:Description>
<rdf:Description rdf:about="RDF.NTriples">
<isDefinedBy rdf:resource="N3-Design-Issues"/>
<isDefinedBy rdf:resource="N3-Primer"/>
</rdf:Description>
<rdf:Description rdf:about="RDF.XML">
<isDefinedBy rdf:resource="RDF.XML-Syntax-Specification"/>
</rdf:Description>
<rdf:Description rdf:about="RDF.XML-Syntax-Specification">
<subClassOf
rdf:resource="http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/"/>
</rdf:Description>
<rdf:Description rdf:about="RDFCollections">
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="RDFTypedLiterals">
<subClassOf rdf:resource="Namespace"/>
<label xmlns="owl:"
rdf:resource="DotGNU.Rdf.Values.TypedLiterals"/>
</rdf:Description>
<rdf:Description rdf:about="RDFValues">
<subClassOf rdf:resource="Namespace"/>
<label xmlns="owl:"
rdf:resource="DotGNU.Rdf.Values"/>
</rdf:Description>
<rdf:Description rdf:about="RdfAlt">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="owl:">This is an RDF Alt collection. Derived from
RdfCollection.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfBag">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="owl:">This is an RDF Bag collection. Derived from
RdfCollection</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfCollection">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is the base RDF collection. Derived from
RdfNode. All collections are dervied from here.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfEdge">
<PartOfNameSpace xmlns="dro:"
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is an edge in the RdfGraph or RdfModel. It
is a Node that connects two Triples/Statements</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfGraph">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">An RDF graph. This will be a labelled digraph
that is recursively traversable.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfIterator">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is a interator over a storage</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteral">
<PartOfNameSpace xmlns="dro:"
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is a literal in RDF. Derived from
RdfNode</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteralFloat">
<comment xmlns="owl:">This is a Floating point literal in RDF. Derived
from RdfLiteral.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfLiteralInteger">
<comment xmlns="owl:">This is a integer literal in RDF. Derived from
RdfLiteral.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfModel">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">Same as an RdfGraph. This is mainly a naming
issue and this class can be removed.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfN3Parser">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">The main RdfParse that will parse RDF/XML
documents. Subclass of RdfParser.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfN3Storage">
<ImplementsInterface xmlns="dro:"
rdf:resource="RDF.NTriples"/>
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfNode">
<PartOfNameSpace xmlns="dro:"
rdf:resource="RDFValues"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is a node in the RdfGraph or RdfModel. It is
the base class of all values</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfNodeRole">
<subClassOf rdf:resource="RdfNodeRole"/>
<subClassOf rdf:resource="class"/>
<subClassOf rdf:resource="member"/>
<subClassOf rdf:resource="role"/>
<comment xmlns="owl:">This is the base class for members nodes. A node
may play a Role for a certain period of time</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfObject">
<ParameterPosition xmlns="dro:"
rdf:resource="3"/>
<label>object</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="owl:">This is an RDF Object. Used in reification.
Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfPair">
<subClassOf rdf:resource="NonStandardStatement"/>
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="owl:">This is an RDF Pair where the subject, predicate
are Nodes.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfParser">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">The main RdfParse that will parse RDF
documents</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfParserFactory">
<subClassOf rdf:resource="Factory"/>
<subClassOf rdf:resource="ImplementationClass"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">Factory class that generates and returns
RdfParser objects</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfPredicate">
<ParameterPosition xmlns="dro:"
rdf:resource="2"/>
<label>predicate</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="owl:">This is an RDF predicate. Used in reification.
Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfQuad">
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="owl:">This is a non standard RDF Quad where the
subject, predicate, and object and context are in non standard N4
format</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfSeq">
<subClassOf rdf:resource="RdfCollection"/>
<comment xmlns="owl:">This is an RDFSeq collection. Derived from
RdfCollection.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfSerializer">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This generates RDF documents to Storages</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfStatement">
<subClassOf rdf:resource="classs"/>
<comment xmlns="owl:">This is an RDF statement. Used in reification.
Base class for future statement types.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfStatements">
<subClassOf rdf:resource="Namespace"/>
</rdf:Description>
<rdf:Description rdf:about="RdfStorage">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">An RDF Storage class that will store the XML
serialzation of RDF</comment>
<comment xmlns="owl:">An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory.</comment>
<comment xmlns="owl:">The word storage better reflects the fact that it
could be any format, including a distributed database.</comment>
<sameClassAs xmlns="owl:"
rdf:resource="Redland.RDFStorage"/>
</rdf:Description>
<rdf:Description rdf:about="RdfSubject">
<ParameterPosition xmlns="dro:"
rdf:resource="1"/>
<label>subject</label>
<subClassOf rdf:resource="RdfNodeRole"/>
<comment xmlns="owl:">This is an RDF subject. Used in reification.
Derived from RdfNodeRole.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfTriple">
<subClassOf rdf:resource="RdfStatement"/>
<comment xmlns="owl:">This is an RDF triple where the subject,
predicate and object are in N3 format.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfUri">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">This is a URI. Derived from System.Uri</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfXMLStorage">
<ImplementsInterface xmlns="dro:"
rdf:resource="RDF.XML"/>
</rdf:Description>
<rdf:Description rdf:about="RdfXmlParser">
<subClassOf rdf:resource="class"/>
<comment xmlns="owl:">The main RdfParse that will parse RDF/XML
documents. Subclass of RdfParser.</comment>
</rdf:Description>
<rdf:Description rdf:about="RdfXmlStorage">
<SubNameSpace xmlns="dro:"
rdf:resource="DotGNU.Rdf"/>
<subClassOf rdf:resource="class"/>
<subClassOf xmlns="owl:"
rdf:resource="RdfStorage"/>
</rdf:Description>
</rdf:RDF>
--- NEW FILE ---
#pragma section-numbers off
== Creating Rdf Api ==
Disclaimer : This is a TaskProposal from ["DotGNUPeople/MikeDuPont"]
this is not an OfficalDotGnuProject.
== Concepts ==
["DotGNU.Rdf.Model"]
["DotGNU.Rdf.Model"]
=== Mails ===
[http://dotgnu.info/mailman/htdig/developers/2003-February/009815.html MAIL
Call for a DotGNU/W3C RDF API ....]
[http://dotgnu.info/mailman/htdig/developers/2003-February/009859.html from
Gopal : "You're getting my vote :-)"]
=== CVS Repository ===
CVS: cvs -z3 -d:pserver:address@hidden:/cvsroot/dotgnu-libs co dotgnu.rdf
=== source tgz/deb ===
http://introspector.sourceforge.net/debian/incoming/dotgnu.rdf_0.2-1.tar.gz
=== See also ===
==== Redland ====
[http://www.redland.opensource.ac.uk "Redland RDF Framework"]
[http://www.ilrt.bris.ac.uk/discovery/2001/02/redland/ The Design and
Implementation of the Redland RDF Application Framework]
==== Jena2 ====
[http://www.hpl.hp.com/semweb/jena2.htm "Jena2"]
[http://sourceforge.net/projects/jena/ Jena2 SourceForge]
[http://groups.yahoo.com/group/jena-dev/ Jena Discussion]
==== Drive ====
[http://www.daml.ri.cmu.edu/drive/ "Drive RDF"]
==== Injektilo.org ====
[http://injektilo.org/rdf/rdf.net.html "Injektilo.org RDF"]
==== daml dotnetAPI ====
[http://www.daml.org/2002/10/dotnetAPI/ "daml dotnetAPI"]
==== RDFStore ====
[http://rdfstore.sourceforge.net/ "RDFStore Perl API"]
=== See also ===
[http://lists.w3.org/Archives/Public/www-rdf-interest/2000Nov/0151.html
RDFInterestMail]
Status : InProgress
--- NEW FILE ---
build :
csant
install :
mkdir debian/tmp
mv *.dll debian/tmp
makeapi : DotGNU.Rdf.n3_clean
DotGNU.Rdf.n3_clean : predicates.txt DotGNU.Rdf.n3t
perl test2n3.pl DotGNU.Rdf.n3t > DotGNU.Rdf.n3
rdfdump -n file:DotGNU.Rdf.n3 -o ntriples > DotGNU.Rdf.n3_clean
~/cwm/cwm.py DotGNU.Rdf.n3 > DotGNU.Rdf.n3_pure
--- NEW FILE ---
A Unified API for RDF
---------------------
Initial Draft: February 19th 2003.
Rahul Singh address@hidden
Modifications : February 23rd 2003.
James Michael DuPont address@hidden
Notations
---------
Original Sugesstion :
>>Class names use Pascal case for naming
This would be fine, but we want to make the Class names use standard ECMA case
for naming.
System.Xml for example, is analog to System.Rdf
>>Methodnames
Method names use standard ECMA case for naming
The first letter should be Upper-case, every other word Upper. ParseToken, For
example.
>>Parameter names use camel case for naming
The first letter should be lower-case, every other word Upper. myParameter, For
example.
>>Implementations of abstract classes are suffixed with Impl.
The standard does not cover the names of the Implementation classes
we recommend using a different namespace.
Abstract Classes
------------------
RdfStorage
An RDF Storage class that will store the XML serialzation, N3 Serialization or
other formatted RDF document. It also allows an abstract access to any RDF data
that is stored in Memory.
This is analog to the redland class RDFStorage.
The word storage better reflects the fact that it could be any format,
including a distributed database.
RdfXmlStorage
An RDF Storage class that will store the XML serialzation of RDF. Subclass of
RdfStorage
RdfN3Storage
An RDF Storage class that will store the N3 Serialization of RDF. Subclass of
RdfStorage
RdfParser
The main RdfParse that will parse RDF documents.
RdfSerializer
This generates RDF documents to Storages.
RdfIterator
This is a interator over a storage
RdfXmlParser
The main RdfParse that will parse RDF/XML documents. Subclass of RdfParser.
RdfN3Parser
The main RdfParse that will parse RDF/XML documents. Subclass of RdfParser.
RdfGraph
An RDF graph. This will be a labelled digraph that is recursively traversable.
RdfModel
Same as an RdfGraph. This is mainly a naming issue and this class can be
removed.
##############################################
Values
##############################################
RdfNode
This is a node in the RdfGraph or RdfModel. It is the base class of all values
RdfEdge
This is an edge in the RdfGraph or RdfModel. It is a Node that connects two
Triples/Statements.
RdfUri
This is a URI. Derived from System.Uri
RdfLiteral
This is a literal in RDF. Derived from RdfNode.
#######################
Data typed literals
#######################
RdfLiteralInteger
This is a integer literal in RDF. Derived from RdfLiteral.
RdfLiteralFloat
This is a Floating point literal in RDF. Derived from RdfLiteral.
##################################################
Statements
##################################################
RdfStatement
This is an RDF statement. Used in reification. Base class for future statement
types.
RdfTriple
This is an RDF triple where the subject, predicate and object are in N3 format.
A RdfTriple is a RdfStatement.
#################################
Collections
#################################
RdfCollection
This is the base RDF collection. Derived from RdfNode.
All collections are dervied from here.
RdfBag
This is an RDF Bag collection. Derived from RdfCollection.
RdfAlt
This is an RDF Alt collection. Derived from RdfCollection.
RdfSeq
This is an RDFSeq collection. Derived from RdfCollection.
##########################################
Here are non standard statement types.
These are not needed in the standard, but can be considered for the class design
##########################################
RdfPair
This is an RDF Pair where the subject, predicate are Nodes.
A RdfTriple is a RdfStatement.
RdfQuad
This is a non standard RDF Quad where the subject, predicate, and object and
context are in non standard N4 format.
A RdfQuad is a RdfStatement.
#########################
Following are not classes of nodes,
but role or states supported by nodes :
############################
RdfNodeRole
This is the base class for members nodes. A node may play a Role for a certain
period of time.
RdfObject
This is an RDF Object. Used in reification. Derived from RdfNodeRole.
RdfSubject
This is an RDF subject. Used in reification. Derived from RdfNodeRole.
RdfPredicate
This is an RDF predicate. Used in reification. Derived from RdfNodeRole.
############################
Implementation Classes
############################
RdfParserFactory
Factory class that generates and returns RdfParser objects.
This is questionable if it is needed in a C# context.
References:
-----------
[1] RDF/XML Syntax Specification
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
[2] N3 Design Issues
http://www.w3.org/DesignIssues/Notation3.html
[3] N3 Primer
http://www.w3.org/2000/10/swap/Primer
--- NEW FILE ---
A Unified API for RDF
---------------------
Initial Draft: February 19th 2003.
Rahul Singh address@hidden
Notations
---------
>>Class names use Pascal case for naming
Class names use standard ECMA case for naming
System.Xml for example, is analog to System.Rdf
>>Methodnames
Class names use standard ECMA case for naming
The first letter should be Upper-case, every other word Upper. ParseToken, For
example.
>>Parameter names use camel case for naming
The first letter should be lower-case, every other word Upper. myParameter, For
example.
>>Implementations of abstract classes are suffixed with Impl.
The standard does not cover the names of the Implementation classes
we recommend using a different namespace.
Abstract Classes
------------------
RDFDocument
An RDF Document class that will store the XML serialzation, N3 Serialization or
other formatted RDF document
RDFXMLDocument
An RDF Document class that will store the XML serialzation of RDF. Subclass of
RDFDocument
RDFN3Document
An RDF Document class that will store the N3 Serialization of RDF. Subclass of
RDFDocument
RDFParser
The main RDFParse that will parse RDF documents.
RDFParserFactory
Factory class that generates returns RDFParser objects
RDFGraph
An RDF graph. This will be a labelled digraph that is recursively traversable.
RDFModel
Same as an RDFGraph. This is mainly a naming issue and this class can be
removed. Alternatively this class can be used to hold logical models for RDF
based knowledgebases
RDFNode
This is a node in the RDFGraph or RDFModel
RDFEdge
This is an edge in the RDFGraph or RDFModel
RDFUri
This is a URI.
RDFLiteral
This is a literal in RDF.
RDFBag
This is an RDF Bag collection.
RDFAlt
This is an RDF Alt collection.
RDFSeq
This is an RDFSeq collection.
RDFTriple
This is an RDF triple where the subject, predicate and object are in N3 format.
RDFStatement
This is an RDF statement. Used in reification.
RDFObject
This is an RDF Object. Used in reification.
RDFSubject
This is an RDF subject. Used in reification.
RDFPredicate
This is an RDF predicate. Used in reification.
References:
-----------
[1] RDF/XML Syntax Specification
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
[2] N3 Design Issues
http://www.w3.org/DesignIssues/Notation3.html
[3] N3 Primer
http://www.w3.org/2000/10/swap/Primer
--- NEW FILE ---
DotGNU is-a Namespace
DotGNU.Rdf is-a Namespace
DotGNU.Rdf is-part-of DotGNU
N3-Design-Issues is http://www.w3.org/DesignIssues/Notation3.html
N3-Primer is http://www.w3.org/2000/10/swap/Primer
NonStandardStatements description "Here are non standard statement types. These
are not needed in the standard, but can be considered for the class design"
RDF.NTriples is-related-to N3-Design-Issues
RDF.NTriples is-related-to N3-Primer
RDF.XML is-related-to RDF.XML-Syntax-Specification
RDF.XML-Syntax-Specification is
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
RDFCollections is-a Namespace
RDFTypedLiterals is-a Namespace
RDFTypedLiterals is-named DotGNU.Rdf.Values.TypedLiterals
RDFValues is-a Namespace
RDFValues is-named DotGNU.Rdf.Values
RdfAlt description "This is an RDF Alt collection. Derived from RdfCollection."
RdfAlt is-a RdfCollection
RdfBag description This is an RDF Bag collection. Derived from RdfCollection
RdfBag is-a RdfCollection
RdfCollection description "This is the base RDF collection. Derived from
RdfNode. All collections are dervied from here."
RdfCollection is-a class
RdfEdge description "This is an edge in the RdfGraph or RdfModel. It is a Node
that connects two Triples/Statements"
RdfEdge is-a class
RdfEdge part-of RDFValues
RdfEdge part-of RDFValues
RdfGraph description "An RDF graph. This will be a labelled digraph that is
recursively traversable."
RdfGraph is-a class
RdfIterator description "This is a interator over a storage"
RdfIterator is-a class
RdfIterator is-part-of DotGNU.Rdf
RdfLiteral description "This is a literal in RDF. Derived from RdfNode"
RdfLiteral is-a class
RdfLiteral part-of RDFValues
RdfLiteralFloat description "This is a Floating point literal in RDF. Derived
from RdfLiteral."
RdfLiteralInteger description "This is a integer literal in RDF. Derived from
RdfLiteral."
RdfModel description "Same as an RdfGraph. This is mainly a naming issue and
this class can be removed."
RdfModel is-a class
RdfN3Parser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfN3Parser is-a class
RdfN3Storage description "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage"
RdfN3Storage implements RDF.NTriples
RdfN3Storage is-a class
RdfN3Storage is-part-of DotGNU.Rdf
RdfNode description "This is a node in the RdfGraph or RdfModel. It is the base
class of all values".
RdfNode is-a class
RdfNode part-of RDFValues
RdfNodeRole description "This is the base class for members nodes. A node may
play a Role for a certain period of time"
RdfNodeRole is-a RdfNodeRole
RdfNodeRole is-a class
RdfNodeRole is-a member
RdfNodeRole is-a role
RdfObject description "This is an RDF Object. Used in reification. Derived from
RdfNodeRole."
RdfObject is-a RdfNodeRole
RdfObject member-name "object"
RdfObject member-position 3
RdfPair description "This is an RDF Pair where the subject, predicate are
Nodes."
RdfPair is-a NonStandardStatement
RdfPair is-a NonStandardStatement
RdfPair is-a RdfStatement
RdfParser description "The main RdfParse that will parse RDF documents"
RdfParser is-a class
RdfParser is-part-of DotGNU.Rdf
RdfParserFactory description "Factory class that generates and returns
RdfParser objects"
RdfParserFactory is-a Factory
RdfParserFactory is-a ImplementationClass
RdfParserFactory is-a class
RdfPredicate description "This is an RDF predicate. Used in reification.
Derived from RdfNodeRole."
RdfPredicate is-a RdfNodeRole
RdfPredicate member-name "predicate"
RdfPredicate member-position 2
RdfQuad description "This is a non standard RDF Quad where the subject,
predicate, and object and context are in non standard N4 format"
RdfQuad is-a RdfStatement
RdfSeq description "This is an RDFSeq collection. Derived from RdfCollection."
RdfSeq is-a RdfCollection
RdfSerializer description "This generates RDF documents to Storages"
RdfSerializer is-a class
RdfSerializer is-part-of DotGNU.Rdf
RdfStatement description "This is an RDF statement. Used in reification. Base
class for future statement types."
RdfStatement is-a classs
RdfStatements is-a Namespace
RdfStorage analog Redland.RDFStorage
RdfStorage description "An RDF Storage class that will store the XML
serialzation of RDF".
RdfStorage description "An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory."
RdfStorage is-a class
RdfStorage is-part-of DotGNU.Rdf
RdfStorage meaning "The word storage better reflects the fact that it could be
any format, including a distributed database."
RdfSubject description "This is an RDF subject. Used in reification. Derived
from RdfNodeRole."
RdfSubject is-a RdfNodeRole
RdfSubject member-name "subject"
RdfSubject member-position 1
RdfTriple description "This is an RDF triple where the subject, predicate and
object are in N3 format."
RdfTriple is-a RdfStatement
RdfUri description "This is a URI. Derived from System.Uri"
RdfUri is-a class
RdfXMLStorage implements RDF.XML
RdfXmlParser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfXmlParser is-a class
RdfXmlStorage Subclass-of RdfStorage
RdfXmlStorage is-a class
RdfXmlStorage is-part-of DotGNU.Rdf
--- NEW FILE ---
DotGNU is-a Namespace.
DotGNU.Rdf is-a Namespace.
DotGNU.Rdf is-part-of DotGNU.
RdfStorage is-a class.
RdfStorage is-part-of DotGNU.Rdf.
RdfStorage description "An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory.".
RdfStorage analog Redland.RDFStorage.
RdfStorage meaning "The word storage better reflects the fact that it could be
any format, including a distributed database."
RdfXmlStorage is-a class.
RdfXmlStorage is-part-of DotGNU.Rdf.
RdfXMLStorage implements RDF.XML.
RdfStorage description "An RDF Storage class that will store the XML
serialzation of RDF".
RdfXmlStorage Subclass-of RdfStorage.
RDF.XML is-related-to RDF.XML-Syntax-Specification.
RDF.XML-Syntax-Specification is
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
RdfN3Storage is-a class.
RdfN3Storage is-part-of DotGNU.Rdf.
RdfN3Storage implements RDF.NTriples.
RdfN3Storage description "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage".
RDF.NTriples is-related-to N3-Design-Issues.
RDF.NTriples is-related-to N3-Primer.
N3-Design-Issues is http://www.w3.org/DesignIssues/Notation3.html.
N3-Primer is http://www.w3.org/2000/10/swap/Primer
RdfParser is-a class.
RdfParser is-part-of DotGNU.Rdf.
RdfParser description "The main RdfParse that will parse RDF documents".
RdfSerializer is-part-of DotGNU.Rdf.
RdfSerializer is-a class.
This generates RDF documents to Storages.
RdfIterator is-a class.
RdfIterator is-part-of DotGNU.Rdf.
RdfIterator description "This is a interator over a storage".
RdfXmlParser is-a class.
RdfXmlParser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfN3Parser is-a class.
RdfN3Parser description "The main RdfParse that will parse RDF/XML documents.
Subclass of RdfParser."
RdfGraph is-a class.
RdfGraph description "An RDF graph. This will be a labelled digraph that is
recursively traversable."
RdfModel is-a class.
RdfModel description "Same as an RdfGraph. This is mainly a naming issue and
this class can be removed."
##############################################
RDFValues is-a Namespace.
RDFValues is-named DotGNU.Rdf.Values.
##############################################
RdfNode is-a class.
RdfNode part-of RDFValues.
This is a node in the RdfGraph or RdfModel. It is the base class of all values
RdfEdge is-a class.
RdfEdge part-of RDFValues.
This is an edge in the RdfGraph or RdfModel. It is a Node that connects two
Triples/Statements.
RdfUri is-a class.
RdfEdge part-of RDFValues.
This is a URI. Derived from System.Uri
RdfLiteral is-a class.
RdfLiteral part-of RDFValues.
This is a literal in RDF. Derived from RdfNode.
#######################
RDFTypedLiterals is-a Namespace.
RDFTypedLiterals is-named DotGNU.Rdf.Values.TypedLiterals.
#######################
RdfLiteralInteger
This is a integer literal in RDF. Derived from RdfLiteral.
RdfLiteralFloat
This is a Floating point literal in RDF. Derived from RdfLiteral.
##################################################
Statements
##################################################
RdfStatement
This is an RDF statement. Used in reification. Base class for future statement
types.
RdfTriple
This is an RDF triple where the subject, predicate and object are in N3 format.
A RdfTriple is a RdfStatement.
#################################
Collections
#################################
RdfCollection
This is the base RDF collection. Derived from RdfNode.
All collections are dervied from here.
RdfBag
This is an RDF Bag collection. Derived from RdfCollection.
RdfAlt
This is an RDF Alt collection. Derived from RdfCollection.
RdfSeq
This is an RDFSeq collection. Derived from RdfCollection.
##########################################
Here are non standard statement types.
These are not needed in the standard, but can be considered for the class design
##########################################
RdfPair
This is an RDF Pair where the subject, predicate are Nodes.
A RdfTriple is a RdfStatement.
RdfQuad
This is a non standard RDF Quad where the subject, predicate, and object and
context are in non standard N4 format.
A RdfQuad is a RdfStatement.
#########################
Following are not classes of nodes,
but role or states supported by nodes :
############################
RdfNodeRole
This is the base class for members nodes. A node may play a Role for a certain
period of time.
RdfObject
This is an RDF Object. Used in reification. Derived from RdfNodeRole.
RdfSubject
This is an RDF subject. Used in reification. Derived from RdfNodeRole.
RdfPredicate
This is an RDF predicate. Used in reification. Derived from RdfNodeRole.
############################
Implementation Classes
############################
RdfParserFactory
Factory class that generates and returns RdfParser objects.
This is questionable if it is needed in a C# context.
References:
-----------
--- NEW FILE ---
RdfStorage is-a class.
RdfStorage description "An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory.".
RdfStorage analog Redland.RDFStorage.
RdfStorage meaning "The word storage better reflects the fact that it could be
any format, including a distributed database."
RdfXmlStorage is-a class.
RdfN3Storage implements RDF/XML.
RdfStorage description "An RDF Storage class that will store the XML
serialzation of RDF".
RdfXmlStorage Subclass-of RdfStorage.
RdfN3Storage is-a class.
RdfN3Storage implements RDF/NTriples.
RdfN3Storage description "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage".
RdfParser is-a class.
RdfParser description "The main RdfParse that will parse RDF documents".
RdfSerializer is-a class.
This generates RDF documents to Storages.
RdfIterator is-a class.
This is a interator over a storage
RdfXmlParser is-a class.
The main RdfParse that will parse RDF/XML documents. Subclass of RdfParser.
RdfN3Parser is-a class.
The main RdfParse that will parse RDF/XML documents. Subclass of RdfParser.
RdfGraph is-a class.
An RDF graph. This will be a labelled digraph that is recursively traversable.
RdfModel is-a class.
Same as an RdfGraph. This is mainly a naming issue and this class can be
removed.
##############################################
RDFValues is-a Namespace.
RDFValues is-named DotGNU.Rdf.Values.
##############################################
RdfNode is-a class.
RdfNode part-of RDFValues.
This is a node in the RdfGraph or RdfModel. It is the base class of all values
RdfEdge is-a class.
RdfEdge part-of RDFValues.
This is an edge in the RdfGraph or RdfModel. It is a Node that connects two
Triples/Statements.
RdfUri is-a class.
RdfEdge part-of RDFValues.
This is a URI. Derived from System.Uri
RdfLiteral is-a class.
RdfLiteral part-of RDFValues.
This is a literal in RDF. Derived from RdfNode.
#######################
RDFTypedLiterals is-a Namespace.
RDFTypedLiterals is-named DotGNU.Rdf.Values.TypedLiterals.
#######################
RdfLiteralInteger
This is a integer literal in RDF. Derived from RdfLiteral.
RdfLiteralFloat
This is a Floating point literal in RDF. Derived from RdfLiteral.
##################################################
Statements
##################################################
RdfStatement
This is an RDF statement. Used in reification. Base class for future statement
types.
RdfTriple
This is an RDF triple where the subject, predicate and object are in N3 format.
A RdfTriple is a RdfStatement.
#################################
Collections
#################################
RdfCollection
This is the base RDF collection. Derived from RdfNode.
All collections are dervied from here.
RdfBag
This is an RDF Bag collection. Derived from RdfCollection.
RdfAlt
This is an RDF Alt collection. Derived from RdfCollection.
RdfSeq
This is an RDFSeq collection. Derived from RdfCollection.
##########################################
Here are non standard statement types.
These are not needed in the standard, but can be considered for the class design
##########################################
RdfPair
This is an RDF Pair where the subject, predicate are Nodes.
A RdfTriple is a RdfStatement.
RdfQuad
This is a non standard RDF Quad where the subject, predicate, and object and
context are in non standard N4 format.
A RdfQuad is a RdfStatement.
#########################
Following are not classes of nodes,
but role or states supported by nodes :
############################
RdfNodeRole
This is the base class for members nodes. A node may play a Role for a certain
period of time.
RdfObject
This is an RDF Object. Used in reification. Derived from RdfNodeRole.
RdfSubject
This is an RDF subject. Used in reification. Derived from RdfNodeRole.
RdfPredicate
This is an RDF predicate. Used in reification. Derived from RdfNodeRole.
############################
Implementation Classes
############################
RdfParserFactory
Factory class that generates and returns RdfParser objects.
This is questionable if it is needed in a C# context.
References:
-----------
[1] RDF/XML Syntax Specification
http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/
[2] N3 Design Issues
http://www.w3.org/DesignIssues/Notation3.html
[3] N3 Primer
http://www.w3.org/2000/10/swap/Primer
--- NEW FILE ---
<HTML>
<HEAD><TITLE>dotgnu.rdf.xml</TITLE></HEAD>
<BODY BGCOLOR="#FFFFFF">
<H1>dotgnu.rdf.xml</H1>
<BLOCKQUOTE>
<A HREF="DotGNU/Rdf/Rdf.html" TARGET="members">DotGNU.Rdf Namespace</A><BR>
</BLOCKQUOTE>
</BODY>
</HTML>
--- NEW FILE ---
--- NEW FILE ---
--- NEW FILE ---
FeatureTable.cs RdfParser.cs RdfSerializer.cs RdfUri.cs
RdfEdge.cs RdfParserFactory.cs RdfSerializerN3.cs RdfWorld.cs
RdfModel.cs RdfParser_N3.cs RdfStream.cs Stack.cs
RdfNode.cs RdfParser_SystemXml.cs RdfTriple.cs
--- NEW FILE ---
cvs -z3 address@hidden:/cvsroot/dotgnu-libs $1
--- NEW FILE ---
\input texinfo @c -*-texinfo-*-
@c %** start of header
@setfilename dotgnu.rdf.info
@settitle dotgnu.rdf.info
@setchapternewpage on
@syncodeindex tp cp
@syncodeindex fn cp
@syncodeindex vr cp
@c %** end of header
@ifinfo
dotgnu.rdf.info
@end ifinfo
@titlepage
@sp 10
@center @titlefont{dotgnu.rdf.info}
@end titlepage
[...2360 lines suppressed...]
@example
@cartouche
public RdfWorld();
@end cartouche
@end example
@noindent @b{See Also}
@quotation
@ref{DotGNU.Rdf.RdfWorld Class}, @ref{DotGNU.Rdf Namespace}
@end quotation
@node Index,,, Top
@unnumbered Index
@printindex cp
@contents
@bye
--- NEW FILE ---
<Libraries><Types>
<Type Name="RdfEdge" FullName="DotGNU.Rdf.RdfEdge"
FullNameSP="DotGNU_Rdf_RdfEdge">
<TypeSignature Language="ILASM" Value=".class public auto ansi RdfEdge
extends System.Object"/>
<TypeSignature Language="C#" Value="public class RdfEdge"/>
<TypeKind>1</TypeKind>
<Docs><summary>
This class represents an RDFEdge in the RDFGraph
</summary></Docs>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces/>
<Attributes/>
<Members>
<Member MemberName="EdgeTypeIncoming">
<MemberSignature Language="ILASM" Value=".field public static literal
int32 EdgeTypeIncoming"/>
<MemberSignature Language="C#" Value="public static const int
EdgeTypeIncoming"/>
<MemberType>Field</MemberType>
<Attributes/>
[...1599 lines suppressed...]
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces/>
<Attributes/>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="ILASM" Value="public hidebysig specialname
rtspecialname instance void .ctor() cil managed "/>
<MemberSignature Language="C#" Value="public RdfWorld();"/>
<MemberType>Constructor</MemberType>
<Attributes/>
<ReturnValue/>
<Parameters/>
<Docs/>
<Excluded>0</Excluded>
</Member>
</Members>
<TypeExcluded>0</TypeExcluded>
</Type>
</Types></Libraries>
--- NEW FILE ---
gmon
--- NEW FILE ---
<HTML>
<HEAD><TITLE>dotgnu.rdf.xml</TITLE></HEAD>
<FRAMESET COLS="150,*">
<FRAMESET ROWS="50%,50%">
<FRAME SRC="namespaces.html" NAME="namespaces">
<FRAME SRC="DotGNU/Rdf/Rdf.html" NAME="members">
</FRAMESET>
<FRAME SRC="begin.html" NAME="contents">
</FRAMESET>
</HTML>
--- NEW FILE ---
[22:16] <minddog> heya dajobe
[22:16] <mdupont> ok guys, now start acting serious
[22:16] <dajobe> hello
[22:16] <mdupont> we have guests
[22:16] <mdupont> hi dajobe
[22:16] <minddog> ;)
[22:16] <dajobe> don't bother, I read the logs
[22:16] <mdupont> LOL
[22:18] Action: mdupont checks out the newest dotgnu.rdf
[22:19] <mdupont> and gets the newest redland.debs
[22:19] <mdupont> and cvs
[22:19] <mdupont> time to get serious now
[22:19] <mdupont> CVS SERVER :pserver:address@hidden:/cvsroot
[22:21] <mdupont>
http://www.redland.opensource.ac.uk/dist/source/redland-0.9.12.tar.gz
[22:21] <mdupont> this is the latest snapshot of redland
[22:21] <dajobe> release
[22:22] <mdupont> here is the real API
http://cvs.ilrt.org/cvsweb/redland/librdf/Redland.i?rev=1.32&content-type=text/vnd.viewcvs-markup
[22:22] <minddog> mdupont: lets get to work on an rdf writer
[22:22] <mdupont> that is the input to swig
[22:23] <mdupont> minddog: wait
[22:23] <minddog> so statement's need to be written
[22:23] <minddog> work from the output ;)
[22:23] <mdupont> lets pick dajobes brain about the api
[22:23] <minddog> we'll eventually get to the input
[22:23] <mdupont> we need to split it up into :
[22:23] <mdupont> API that is C# interface related
[22:23] <dajobe> I think I said to mdupont, there are lots of ways to do it and
my ignorance of c#/.NET CLR's capabilities meant I didn't know what things you
could use
[22:23] <dajobe> such as hashes/dicts/sequences/arrays/lists/...
[22:23] <mdupont> and API that is C specific
[22:24] <mdupont> dajobe: let me show you what we have done so far to answer
those questions
[22:24] <dajobe> the C API hides what actually can look a cleaner api when you
have higher level features
[22:24] <dajobe> sure
[22:25] <mdupont> that is why we may want to provide also interfaces for the C#
that mimic things like uri
[22:25] <mdupont> even if there is a .Net standard uri
[22:25] <dajobe> ok, in the perl API I accept both by sniffing for the type
with ref()
[22:26] <mdupont> people who only know redland or are porting code from python
for example
[22:26] <mdupont> dajobe: that is a good idea
[22:26] <mdupont> accept both
[22:26] <mdupont> :)
[22:26] <mdupont> we can also derive the redland classes from the originals
[22:26] <mdupont> supporting the base interface
[22:27] <mdupont> with redland specific function calls
[22:27] <mdupont> the inheritance would allow any redland.uri to be used
instead of a system.uri
[22:27] Action: minddog gets a headache
[22:27] <mdupont> https://savannah.gnu.org/projects/dotgnu-libs/
[22:27] <dajobe> hmm
[22:27] <minddog> ill grab some more caffeine
[22:27] <mdupont> this is the savannah page that hosts the package
[22:28] <dajobe> you don't really need a redland URI class
[22:28] <dajobe> it is just there for consistency across langauges
[22:28] <dajobe> so if there is a "native" one, I recommend using that and just
convert on calls
[22:28] <mdupont>
http://savannah.gnu.org/cgi-bin/viewcvs/dotgnu-libs/dotgnu.rdf/RdfParser.cs?rev=1.3&content-type=text/vnd.viewcvs-markup
[22:28] <mdupont> that is the dotGnu.rdfparser
[22:28] <mdupont> inspired by the redland parser
[22:29] <mdupont> dajobe: we have two sides to this
[22:29] <mdupont> on the interface
[22:29] <mdupont> for examples,
[22:29] <mdupont> let me dig up the interface for URi
[22:30] <dajobe> Not sure how that callback function stuff maps to that C#
[22:30] <mdupont> ooh
[22:30] <mdupont> that is a good question : Delegates
[22:30] <dajobe> I've no idea what that is, you'll have to consider it
[22:30] <mdupont> they are very nice, take a look a the parser class, scan for
delegate
[22:30] <mdupont> a delegate is a callobject object
[22:31] <mdupont> a function pointer with a type
[22:31] <mdupont> and it can be used as an stack of pointers to things
[22:31] <dajobe> ok
[22:31] <minddog> delegates are function pointers
[22:31] <dajobe> what's that Object[] paramlist stuff?
[22:31] <minddog> thats your ...
[22:31] <mdupont> so you can insert a whole stack of callbacks to a function
[22:32] <minddog> yup
[22:32] <minddog> i propose we build a statement class
[22:32] <minddog> and then have to convert the object to n3
[22:32] <minddog> and rdf/xml
[22:32] <mdupont>
http://savannah.gnu.org/cgi-bin/viewcvs/dotgnu-pnet/pnetlib/System/Uri.cs?rev=1.32&content-type=text/vnd.viewcvs-markup
[22:32] <minddog> we so can create different types of output from the start
[22:32] <mdupont> that is the dotgnu URI class
[22:33] <mdupont> public class Uri : MarshalByRefObject
[22:33] <mdupont> not an interface
[22:33] <mdupont> librdf_uri* librdf_new_uri (librdf_world *world, char
*string);
[22:33] <mdupont> librdf_uri* librdf_new_uri_from_uri (librdf_uri* uri);
[22:33] <mdupont> void librdf_free_uri(librdf_uri *uri);
[22:33] <mdupont> %newobject librdf_uri_to_string;
[22:33] <mdupont> char* librdf_uri_to_string (librdf_uri* uri);
[22:33] <mdupont> int librdf_uri_equals(librdf_uri* first_uri, librdf_uri*
second_uri);
[22:33] <mdupont> so this is the uri set from redland :
[22:33] <dajobe> it is pretty minimal there
[22:34] <dajobe> but Raptor uses/provides a fuller URI api
[22:34] <mdupont> librdf_uri* librdf_new_uri (librdf_world *world, char
*string); -- a new uri in a world.
[22:34] <dajobe> since it needs relative resolving etc.
[22:34] <mdupont> ok, but lets look at this for a minute
[22:34] <mdupont> this is the bare minimum as dajobe points out
[22:34] <mdupont> what is a world? it is a global data structure
[22:35] <mdupont> holding all the memory allocations
[22:35] <minddog> i thought we could just use System.Uri
[22:35] <mdupont> or if not holding, associated to.
[22:35] <minddog> since it holds all the values to the spec
[22:35] <minddog> and so does rdf
[22:35] <mdupont> yes we can use use system.uri
[22:35] <dajobe> so, what's the problem? use it
[22:35] Action: minddog notes its ecma compatible, so theres no discrepancy
[22:36] <mdupont> ok fine
[22:36] <minddog> since all cil implementations are at least ecma compat
[22:36] <minddog> problem solved
[22:36] <minddog> whats next on the agenda
[22:36] <mdupont>
http://savannah.gnu.org/cgi-bin/viewcvs/dotgnu-libs/dotgnu.rdf/RdfUri.cs?rev=1.1&content-type=text/vnd.viewcvs-markup
[22:37] <mdupont> this is the RdfUri
[22:37] <mdupont> that is derived from the system.uri and gives you the same
constructors
[22:37] <mdupont> do we delete this?
[22:37] <dajobe> sure
[22:37] <mdupont> ok
[22:37] <dajobe> as long as system.uri does all you need
[22:38] <dajobe> re statement
[22:38] <minddog> wel...
[22:38] <dajobe> if we are starting from scratch, I'd prefer triple
[22:38] <minddog> its good to have architecture in place
[22:38] <mdupont> what about the world.
[22:38] <mdupont> do we need an explicit world object
[22:38] <minddog> what are worlds again =X
[22:38] <dajobe> this is a C library
[22:38] <dajobe> so you needed somewhere to hang all the dynamically allocated
stuff
[22:39] <minddog> a tree?
[22:39] <mdupont> dajobe: pnet uses garbage collection
[22:39] <dajobe> no
[22:39] <mdupont> i think it even uses boeme
[22:39] <dajobe> for example, where you register all the parser factories
[22:40] <dajobe> and other dynamically registered stuff. The 1-time
initialising things
[22:41] <minddog> mdupont: fill me in
[22:41] <minddog> factories?
[22:42] <mdupont> these are the important functions :
[22:42] <mdupont> librdf_node* librdf_new_node_from_uri_string(librdf_world
*world, char *string);
[22:42] <mdupont> for example
[22:42] <mdupont> all the node creation functions
[22:42] <minddog> hrmm /me looks up factories on his own
[22:42] Action: mdupont looks to the c# api
[22:42] <mdupont> sorry minddog
[22:43] <dajobe> this is mostly internals for me; in a lang without
interface/impl split, you need a way to register impls of an interface - those
are the factories. The "world" place is where you can register them
[22:43] <mdupont> factories are used to dynamically register callbacks for
name-look-up object instanciation
[22:43] <mdupont> il supports that directly
[22:43] <mdupont> basically the "world" is the pnet runtime
[22:43] <mdupont> created by rhysw here :)
[22:43] <minddog> whoa thats a mouthful
[22:44] <minddog> yeah rhysw might interested in this experiment
[22:44] <mdupont> you can say in il:
[22:44] Action: mdupont looks
[22:45] <mdupont> newobj instance void 'System'.'Uri'::'.ctor'(class
'System'.'String')
[22:45] <mdupont> based on the name of the class, the right implemention is
loaded
[22:45] <mdupont> this is not very easy in c
[22:45] <minddog> factories sound like an object oriented way of doing things
with instances
[22:46] <mdupont> the factory would allow you to register things like a "n3"
parser
[22:46] <mdupont> and associate a set of functions to implement it
[22:46] <mdupont> that is all handled by c# and the runtime
[22:46] Action: dajobe thought factories was a well known design pattern.
Guess I was wrong :)
[22:46] <mdupont> dajobe: they are well know
[22:46] <mdupont> n
[22:46] <minddog> << not a C guru
[22:47] <minddog> okay i get ya
[22:47] <dajobe> I'm thinking of the Design Patterns books, which were C++ IIRC
[22:47] <dajobe> anyhoo
[22:48] <mdupont> http://www.dofactory.com/patterns/PatternAbstract.aspx
[22:48] <mdupont> Definition
[22:48] <mdupont> Provide an interface for creating families of related or
dependent objects without specifying their concrete classes.
[22:48] <minddog> sounds like the interface keyword in OO Languages
[22:49] <dajobe> yes, and as I said " in a lang without interface/impl
split,...."
[22:49] <mdupont> so, each factory will basically turn into an interface
[22:49] <mdupont> in c#
[22:49] <minddog> so we build an interface Factory
[22:49] Action: rhysw would like to see factory syntax integrated directly into
the language. e.g. "new X(...) with Factory"
[22:49] <minddog> and implement our concretes from there
[22:50] <dajobe> this seems rather a (maybe interesting!) but lowlevel bit of
the api, maybe we could move up a few layers?
[22:50] <rhysw> rather than "Factory.createX(...)"
[22:50] <minddog> rhysw: does this have anything to do with generic in the new
c# rev
[22:50] <dajobe> rhysw: seems a good idea; the latter is the metaphor I see in
Java
[22:50] <minddog> err i think thats just templates nevermind
[22:50] <rhysw> minddog: not that I'm aware of, but I haven't really
investigated generics yet because the spec isn't public
[22:50] <mdupont> lets look at the java api for a minute
[22:50] <mdupont> http://www.redland.opensource.ac.uk/docs/java.html
[22:51] <mdupont> the Redland storage is basically the Rdfgraph
[22:51] <dajobe> if you are starting from scratch, I suggest a few renames
[22:52] <dajobe> statement->triple and model->graph
[22:52] <minddog> dajobe: sounds cool
[22:52] <mdupont> Add Statements, Get things about this object
[22:52] <mdupont> dajobe: ok
[22:52] <dajobe> the former confuses use/mention (sigh!) and the latter just
baffles logicians
[22:53] <minddog> dajobe: what better then to put in an automata for compiling
[22:53] <minddog> ;)
[22:53] <dajobe> BTW if you've got some urgent c# stuff to chat about, I'll
re-lurk
[22:53] <mdupont> so storage is coupled tightly with model(graph)
[22:53] <minddog> #if LOGICIAN
[22:53] <dajobe> s/c#/dotgnu/ # naughty
[22:53] <minddog> #else
[22:53] <minddog> ./configure --with-mode=LOGICIAN
[22:54] <minddog> okay veering off the road
[22:54] <minddog> i noticed they don't have a Factory in java
[22:54] <dajobe> I once considered ./configure --with-license=GPL for my
multi-licensed software but that's another story
[22:54] <dajobe> yeah, but they emulate it
[22:54] <dajobe> as rhysw showed
[22:55] <mdupont> the model is what is stored in the storage
[22:55] duplexer_gmf (address@hidden) left irc: Read error: 110 (Connection
timed out)
[22:55] <dajobe> I'd put it another way
[22:55] <dajobe> the graph (was model) is the abstract thing
[22:55] <mdupont> so basically the model (graph) is the key abstraction of rdf.
[22:55] <dajobe> yeah :)
[22:55] <mdupont> ok,
[22:55] <mdupont> then lets look at this class togeather
[22:56] <dajobe> and a graph could be stored, and if it does, it has an
associated storage object
[22:56] <minddog> rdfgraph == hashtable
[22:56] <dajobe> no, it's abstract
[22:56] <minddog> i think rdfgraph in drive was done with a hashtable
[22:56] <dajobe> and for example one of the storages could be implemented as a
hashtable
[22:56] <minddog> oh
[22:56] duplexer (address@hidden) left irc: "Adjusting my dish for a satellite
uplink."
[22:56] <mdupont> minddog: rdfgraph has a storage, a storage has three hashes
[22:56] <dajobe> .. in one of the redland impls
[22:57] <mdupont> a hash can be in memory or on disk
[22:57] <dajobe> in another, a storage is doubly linked list in memory - fast
and dumb
[22:57] <dajobe> the abstract api - the model - deals with triples
[22:57] <minddog> hah
[22:57] <minddog> the nodes are stored in a hashtable
[22:57] <dajobe> so the abstract look of an rdf graph is asking about the --->
arrows in a graph
[22:58] <minddog> and listIDs and Namespaces are two private hashtables
[22:58] Action: dajobe hasn't dived into drive
[22:58] <minddog> http://minddog.shacknet.nu:8080/~minddog/RDFGraph.cs
[22:58] <minddog> thats from drive
[22:59] <dajobe> this is more of a discussion of the best way to implement a
directed labeled graph (with possible duplicate arcs) I think
[22:59] <dajobe> and there are many answers, long and complex
[23:00] <dajobe> minddog: that's a model and store in 1
[23:00] <minddog> dajobe: ahh
[23:00] <dajobe> using the graph terminology - nodes and edges
[23:00] <mdupont> ok, it seems we dont have a RdfGraph.cs yet
[23:00] <mdupont> so, we can base that on Redland::Model
[23:01] <mdupont> http://www.redland.opensource.ac.uk/docs/api/model.html
[23:01] <dajobe> you've got RdfModel.cs already though
[23:01] <mdupont> renaming that to RdgGraph
[23:01] <dajobe> yes
[23:01] <minddog> oaky
[23:01] <minddog> i'm starting to see some things fit together
[23:01] <mdupont> yes the RdfModel is empty
[23:01] <mdupont> we delete that
[23:01] <t3rmin4t0r> rhysw: ?
[23:01] <mdupont> and the URi
[23:02] <rhysw> t3rmin4t0r: I'm here
[23:02] <minddog> we need an RdfNode.cs
[23:02] <t3rmin4t0r> ok
[23:02] <mdupont> rhys would you like to start the main meeting
[23:02] <dajobe> here, you might want to think about the way java etc does it
[23:02] <mdupont> we can move this to after the main dotgnu meeting
[23:02] <dajobe> since they have rdf node/literal/resource inheriting
[23:02] <dajobe> sure
[23:02] <rhysw> whatever works
[23:03] <mdupont> ok, just let us finish this point
[23:03] <rhysw> ok
[23:03] <mdupont> dajobe: you want to have literal derived from node
[23:03] <minddog> a small RdfNode to build maybe a linked list as a statement?
[23:03] <mdupont> and resource derived from node
[23:04] <dajobe> i.e. rdf literal ISA rdf resource
[23:04] <mdupont> Hello JosD
[23:04] <dajobe> minddog: yes, could do i.e. statement is [3]node
[23:04] <mdupont>
http://savannah.gnu.org/cgi-bin/viewcvs/dotgnu-libs/dotgnu.rdf/RdfNode.cs?rev=1.1&content-type=text/vnd.viewcvs-markup
[23:04] <JosD> Hello Mike (I'm still sleeping ...)
[23:04] Action: t3rmin4t0r slowly says "we need to finish up XML !" :-)
[23:04] <mdupont> the current RdfNode supports some of the arc queries that the
model doesl
[23:05] <mdupont> that is because it knows in which Graph it is in
[23:05] <mdupont> this is a "fatter" design
[23:05] <dajobe> it again assumes an implementation
[23:05] <dajobe> and is in terms of graph edge/nodes, not triples
[23:05] <mdupont> ok, from the interface side : can we have a node that knows
this? not really,
[23:05] <dajobe> no
[23:06] <dajobe> nodes are not standalone
[23:06] <mdupont> you would have to pass the graph in as a parameter
[23:06] <minddog> RdfNode's should be aware throguh reflection
[23:06] <dajobe> they only exist as parts of triples
[23:06] <minddog> but not around the entire Graph
[23:06] <dajobe> and triples only exist in graphs
[23:06] <minddog> Whatever triples the RdfNode is in, is what its aware of
[23:06] <mdupont> Graph --< Triples --< Node
[23:07] <dajobe> so you *can* do triple.method() that can reference the triple
& it's nodes
[23:07] <minddog> the triples would tell the ndoe that anyway, shall we wrap it
up
[23:07] <dajobe> but you cannot do node.method() that automagically knows about
what triple/graph it is in
[23:07] <mdupont> we want to find all the triples about a node, given a nodes
reference
[23:07] Action: JosD thinks dajobe is very right that "triples only exist in
graphs"
[23:07] <dajobe> mdupont: that would be a method on the graph
[23:07] <mdupont> ok
[23:07] <dajobe> graph.find_all_triples_about(node)
[23:08] <mdupont> so we have a clean hierarchy here, no backpointers
[23:08] <dajobe> sure
[23:08] <mdupont> no assumptions about implementation
[23:08] <minddog> a triple is a graph and a graph is triple|many triples
[23:08] <t3rmin4t0r> so is it going to be a Tree + References ?
[23:08] <dajobe> maybe you should go on with your scheduled meeting
[23:08] <mdupont> t3rmin4t0r: the graph has a specific api
[23:08] <dajobe> maybe this would help
http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-triple
[23:09] <t3rmin4t0r> ok, I thought you were discussing that
[23:09] <minddog> dajobe: the most optimized way of getting what the node is
aware of is through each statement created the node appends to a list of
friends|relatives or something
[23:09] <dajobe> possibly
[23:10] <dajobe> that could be optimised by indexes
[23:10] <dajobe> so it would be a storage question really
[23:10] <minddog> you can just use pointers in taht list
[23:10] <mdupont> minddog: lets assume that we are on the net
[23:10] <dajobe> in the big case, a SQL backend
[23:10] <mdupont> and i pass you a node across the jabber transport
[23:10] <minddog> uh huh
[23:10] <mdupont> you want to know, who has statements about this
[23:10] <mdupont> but there could be billions of statements
[23:10] <mdupont> across millions of servres
[23:11] <mdupont> so we cannot assume that all statements are stored in one
storage
[23:11] <minddog> ip addresses would be a good way of indexing
[23:11] <mdupont> the storage needs to be remote
[23:11] <minddog> like a root ip address
[23:11] <mdupont> the node can be an uri
[23:12] <mdupont> you can say http://dotgnu.org/people.html is a node
[23:12] <mdupont> you can say http://192.168.0.101/test/file.rdf#id-2033
[23:12] <mdupont> is a node
[23:12] <minddog> lets call it shut
[23:12] <minddog> dotgnu time
[23:12] <mdupont> ok,
[23:12] <minddog> well this is dotgnu heh
[23:12] <mdupont> thanks for waiting rhysw, t3rmin4t0r
[23:13] <minddog> thats t3rmin4t0r's phone bill =X
[23:13] Action: rhysw calls the meeting to order
[23:13] <mdupont> we will continue the rdf stuff on #rdfig for now
[23:13] <minddog> mdupont: ill get to it later
--- NEW FILE ---
<HTML>
<BODY BGCOLOR="#FFFFFF">
<I>Namespaces</I><P>
<A HREF="DotGNU/Rdf/Rdf.html" TARGET="members">DotGNU.Rdf</A><BR>
</BODY>
</HTML>
--- NEW FILE ---
http://www.mindswap.org/~mhgrove/ClassLoader/classLoaderOnt.owl#Constructor
http://www.mindswap.org/~mhgrove/ClassLoader/classLoaderOnt.owl#Method
http://www.mindswap.org/~mhgrove/ClassLoader/classLoaderOnt.owl#Object
http://www.mindswap.org/~mhgrove/ClassLoader/classLoaderOnt.owl#Parameter
http://www.mindswap.org/~mhgrove/ClassLoader/classLoaderOnt.owl#withValue
http://www.w3.org/1999/02/22-rdf-syntax-ns#first
http://www.w3.org/1999/02/22-rdf-syntax-ns#rest
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
http://www.w3.org/2002/07/owl#Class
http://www.w3.org/2002/07/owl#Datatype
http://www.w3.org/2002/07/owl#Nothing
http://www.w3.org/2002/07/owl#Ontology
http://www.w3.org/2002/07/owl#Restriction
http://www.w3.org/2002/07/owl#Thing
http://www.w3.org/2002/07/owl#allValuesFrom
http://www.w3.org/2002/07/owl#cardinality
http://www.w3.org/2002/07/owl#comment
http://www.w3.org/2002/07/owl#complementOf
http://www.w3.org/2002/07/owl#differentFrom
http://www.w3.org/2002/07/owl#disjointWith
http://www.w3.org/2002/07/owl#domain
http://www.w3.org/2002/07/owl#hasValue
http://www.w3.org/2002/07/owl#imports
http://www.w3.org/2002/07/owl#intersectionOf
http://www.w3.org/2002/07/owl#inverseOf
http://www.w3.org/2002/07/owl#maxCardinality
http://www.w3.org/2002/07/owl#minCardinality
http://www.w3.org/2002/07/owl#onProperty
http://www.w3.org/2002/07/owl#oneOf
http://www.w3.org/2002/07/owl#range
http://www.w3.org/2002/07/owl#resource
http://www.w3.org/2002/07/owl#sameAs
http://www.w3.org/2002/07/owl#sameClassAs
http://www.w3.org/2002/07/owl#sameIndividualAs
http://www.w3.org/2002/07/owl#someValuesFrom
http://www.w3.org/2002/07/owl#unionOf
http://www.w3.org/2002/07/owl#versionInfo
http://www.w3.org/2002/07/owl#samePropertyAs
http://www.w3.org/2002/07/owl#DatatypeProperty
http://www.w3.org/2002/07/owl#FunctionalProperty
http://www.w3.org/2002/07/owl#InverseFunctional Property
http://www.w3.org/2002/07/owl#ObjectProperty
http://www.w3.org/2002/07/owl#SymmetricProperty
http://www.w3.org/2002/07/owl#TransitiveProperty
http://www.w3.org/2000/01/rdf-schema#Class
http://www.w3.org/2000/01/rdf-schema#ConstraintProperty
http://www.w3.org/2000/01/rdf-schema#ConstraintResource
http://www.w3.org/2000/01/rdf-schema#Container
http://www.w3.org/2000/01/rdf-schema#ContainerMembershipProperty
http://www.w3.org/2000/01/rdf-schema#Literal
http://www.w3.org/2000/01/rdf-schema#Resource
http://www.w3.org/2000/01/rdf-schema#comment
http://www.w3.org/2000/01/rdf-schema#domain
http://www.w3.org/2000/01/rdf-schema#isDefinedBy
http://www.w3.org/2000/01/rdf-schema#label
http://www.w3.org/2000/01/rdf-schema#range
http://www.w3.org/2000/01/rdf-schema#seeAlso
http://www.w3.org/2000/01/rdf-schema#subClassOf
http://www.w3.org/2000/01/rdf-schema#subPropertyOf
http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt
http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag
http://www.w3.org/1999/02/22-rdf-syntax-ns#Property
http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq
http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement
http://www.w3.org/1999/02/22-rdf-syntax-ns#object
http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate
http://www.w3.org/1999/02/22-rdf-syntax-ns#subject
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
http://www.w3.org/1999/02/22-rdf-syntax-ns#value
http://www.w3.org/2000/01/rdf-schema#
--- NEW FILE ---
is-named http://www.w3.org/2002/07/owl#label
is-part-of http://introspector.sf.net/2003/03/dro#SubNameSpace
Subclass-of http://www.w3.org/2002/07/owl#subClassOf
meaning http://www.w3.org/2002/07/owl#comment
description http://www.w3.org/2002/07/owl#comment
member-name http://www.w3.org/2000/01/rdf-schema#label
is-related-to http://www.w3.org/2000/01/rdf-schema#isDefinedBy
is http://www.w3.org/2000/01/rdf-schema#subClassOf
part-of http://introspector.sf.net/2003/03/dro#PartOfNameSpace
is-a http://www.w3.org/2000/01/rdf-schema#subClassOf
analog http://www.w3.org/2002/07/owl#sameClassAs
member-position http://introspector.sf.net/2003/03/dro#ParameterPosition
implements http://introspector.sf.net/2003/03/dro#ImplementsInterface
--- NEW FILE ---
2003-02-08 19:35 mdupont
* DotGNU.Rdf.build, RdfModel.cs, RdfParser.cs, RdfParserFactory.cs,
RdfParser_SystemXml.cs, RdfStream.cs, RdfUri.cs, RdfWorld.cs: this
is a major clean up
2003-02-08 17:30 mdupont
* RDFParser.cs, RDFParser_SystemXml.cs, RdfParser.cs: Cleaning up
put lots of new empty classes in. have to move that out
2003-02-08 10:38 mdupont
* ChangeLog: doing the cl
2003-02-08 10:35 mdupont
* RdfEdge.cs, RdfNode.cs: cleaned up
2003-02-08 10:19 minddog
* ChangeLog, RDFEdge.cs, RDFNode.cs, RdfParser.cs,
RdfParser_SystemXml.cs, ChangeLog: [no log message]
2003-02-08 09:10 minddog
* RDFParser_SystemXml.cs: [no log message]
2003-02-05 00:33 minddog
* DotGNU.Rdf.build, RDFParser.cs, RDFParser_SystemXml.cs,
ChangeLog: [no log message]
2003-02-02 02:17 minddog
* ChangeLog, DotGNU.Rdf.build, build.sh, Makefile.am, auto_gen.sh,
configure.in: [no log message]
2003-02-02 01:53 minddog
* Makefile.am, auto_gen.sh, configure.in, ChangeLog: [no log
message]
2003-02-02 00:32 minddog
* ChangeLog, RDFEdge.cs, RDFNode.cs, RDFParser.cs, COPYING: [no log
message]
2003-02-02 00:32 minddog
* ChangeLog, RDFEdge.cs, RDFNode.cs, RDFParser.cs, COPYING: Initial
revision
--- NEW FILE ---
<DotGNU> <is-a> <Namespace>.
<DotGNU.Rdf> <is-a> <Namespace>.
<DotGNU.Rdf> <is-part-of> <DotGNU>.
<RdfStorage> <is-a> <class>.
<RdfStorage> <is-part-of> <DotGNU.Rdf>.
<RdfStorage> <description> "An RDF Storage class that will store the XML
serialzation, N3 Serialization or other formatted RDF document. It also allows
an abstract access to any RDF data that is stored in Memory.".
<RdfStorage> <analog> <Redland.RDFStorage>.
<RdfStorage> <meaning> "The word storage better reflects the fact that it could
be any format, including a distributed database.".
<RdfXmlStorage> <is-a> <class>.
<RdfXmlStorage> <is-part-of> <DotGNU.Rdf>.
<RdfXMLStorage> <implements> <RDF.XML>.
<RdfStorage> <description> "An RDF Storage class that will store the XML
serialzation of RDF".
<RdfXmlStorage> <Subclass-of> <RdfStorage>.
<RDF.XML> <is-related-to> <RDF.XML-Syntax-Specification>.
<RDF.XML-Syntax-Specification> <is>
<http://www.w3.org/2001/sw/RDFCore/TR/WD-rdf-syntax-grammar-20030117/>.
<RdfN3Storage> <is-a> <class>.
<RdfN3Storage> <is-part-of> <DotGNU.Rdf>.
<RdfN3Storage> <implements> <RDF.NTriples>.
<RdfN3Storage> <description> "An RDF Storage class that will store the N3
Serialization of RDF. Subclass of RdfStorage".
<RDF.NTriples> <is-related-to> <N3-Design-Issues>.
<RDF.NTriples> <is-related-to> <N3-Primer>.
<N3-Design-Issues> <is> <http://www.w3.org/DesignIssues/Notation3.html>.
<N3-Primer> <is> <http://www.w3.org/2000/10/swap/Primer>.
<RdfParser> <is-a> <class>.
<RdfParser> <is-part-of> <DotGNU.Rdf>.
<RdfParser> <description> "The main RdfParse that will parse RDF documents".
<RdfSerializer> <is-part-of> <DotGNU.Rdf>.
<RdfSerializer> <is-a> <class>.
<This> <generates> <RDF> <documents> <to> <Storages>.
<RdfIterator> <is-a> <class>.
<RdfIterator> <is-part-of> <DotGNU.Rdf>.
<RdfIterator> <description> "This is a interator over a storage".
<RdfXmlParser> <is-a> <class>.
<RdfXmlParser> <description> "The main RdfParse that will parse RDF/XML
documents. Subclass of RdfParser.".
<RdfN3Parser> <is-a> <class>.
<RdfN3Parser> <description> "The main RdfParse that will parse RDF/XML
documents. Subclass of RdfParser.".
<RdfGraph> <is-a> <class>.
<RdfGraph> <description> "An RDF graph. This will be a labelled digraph that is
recursively traversable.".
<RdfModel> <is-a> <class>.
<RdfModel> <description> "Same as an RdfGraph. This is mainly a naming issue
and this class can be removed.".
<RDFValues> <is-a> <Namespace>.
<RDFValues> <is-named> <DotGNU.Rdf.Values>.
<RdfNode> <is-a> <class>.
<RdfNode> <part-of> <RDFValues>.
<This> <is> <a> <node> <in> <the> <RdfGraph> <or> <RdfModel.> <It> <is> <the>
<base> <class> <of> <all> <values>.
<RdfEdge> <is-a> <class>.
<RdfEdge> <part-of> <RDFValues>.
<This> <is> <an> <edge> <in> <the> <RdfGraph> <or> <RdfModel.> <It> <is> <a>
<Node> <that> <connects> <two> <Triples/Statements>.
<RdfUri> <is-a> <class>.
<RdfEdge> <part-of> <RDFValues>.
<This> <is> <a> <URI.> <Derived> <from> <System.Uri>.
<RdfLiteral> <is-a> <class>.
<RdfLiteral> <part-of> <RDFValues>.
<This> <is> <a> <literal> <in> <RDF.> <Derived> <from> <RdfNode>.
<RDFTypedLiterals> <is-a> <Namespace>.
<RDFTypedLiterals> <is-named> <DotGNU.Rdf.Values.TypedLiterals>.
<RdfLiteralInteger> <description> "This is a integer literal in RDF. Derived
from RdfLiteral.".
<RdfLiteralFloat> <description> "This is a Floating point literal in RDF.
Derived from RdfLiteral.".
<RdfStatements> <is-a> <Namespace>.
<RdfStatement> <description> "This is an RDF statement. Used in reification.
Base class for future statement types.".
<RdfStatement> <is-a> <classs>.
<RdfTriple> <description> "This is an RDF triple where the subject, predicate
and object are in N3 format.".
<RdfTriple> <is-a> <RdfStatement>.
<RDFCollections> <is-a> <Namespace>.
<RdfCollection> <description> "This is the base RDF collection. Derived from
RdfNode. All collections are dervied from here.".
<RdfCollection> <is-a> <class>.
<RdfBag> <is-a> <RdfCollection>.
<RdfBag> <description> <This> <is> <an> <RDF> <Bag> <collection.> <Derived>
<from> <RdfCollection>.
<RdfAlt> <is-a> <RdfCollection>.
<RdfAlt> <description> "This is an RDF Alt collection. Derived from
RdfCollection.".
<RdfSeq> <is-a> <RdfCollection>.
<RdfSeq> <description> "This is an RDFSeq collection. Derived from
RdfCollection.".
<NonStandardStatements> <description> "Here are non standard statement types.
These are not needed in the standard, but can be considered for the class
design".
<RdfPair> <description> "This is an RDF Pair where the subject, predicate are
Nodes.".
<RdfPair> <is-a> <RdfStatement>.
<RdfPair> <is-a> <NonStandardStatement>.
<RdfQuad> <description> "This is a non standard RDF Quad where the subject,
predicate, and object and context are in non standard N4 format".
<RdfQuad> <is-a> <RdfStatement>.
<RdfPair> <is-a> <NonStandardStatement>.
<RdfNodeRole> <is-a> <class>.
<RdfNodeRole> <is-a> <role>.
<RdfNodeRole> <is-a> <RdfNodeRole>.
<RdfNodeRole> <is-a> <member>.
<RdfNodeRole> <description> "This is the base class for members nodes. A node
may play a Role for a certain period of time".
<RdfObject> <is-a> <RdfNodeRole>.
<RdfObject> <member-name> "object".
<RdfObject> <member-position> <3>.
<RdfObject> <description> "This is an RDF Object. Used in reification. Derived
from RdfNodeRole.".
<RdfSubject> <is-a> <RdfNodeRole>.
<RdfSubject> <member-name> "subject".
<RdfSubject> <member-position> <1>.
<RdfSubject> <description> "This is an RDF subject. Used in reification.
Derived from RdfNodeRole.".
<RdfPredicate> <is-a> <RdfNodeRole>.
<RdfPredicate> <member-name> "predicate".
<RdfPredicate> <member-position> <2>.
<RdfPredicate> <description> "This is an RDF predicate. Used in reification.
Derived from RdfNodeRole.".
<RdfParserFactory> <is-a> <class>.
<RdfParserFactory> <is-a> <Factory>.
<RdfParserFactory> <is-a> <ImplementationClass>.
<RdfParserFactory> <description> "Factory class that generates and returns
RdfParser objects".
--- NEW FILE ---
# split by ""
# split by ws.
use warnings;
use strict;
my %predicates;
my $debug =0;
sub loadpredicates
{
open IN,"predicates.txt";
while (<IN>)
{
chomp;
my @values =split /\s+/;
$predicates{$values[0]}=$values[1];
warn "Read $_\n" if $debug;
}
close IN;
}
sub ReadFile
{
while (<>)
{
next if /^\s+$/;
my $line= $_;
my @strings;
my $end = ".\n";
if (@strings = split /\"/)
{
if ($#strings > 1)
{
$line =$strings[0];
$end = ' "' . $strings[1] . '"' . $end;
}
}
my @values = split (/\s+/,$line);
my $predicate = $values[1];
my $name = $predicates{$predicate};
warn "$name --> $predicate\n" if $debug;
die "$predicate is missing!\n" unless $name;
$values[1] = $name;
# sub write_line
print join(
" ",
(
map {
"<$_>"
}
@values
)
);
print $end;
###################
}
}
loadpredicates;
ReadFile;
warn join ("\n", (keys %predicates)) if $debug;
Index: DotGNU.Rdf.build
===================================================================
RCS file: /cvsroot/dotgnu-libs/dotgnu.rdf/DotGNU.Rdf.build,v
retrieving revision 1.9
retrieving revision 1.10
diff -C2 -r1.9 -r1.10
*** DotGNU.Rdf.build 16 Feb 2003 20:03:16 -0000 1.9
--- DotGNU.Rdf.build 19 Jun 2003 20:16:07 -0000 1.10
***************
*** 6,27 ****
<compile output="DotGNU.Rdf.dll"
target="library"
! optimize="true">
<sources>
! <includes name="RdfNode.cs" />
<includes name="RdfEdge.cs" />
- <includes name="RdfParser.cs" />
- <includes name="RdfGraph.cs" />
- <includes name="RdfStream.cs" />
<includes name="RdfModel.cs" />
! <includes name="RdfWorld.cs" />
! <includes name="RdfUri.cs" />
<includes name="RdfParserFactory.cs" />
<includes name="RdfParser_SystemXml.cs" />
<includes name="RdfSerializer.cs" />
<includes name="RdfSerializerN3.cs" />
<includes name="RdfTriple.cs" />
! <includes name="RdfParser_N3.cs" />
! <includes name="FeatureTable.cs" />
<includes name="Stack.cs" />
</sources>
--- 6,27 ----
<compile output="DotGNU.Rdf.dll"
target="library"
! debug="true"
! optimize="false">
<sources>
! <includes name="FeatureTable.cs" />
<includes name="RdfEdge.cs" />
<includes name="RdfModel.cs" />
! <includes name="RdfNode.cs" />
! <includes name="RdfParser.cs" />
<includes name="RdfParserFactory.cs" />
+ <includes name="RdfParser_N3.cs" />
<includes name="RdfParser_SystemXml.cs" />
<includes name="RdfSerializer.cs" />
<includes name="RdfSerializerN3.cs" />
+ <includes name="RdfStream.cs" />
<includes name="RdfTriple.cs" />
! <includes name="RdfUri.cs" />
! <includes name="RdfWorld.cs" />
<includes name="Stack.cs" />
</sources>
Index: RdfParser.cs
===================================================================
RCS file: /cvsroot/dotgnu-libs/dotgnu.rdf/RdfParser.cs,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -r1.5 -r1.6
*** RdfParser.cs 16 Feb 2003 16:05:31 -0000 1.5
--- RdfParser.cs 19 Jun 2003 20:16:07 -0000 1.6
***************
*** 27,31 ****
using System.Net;
! public class RdfParser
{
private RdfWorld world;
--- 27,31 ----
using System.Net;
! public abstract class RdfParser
{
private RdfWorld world;
***************
*** 35,39 ****
// librdf_parser_register_factory
! public abstract void ParserRegisterFactory(RdfWorld world,
String name, String mime_type, String uri_string, Factory parser_factory);
// Constructor.
--- 35,39 ----
// librdf_parser_register_factory
! // public abstract void ParserRegisterFactory(RdfWorld world,
String name, String mime_type, String uri_string, Factory parser_factory);
// Constructor.
***************
*** 77,81 ****
// librdf_free_parser
! public abstract void ParserFree(RdfParser parser);
// librdf_parser_parse_as_stream
--- 77,81 ----
// librdf_free_parser
! // public abstract void ParserFree(RdfParser parser);
// librdf_parser_parse_as_stream
***************
*** 99,103 ****
// librdf_parser_set_error
! public abstract void ParserSetError(RdfParser parser, ErrorFn
errorfn);
--- 99,103 ----
// librdf_parser_set_error
! // public abstract void ParserSetError(RdfParser parser,
ErrorFn errorfn);
***************
*** 112,120 ****
// librdf_parser_get_feature
! public abstract String Feature(RdfParser parser, RdfUri
feature);
// librdf_parser_set_feature
// return non-zero on failure ... negative if no such feature
! public abstract int Feature(RdfParser parser, RdfUri feature,
String value);
}
--- 112,120 ----
// librdf_parser_get_feature
! // public abstract String Feature(RdfParser parser, RdfUri
feature);
// librdf_parser_set_feature
// return non-zero on failure ... negative if no such feature
! // public abstract int Feature(RdfParser parser, RdfUri feature,
String value);
}
Index: RdfParser_N3.cs
===================================================================
RCS file: /cvsroot/dotgnu-libs/dotgnu.rdf/RdfParser_N3.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** RdfParser_N3.cs 16 Feb 2003 16:05:31 -0000 1.1
--- RdfParser_N3.cs 19 Jun 2003 20:16:07 -0000 1.2
***************
*** 627,631 ****
// librdf_parser_set_feature
// return non-zero on failure ... negative if no such feature
! public int Feature(RdfParser parser, RdfUri feature, String
value)
{
--- 627,631 ----
// librdf_parser_set_feature
// return non-zero on failure ... negative if no such feature
! public override int Feature(RdfParser parser, RdfUri feature,
String value)
{
Index: RdfTriple.cs
===================================================================
RCS file: /cvsroot/dotgnu-libs/dotgnu.rdf/RdfTriple.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** RdfTriple.cs 16 Feb 2003 16:05:31 -0000 1.2
--- RdfTriple.cs 19 Jun 2003 20:16:07 -0000 1.3
***************
*** 1685,1689 ****
}
TcpClient so = new
TcpClient(r.Host, r.Port == - 1?80:r.Port);
! so.NoDelay.Enabled = true;
StreamWriter pw = new
StreamWriter((Stream) so.GetStream());
pw.WriteLine("GET " + p + "
HTTP/1.0");
--- 1685,1691 ----
}
TcpClient so = new
TcpClient(r.Host, r.Port == - 1?80:r.Port);
!
! //TODO :so.NoDelay.Enabled =
true;
!
StreamWriter pw = new
StreamWriter((Stream) so.GetStream());
pw.WriteLine("GET " + p + "
HTTP/1.0");
Index: RdfWorld.cs
===================================================================
RCS file: /cvsroot/dotgnu-libs/dotgnu.rdf/RdfWorld.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** RdfWorld.cs 8 Feb 2003 18:35:07 -0000 1.1
--- RdfWorld.cs 19 Jun 2003 20:16:07 -0000 1.2
***************
*** 1,2 ****
--- 1,25 ----
+ /*
+ * RdfWorld.cs - Implementation of the "DotGNU.Rdf.World" class.
+ *
+ * Copyright (C) 2003 James Michael DuPont.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Thanks to Redland http://www.redland.opensource.ac.uk for the design
interface.
+ *
+ */
+
namespace DotGNU.Rdf
{
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Dotgnu-libs-commits] CVS: dotgnu.rdf DotGNU.Rdf.cwm.n3,NONE,1.1 DotGNU.Rdf.cwm.rdf,NONE,1.1 DotGNU.Rdf.dll,NONE,1.1 DotGNU.Rdf.il,NONE,1.1 DotGNU.Rdf.n3,NONE,1.1 DotGNU.Rdf.n3_clean,NONE,1.1 DotGNU.Rdf.n3_pure,NONE,1.1 DotGNU.Rdf.n3t,NONE,1.1 DotGNU.Rdf.rdf,NONE,1.1 DotGNURDF.WIKI,NONE,1.1 Makefile,NONE,1.1 api-update1.txt,NONE,1.1 api.txt,NONE,1.1 apt-update1.n3,NONE,1.1 apt-update1.rdf,NONE,1.1 apt-update1.txt,NONE,1.1 begin.html,NONE,1.1 build-stamp,NONE,1.1 configure-stamp,NONE,1.1 cs.files,NONE,1.1 docvs.sh,NONE,1.1 dotgnu.rdf.texi,NONE,1.1 dotgnu.rdf.xml,NONE,1.1 gmon.out,NONE,1.1 index.html,NONE,1.1 meeting.txt,NONE,1.1 namespaces.html,NONE,1.1 otherpredicates.txt,NONE,1.1 predicates.txt,NONE,1.1 test.log,NONE,1.1 test.n3,NONE,1.1 test2n3.pl,NONE,1.1 DotGNU.Rdf.build,1.9,1.10 RdfParser.cs,1.5,1.6 RdfParser_N3.cs,1.1,1.2 RdfTriple.cs,1.2,1.3 RdfWorld.cs,1.1,1.2,
James Michael DuPont <address@hidden> <=