001: /*
002: * Created on 21.09.2005
003: *
004: */
005: package org.ontoware.semversion.usecase.marcont;
006:
007: import static org.junit.Assert.assertNotNull;
008:
009: import java.io.File;
010: import java.util.List;
011:
012: import org.junit.Test;
013: import org.ontoware.rdf2go.impl.jena24.ModelImplJena24;
014: import org.ontoware.rdf2go.model.Diff;
015: import org.ontoware.rdf2go.model.Model;
016: import org.ontoware.rdf2go.model.Syntax;
017: import org.ontoware.rdf2go.model.impl.DiffImpl;
018: import org.ontoware.rdf2go.model.node.BlankNode;
019: import org.ontoware.rdf2go.model.node.URI;
020: import org.ontoware.rdf2go.model.node.impl.URIImpl;
021: import org.ontoware.rdf2go.util.ModelUtils;
022: import org.ontoware.semversion.SemVersion;
023: import org.ontoware.semversion.SemanticDiffEngine;
024: import org.ontoware.semversion.Session;
025: import org.ontoware.semversion.Version;
026: import org.ontoware.semversion.VersionedModel;
027:
028: import com.hp.hpl.jena.ontology.OntModel;
029: import com.hp.hpl.jena.ontology.OntModelSpec;
030: import com.hp.hpl.jena.rdf.model.ModelFactory;
031:
032: public class MarcOntUseCase {
033: @Test
034: public void testMarcOntUseCase() throws Exception {
035: SemVersion semVersion = new SemVersion();
036: semVersion.startup(new File("./target/test/MarcOntUseCase"));
037: semVersion.deleteStore();
038: semVersion.createUser("User a", "secret");
039: semVersion.createUser("User b", "secret");
040: semVersion.createUser("User c", "secret");
041: semVersion.createUser("User d", "secret");
042:
043: // -----------------------------------------------------------------------------------
044: // user A creates a Versioned Model and commits a first Version
045: // -----------------------------------------------------------------------------------
046:
047: // login to the SemVersion system
048: Session session1 = semVersion.login("User a", "secret");
049: // create a new VersionedModel
050: VersionedModel vm1 = session1
051: .createVersionedModel("MarcOnt 2005");
052: // get an empty Model where you can put your statements.
053: Model rootModel = session1.getModel();
054: // add your Statements into the model by calling
055: // model.addStatement(Object subject , URI predicate , Object object),
056: // model.addStatement(Object subject , URI predicate , String literal,
057: // String languageTag),
058: // or model.addStatement(Object subject, URI predicate, String literal,
059: // URI dataTypeURI).
060:
061: // commit the initial model
062: vm1.commitRoot(rootModel, "My first Version");
063:
064: // -----------------------------------------------------------------------------------
065: // User B commits a suggestion to this Versioned Model
066: // -----------------------------------------------------------------------------------
067:
068: // login to the SemVersion system
069: Session session2 = semVersion.login("User b", "secret");
070: // get the MarcOnt VersionedModel
071: VersionedModel vm2 = session2.getVersionedModel("MarcOnt 2005");
072: // get an empty Model where you can put your statements.
073: Model suggestion2 = session2.getModel();
074: // add your Statements into the model by calling
075: // model.addStatement(Object subject , URI predicate , Object object),
076: // model.addStatement(Object subject , URI predicate , String literal,
077: // String languageTag),
078: // or model.addStatement(Object subject, URI predicate, String literal,
079: // URI dataTypeURI).
080:
081: // commit the suggestion
082: vm2.getLastMainbranchVersion().commit(suggestion2,
083: "Suggestion of user b", true);
084:
085: // -----------------------------------------------------------------------------------
086: // User C commits a suggestion to this Versioned Model
087: // -----------------------------------------------------------------------------------
088:
089: // login to the SemVersion system
090: Session session3 = semVersion.login("User c", "secret");
091: // get the MarcOnt VersionedModel
092: VersionedModel vm3 = session3.getVersionedModel("MarcOnt 2005");
093: // get an empty Model where you can put your statements.
094: Model suggestion3 = session3.getModel();
095: // add your Statements into the model by calling
096: // model.addStatement(Object subject , URI predicate , Object object),
097: // model.addStatement(Object subject , URI predicate , String literal,
098: // String languageTag),
099: // or model.addStatement(Object subject, URI predicate, String literal,
100: // URI dataTypeURI).
101:
102: // commit the suggestion
103: vm3.getLastMainbranchVersion().commit(suggestion3,
104: "Suggestion of user c", true);
105:
106: // -----------------------------------------------------------------------------------
107: // User D commits a suggestion to this Versioned Model
108: // -----------------------------------------------------------------------------------
109:
110: // login to the SemVersion system
111: Session session4 = semVersion.login("User d", "secret");
112: // get the MarcOnt VersionedModel
113: VersionedModel vm4 = session4.getVersionedModel("MarcOnt 2005");
114: // get an empty Model where you can put your statements.
115: Model suggestion4 = session4.getModel();
116: // add your Statements into the model by calling
117: // model.addStatement(Object subject , URI predicate , Object object),
118: // model.addStatement(Object subject , URI predicate , String literal,
119: // String languageTag),
120: // or model.addStatement(Object subject, URI predicate, String literal,
121: // URI dataTypeURI).
122:
123: // commit the suggestion
124: vm4.getLastMainbranchVersion().commit(suggestion4,
125: "Suggestion of user d", true);
126:
127: // -----------------------------------------------------------------------------------
128: // User A accepts the Suggestion of User C
129: // -----------------------------------------------------------------------------------
130:
131: // login to the SemVersion system
132: Session session5 = semVersion.login("User a", "secret");
133: // get the MarcOnt VersionedModel
134: VersionedModel vm5 = session5.getVersionedModel("MarcOnt 2005");
135: // get a list of all versions in this Versioned Model
136: List<Version> allVersions = vm5.getLastMainbranchVersion()
137: .getSuggestions();
138: for (Version version : allVersions) {
139: // accept the Suggestion of User c
140: if (version.getUser().equals("User c"))
141: version.setAsRelease();
142: }
143:
144: // -----------------------------------------------------------------------------------
145: // User B commits another Suggestion as a diff to the most recent
146: // version
147: // -----------------------------------------------------------------------------------
148:
149: // login to the SemVersion system
150: Session session6 = semVersion.login("User b", "secret");
151: // get the MarcOnt VersionedModel
152: VersionedModel vm6 = session6.getVersionedModel("MarcOnt 2005");
153: // create Models with added and removed statements for diff
154: Model added = session6.getModel();
155: Model removed = session6.getModel();
156: // add your Statements into theses models by calling
157: // model.addStatement(Object subject , URI predicate , Object object),
158: // model.addStatement(Object subject , URI predicate , String literal,
159: // String languageTag),
160: // or model.addStatement(Object subject, URI predicate, String literal,
161: // URI dataTypeURI).
162:
163: Diff diff = new DiffImpl(added.iterator(), removed.iterator());
164: // commit the diff
165: vm6.getLastMainbranchVersion().commit(diff,
166: "Another suggestion",
167: new URIImpl("data://suggestion6"), null, true);
168:
169: // -----------------------------------------------------------------------------------
170: // User A wants to see the differences between the first version and the
171: // latest version
172: // -----------------------------------------------------------------------------------
173:
174: // login to the SemVersion system
175: Session session7 = semVersion.login("User a", "secret");
176: // get the MarcOnt VersionedModel
177: VersionedModel vm7 = session7.getVersionedModel("MarcOnt 2005");
178: // calculate the semantic diff of the root Version and the latest
179: // main-branch version
180: Diff diff2 = SemanticDiffEngine.getSemanticDiff_RDFS(vm7
181: .getRoot().getContent(), vm7.getLastMainbranchVersion()
182: .getContent());
183: // Print out all added Statements
184: diff2.dump();
185: semVersion.shutdown();
186:
187: }
188:
189: @Test
190: public void testJenaConversion() throws Exception {
191: // create a Jena Model
192: com.hp.hpl.jena.rdf.model.Model jenaModel = ModelFactory
193: .createDefaultModel();
194:
195: // for ease of use, wrap it in an RDF2Go model
196: Model jenaModelAsRdf2Go = new ModelImplJena24(jenaModel);
197: jenaModelAsRdf2Go.open();
198:
199: // add statements with blank nodes
200: URI u1 = new URIImpl("urn:test:u1");
201: URI u2 = new URIImpl("urn:test:u2");
202: URI u3 = new URIImpl("urn:test:u3");
203: BlankNode b1 = jenaModelAsRdf2Go.createBlankNode();
204: BlankNode b2 = jenaModelAsRdf2Go.createBlankNode();
205: jenaModelAsRdf2Go.addStatement(u1, u2, b1);
206: jenaModelAsRdf2Go.addStatement(u1, u3, b2);
207:
208: // dump to system out
209: jenaModelAsRdf2Go.writeTo(System.out, Syntax.Ntriples);
210:
211: // wrap jenaModel as jenaOntModel
212: OntModel ontModel = ModelFactory.createOntologyModel(
213: OntModelSpec.OWL_DL_MEM, jenaModel);
214:
215: // wrap ontmodel in RDF2Go
216: Model ontModelAsRDF2Go = new ModelImplJena24(ontModel);
217: ontModelAsRDF2Go.open();
218:
219: // dump ontmodelAsRDF2Go
220: ontModelAsRDF2Go.writeTo(System.out, Syntax.Ntriples);
221:
222: // /////////// now try to store it in semversion
223: SemVersion sv = new SemVersion();
224: sv.startup(new File("./target/test"));
225: sv.clear();
226: Session session = sv.createAnonymousSession();
227: VersionedModel vm = session.createVersionedModel("test");
228: assertNotNull(vm);
229: Model semversionModel = session.getModel();
230: ModelUtils.copy(ontModelAsRDF2Go, semversionModel);
231: vm.commitRoot(semversionModel, "root");
232: session.close();
233:
234: // load from semversion
235: session = sv.createAnonymousSession();
236: vm = session.getVersionedModel("test");
237: Model fromSemversion = vm.getRoot().getContent();
238: // dump retrieved content
239: fromSemversion.writeTo(System.out, Syntax.Ntriples);
240: // create a new Jena Model
241:
242: // create a Jena Model
243: com.hp.hpl.jena.rdf.model.Model secondJenaModel = ModelFactory
244: .createOntologyModel(OntModelSpec.OWL_DL_MEM);
245:
246: // for ease of use, wrap it in an RDF2Go model
247: Model secondJenaModelAsRdf2Go = new ModelImplJena24(
248: secondJenaModel);
249: secondJenaModelAsRdf2Go.open();
250:
251: ModelUtils.copy(fromSemversion, secondJenaModelAsRdf2Go);
252: session.close();
253:
254: fromSemversion.close();
255: ontModelAsRDF2Go.close();
256: jenaModelAsRdf2Go.close();
257:
258: secondJenaModelAsRdf2Go.writeTo(System.out, Syntax.Ntriples);
259: secondJenaModelAsRdf2Go.close();
260: sv.shutdown();
261: }
262:
263: }
|