001    package eu.lod2.nlp2rdf.schema.sso;
002    
003    import java.util.ArrayList;
004    import java.util.List;
005    import java.util.Iterator;
006    
007    import nl.tudelft.tbm.eeni.owl2java.model.jenautils.NullFilter;
008    
009    import org.apache.commons.logging.Log;
010    import org.apache.commons.logging.LogFactory;
011    
012    import com.hp.hpl.jena.enhanced.BuiltinPersonalities;
013    import com.hp.hpl.jena.enhanced.EnhGraph;
014    import com.hp.hpl.jena.enhanced.EnhNode;
015    import com.hp.hpl.jena.enhanced.Implementation;
016    import com.hp.hpl.jena.graph.Graph;
017    import com.hp.hpl.jena.graph.Node;
018    import com.hp.hpl.jena.ontology.Individual;
019    import com.hp.hpl.jena.ontology.OntClass;
020    import com.hp.hpl.jena.ontology.OntModel;
021    import com.hp.hpl.jena.ontology.Profile;
022    import com.hp.hpl.jena.ontology.impl.IndividualImpl;
023    import com.hp.hpl.jena.rdf.model.Resource;
024    import com.hp.hpl.jena.rdf.model.RDFNode;
025    import com.hp.hpl.jena.rdf.model.Statement;
026    import com.hp.hpl.jena.rdf.model.Literal;
027    import com.hp.hpl.jena.util.iterator.WrappedIterator;
028    import com.hp.hpl.jena.util.iterator.ExtendedIterator;
029    import com.hp.hpl.jena.util.iterator.Filter;
030    import com.hp.hpl.jena.util.iterator.Map1;
031    
032    // import interface
033    import eu.lod2.nlp2rdf.schema.sso.IStopWord;
034    
035    /**
036     * Class http://nlp2rdf.lod2.eu/schema/sso/StopWord
037     */
038    public class StopWord extends IndividualImpl implements IStopWord {
039    
040            private static Log log = LogFactory.getLog(StopWord.class);
041    
042            /**
043             * Implementation factory for StopWord
044             */
045            static final public Implementation factory = new Implementation() {
046    
047                    /**
048                     * Convert a Node into an instance of the class
049                     */
050                    public EnhNode wrap(Node n, EnhGraph eg) {
051                            if (canWrap(n, eg)) {
052                                    return new StopWord(n, eg);
053                            } else {
054                                    log.warn("Cannot convert node " + n.toString() + " to  StopWord");
055                                    return null;
056                            }
057                    }
058    
059                    /**
060                     * Return true iff the node can be converted to an instance of
061                     * this class (StopWord)
062                     */
063                    public boolean canWrap(Node n, EnhGraph eg) {
064                            Profile profile;
065                            if (eg instanceof OntModel)
066                                    profile = ((OntModel) eg).getProfile();
067                            else
068                                    return false;
069    
070                            if (!profile.isSupported(n, eg, Individual.class)) {
071                                    return false;
072                            }
073    
074                            Graph graph = eg.asGraph();
075                            return graph.contains(n, com.hp.hpl.jena.vocabulary.RDF.type.asNode(), eu.lod2.nlp2rdf.schema.tools.Vocabulary.StopWord.asNode());
076                    }
077            };
078    
079            /**
080             * Filtering support for StopWord
081             */
082            static final public Filter<StopWord> nullFilter = new NullFilter<StopWord>();
083    
084            /**
085             * Mapping support for StopWord
086             */
087            public static <From> Map1<From, StopWord> mapperFrom(Class<From> from) {
088                    return new Map1<From, StopWord>() {
089                            @Override
090                            public StopWord map1(Object x) {
091                                    if (x instanceof Statement) {
092                                            Resource r = ((Statement) x).getResource();
093                                            if (r.canAs(StopWord.class))
094                                                    return r.as(StopWord.class);
095                                    } else if (x instanceof RDFNode) {
096                                            if (((RDFNode) x).canAs(StopWord.class))
097                                                    return ((RDFNode) x).as(StopWord.class);
098                                    }
099                                    return null;
100                            }
101                    };
102            }
103    
104            // Instantiate some mappers for general use
105            static final public Map1<Statement, StopWord> statementMapper = mapperFrom(Statement.class);
106            static final public Map1<Individual, StopWord> individualMapper = mapperFrom(Individual.class);
107            static final public Map1<RDFNode, StopWord> nodeMapper = mapperFrom(RDFNode.class);
108    
109            /**
110             * Generic functions from parent class
111             */
112            public StopWord(Node n, EnhGraph g) {
113                    super(n, g);
114            }
115    
116            /**
117             * Registers all custom classes with jena
118             */
119            public static void register() {
120                    log.debug("Registering custom class StopWord with jena");
121                    BuiltinPersonalities.model.add(StopWord.class, StopWord.factory);
122                    BuiltinPersonalities.model.add(eu.lod2.nlp2rdf.schema.sso.StopWord.class, StopWord.factory);
123            }
124    
125            /**
126             * Static Functions for instance handling
127             */
128            public static StopWord get(java.lang.String uri, OntModel ontModel) {
129                    Individual individual = ontModel.getIndividual(uri);
130                    return (eu.lod2.nlp2rdf.schema.sso.StopWord) individual.as(eu.lod2.nlp2rdf.schema.sso.StopWord.class);
131            }
132    
133            public static StopWord get(java.lang.String uri) {
134                    return get(uri, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
135            }
136    
137            public static Iterator<StopWord> iterate(OntModel ontModel) {
138                    ExtendedIterator<Individual> it = ontModel.listIndividuals(eu.lod2.nlp2rdf.schema.tools.Vocabulary.StopWord);
139                    return it.mapWith(individualMapper).filterDrop(nullFilter);
140            }
141    
142            public static Iterator<StopWord> iterate() {
143                    return iterate(eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
144            }
145    
146            public static List<StopWord> list(OntModel ontModel) {
147                    List<StopWord> list = new ArrayList<StopWord>();
148                    Iterator<StopWord> it = iterate(ontModel);
149                    while (it.hasNext()) {
150                            StopWord cls = it.next();
151                            list.add(cls);
152                    }
153                    return list;
154            }
155    
156            public static List<StopWord> list() {
157                    return list(eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
158            }
159    
160            public static Iterator<StopWord> iterate(boolean direct, OntModel ontModel) {
161                    OntClass cls = ontModel.getOntClass("http://nlp2rdf.lod2.eu/schema/sso/StopWord");
162                    ExtendedIterator<? extends RDFNode> it = cls.listInstances(direct);
163                    ExtendedIterator<RDFNode> nodeIt = new WrappedIterator<RDFNode>(it) {
164                    };
165                    return nodeIt.mapWith(nodeMapper).filterDrop(nullFilter);
166            }
167    
168            public static Iterator<StopWord> iterate(boolean direct) {
169                    return iterate(direct, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
170            }
171    
172            public static List<StopWord> list(boolean direct, OntModel ontModel) {
173                    List<StopWord> list = new ArrayList<StopWord>();
174                    Iterator<StopWord> it = iterate(direct, ontModel);
175                    while (it.hasNext()) {
176                            StopWord cls = it.next();
177                            list.add(cls);
178                    }
179                    return list;
180            }
181    
182            public static List<StopWord> list(boolean direct) {
183                    return list(direct, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
184            }
185    
186            public static int count(OntModel ontModel) {
187                    int count = 0;
188                    Iterator<StopWord> it = iterate(ontModel);
189                    while (it.hasNext()) {
190                            it.next();
191                            count++;
192                    }
193                    return count;
194            }
195    
196            public static int count() {
197                    return count(eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
198            }
199    
200            public static int count(boolean direct, OntModel ontModel) {
201                    int count = 0;
202                    Iterator<StopWord> it = iterate(direct, ontModel);
203                    while (it.hasNext()) {
204                            it.next();
205                            count++;
206                    }
207                    return count;
208            }
209    
210            public static int count(boolean direct) {
211                    return count(direct, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
212            }
213    
214            public static boolean exists(java.lang.String uri, OntModel ontModel) {
215                    Individual individual = ontModel.getIndividual(uri);
216                    if (individual != null)
217                            return true;
218                    return false;
219            }
220    
221            public static boolean exists(java.lang.String uri) {
222                    return exists(uri, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
223            }
224    
225            public static StopWord create(java.lang.String uri, OntModel ontModel) {
226                    return (StopWord) ontModel.createOntResource(StopWord.class, eu.lod2.nlp2rdf.schema.tools.Vocabulary.StopWord, uri);
227            }
228    
229            public static StopWord create(OntModel ontModel) {
230                    return create(null, ontModel);
231            }
232    
233            public static StopWord create(java.lang.String uri) {
234                    return create(uri, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
235            }
236    
237            public static StopWord create() {
238                    return create(null, eu.lod2.nlp2rdf.schema.tools.Factory.getDefaultModel());
239            }
240    
241            public static void delete(java.lang.String uri, OntModel ontModel) {
242                    eu.lod2.nlp2rdf.schema.tools.Factory.deleteInstance(uri, ontModel);
243            }
244    
245            public static void delete(java.lang.String uri) {
246                    eu.lod2.nlp2rdf.schema.tools.Factory.deleteInstance(uri);
247            }
248    
249            /**
250             * Domain property sentence
251             * with uri http://nlp2rdf.lod2.eu/schema/sso/sentence
252             */
253            public boolean existsSentence() {
254                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence);
255            }
256    
257            public boolean hasSentence(eu.lod2.nlp2rdf.schema.sso.ISentence sentenceValue) {
258                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence, sentenceValue);
259            }
260    
261            public eu.lod2.nlp2rdf.schema.sso.Sentence getSentence() {
262                    RDFNode n = getPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence);
263                    if (n.canAs(eu.lod2.nlp2rdf.schema.sso.Sentence.class))
264                            return (eu.lod2.nlp2rdf.schema.sso.Sentence) n.as(eu.lod2.nlp2rdf.schema.sso.Sentence.class);
265                    else {
266                            log.warn("Could not convert sentence of " + getURI() + " (" + n + ") to type Sentence");
267                            return null;
268                    }
269            }
270    
271            public void setSentence(eu.lod2.nlp2rdf.schema.sso.ISentence sentenceValue) {
272                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence);
273                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence, sentenceValue);
274            }
275    
276            public void removeSentence() {
277                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.sentence);
278            }
279    
280            /**
281             * Domain property oliaLink
282             * with uri http://nlp2rdf.lod2.eu/schema/sso/oliaLink
283             */
284            public boolean existsOliaLink() {
285                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink);
286            }
287    
288            public boolean hasOliaLink(eu.lod2.nlp2rdf.schema.IThing thingValue) {
289                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink, thingValue);
290            }
291    
292            public int countOliaLink() {
293                    int count = 0;
294                    Iterator<eu.lod2.nlp2rdf.schema.Thing> it = iterateOliaLink();
295                    while (it.hasNext()) {
296                            it.next();
297                            count++;
298                    }
299                    return count;
300            }
301    
302            public Iterator<eu.lod2.nlp2rdf.schema.Thing> iterateOliaLink() {
303                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink);
304                    return it.mapWith(eu.lod2.nlp2rdf.schema.Thing.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.Thing.nullFilter);
305            }
306    
307            public List<eu.lod2.nlp2rdf.schema.Thing> listOliaLink() {
308                    List<eu.lod2.nlp2rdf.schema.Thing> list = new ArrayList<eu.lod2.nlp2rdf.schema.Thing>();
309                    Iterator<eu.lod2.nlp2rdf.schema.Thing> it = iterateOliaLink();
310                    while (it.hasNext()) {
311                            eu.lod2.nlp2rdf.schema.Thing inst = it.next();
312                            list.add(inst);
313                    }
314                    return list;
315            }
316    
317            public void addOliaLink(eu.lod2.nlp2rdf.schema.IThing thingValue) {
318                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink, thingValue);
319            }
320    
321            public void addAllOliaLink(List<? extends eu.lod2.nlp2rdf.schema.IThing> thingList) {
322                    for (eu.lod2.nlp2rdf.schema.IThing o : thingList)
323                            addOliaLink(o);
324    
325            }
326    
327            public void removeOliaLink(eu.lod2.nlp2rdf.schema.IThing thingValue) {
328                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink, thingValue);
329            }
330    
331            public void removeAllOliaLink() {
332                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.oliaLink);
333            }
334    
335            /**
336             * Domain property previousWord
337             * with uri http://nlp2rdf.lod2.eu/schema/sso/previousWord
338             */
339            public boolean existsPreviousWord() {
340                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord);
341            }
342    
343            public boolean hasPreviousWord(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
344                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord, wordValue);
345            }
346    
347            public eu.lod2.nlp2rdf.schema.sso.Word getPreviousWord() {
348                    RDFNode n = getPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord);
349                    if (n.canAs(eu.lod2.nlp2rdf.schema.sso.Word.class))
350                            return (eu.lod2.nlp2rdf.schema.sso.Word) n.as(eu.lod2.nlp2rdf.schema.sso.Word.class);
351                    else {
352                            log.warn("Could not convert previousWord of " + getURI() + " (" + n + ") to type Word");
353                            return null;
354                    }
355            }
356    
357            public void setPreviousWord(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
358                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord);
359                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord, wordValue);
360            }
361    
362            public void removePreviousWord() {
363                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWord);
364            }
365    
366            /**
367             * Domain property nextWord
368             * with uri http://nlp2rdf.lod2.eu/schema/sso/nextWord
369             */
370            public boolean existsNextWord() {
371                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord);
372            }
373    
374            public boolean hasNextWord(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
375                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord, wordValue);
376            }
377    
378            public eu.lod2.nlp2rdf.schema.sso.Word getNextWord() {
379                    RDFNode n = getPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord);
380                    if (n.canAs(eu.lod2.nlp2rdf.schema.sso.Word.class))
381                            return (eu.lod2.nlp2rdf.schema.sso.Word) n.as(eu.lod2.nlp2rdf.schema.sso.Word.class);
382                    else {
383                            log.warn("Could not convert nextWord of " + getURI() + " (" + n + ") to type Word");
384                            return null;
385                    }
386            }
387    
388            public void setNextWord(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
389                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord);
390                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord, wordValue);
391            }
392    
393            public void removeNextWord() {
394                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWord);
395            }
396    
397            /**
398             * Domain property nextSentenceTrans
399             * with uri http://nlp2rdf.lod2.eu/schema/sso/nextSentenceTrans
400             */
401            public boolean existsNextSentenceTrans() {
402                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans);
403            }
404    
405            public boolean hasNextSentenceTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
406                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans, wordValue);
407            }
408    
409            public int countNextSentenceTrans() {
410                    int count = 0;
411                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iterateNextSentenceTrans();
412                    while (it.hasNext()) {
413                            it.next();
414                            count++;
415                    }
416                    return count;
417            }
418    
419            public Iterator<eu.lod2.nlp2rdf.schema.sso.Word> iterateNextSentenceTrans() {
420                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans);
421                    return it.mapWith(eu.lod2.nlp2rdf.schema.sso.Word.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.sso.Word.nullFilter);
422            }
423    
424            public List<eu.lod2.nlp2rdf.schema.sso.Word> listNextSentenceTrans() {
425                    List<eu.lod2.nlp2rdf.schema.sso.Word> list = new ArrayList<eu.lod2.nlp2rdf.schema.sso.Word>();
426                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iterateNextSentenceTrans();
427                    while (it.hasNext()) {
428                            eu.lod2.nlp2rdf.schema.sso.Word inst = it.next();
429                            list.add(inst);
430                    }
431                    return list;
432            }
433    
434            public void addNextSentenceTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
435                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans, wordValue);
436            }
437    
438            public void addAllNextSentenceTrans(List<? extends eu.lod2.nlp2rdf.schema.sso.IWord> wordList) {
439                    for (eu.lod2.nlp2rdf.schema.sso.IWord o : wordList)
440                            addNextSentenceTrans(o);
441    
442            }
443    
444            public void removeNextSentenceTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
445                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans, wordValue);
446            }
447    
448            public void removeAllNextSentenceTrans() {
449                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextSentenceTrans);
450            }
451    
452            /**
453             * Domain property previousWordTrans
454             * with uri http://nlp2rdf.lod2.eu/schema/sso/previousWordTrans
455             */
456            public boolean existsPreviousWordTrans() {
457                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans);
458            }
459    
460            public boolean hasPreviousWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
461                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans, wordValue);
462            }
463    
464            public int countPreviousWordTrans() {
465                    int count = 0;
466                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iteratePreviousWordTrans();
467                    while (it.hasNext()) {
468                            it.next();
469                            count++;
470                    }
471                    return count;
472            }
473    
474            public Iterator<eu.lod2.nlp2rdf.schema.sso.Word> iteratePreviousWordTrans() {
475                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans);
476                    return it.mapWith(eu.lod2.nlp2rdf.schema.sso.Word.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.sso.Word.nullFilter);
477            }
478    
479            public List<eu.lod2.nlp2rdf.schema.sso.Word> listPreviousWordTrans() {
480                    List<eu.lod2.nlp2rdf.schema.sso.Word> list = new ArrayList<eu.lod2.nlp2rdf.schema.sso.Word>();
481                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iteratePreviousWordTrans();
482                    while (it.hasNext()) {
483                            eu.lod2.nlp2rdf.schema.sso.Word inst = it.next();
484                            list.add(inst);
485                    }
486                    return list;
487            }
488    
489            public void addPreviousWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
490                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans, wordValue);
491            }
492    
493            public void addAllPreviousWordTrans(List<? extends eu.lod2.nlp2rdf.schema.sso.IWord> wordList) {
494                    for (eu.lod2.nlp2rdf.schema.sso.IWord o : wordList)
495                            addPreviousWordTrans(o);
496    
497            }
498    
499            public void removePreviousWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
500                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans, wordValue);
501            }
502    
503            public void removeAllPreviousWordTrans() {
504                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.previousWordTrans);
505            }
506    
507            /**
508             * Domain property nextWordTrans
509             * with uri http://nlp2rdf.lod2.eu/schema/sso/nextWordTrans
510             */
511            public boolean existsNextWordTrans() {
512                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans);
513            }
514    
515            public boolean hasNextWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
516                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans, wordValue);
517            }
518    
519            public int countNextWordTrans() {
520                    int count = 0;
521                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iterateNextWordTrans();
522                    while (it.hasNext()) {
523                            it.next();
524                            count++;
525                    }
526                    return count;
527            }
528    
529            public Iterator<eu.lod2.nlp2rdf.schema.sso.Word> iterateNextWordTrans() {
530                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans);
531                    return it.mapWith(eu.lod2.nlp2rdf.schema.sso.Word.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.sso.Word.nullFilter);
532            }
533    
534            public List<eu.lod2.nlp2rdf.schema.sso.Word> listNextWordTrans() {
535                    List<eu.lod2.nlp2rdf.schema.sso.Word> list = new ArrayList<eu.lod2.nlp2rdf.schema.sso.Word>();
536                    Iterator<eu.lod2.nlp2rdf.schema.sso.Word> it = iterateNextWordTrans();
537                    while (it.hasNext()) {
538                            eu.lod2.nlp2rdf.schema.sso.Word inst = it.next();
539                            list.add(inst);
540                    }
541                    return list;
542            }
543    
544            public void addNextWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
545                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans, wordValue);
546            }
547    
548            public void addAllNextWordTrans(List<? extends eu.lod2.nlp2rdf.schema.sso.IWord> wordList) {
549                    for (eu.lod2.nlp2rdf.schema.sso.IWord o : wordList)
550                            addNextWordTrans(o);
551    
552            }
553    
554            public void removeNextWordTrans(eu.lod2.nlp2rdf.schema.sso.IWord wordValue) {
555                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans, wordValue);
556            }
557    
558            public void removeAllNextWordTrans() {
559                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.nextWordTrans);
560            }
561    
562            /**
563             * Domain property posTag
564             * with uri http://nlp2rdf.lod2.eu/schema/sso/posTag
565             */
566            public boolean existsPosTag() {
567                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag);
568            }
569    
570            public boolean hasPosTag(java.lang.String stringValue) {
571                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag);
572            }
573    
574            public int countPosTag() {
575                    int count = 0;
576                    Iterator<java.lang.String> it = iteratePosTag();
577                    while (it.hasNext()) {
578                            it.next();
579                            count++;
580                    }
581                    return count;
582            }
583    
584            public Iterator<java.lang.String> iteratePosTag() {
585                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag);
586                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
587            }
588    
589            public List<java.lang.String> listPosTag() {
590                    List<java.lang.String> list = new ArrayList<java.lang.String>();
591                    Iterator<java.lang.String> it = iteratePosTag();
592                    while (it.hasNext()) {
593                            java.lang.String inst = it.next();
594                            list.add(inst);
595                    }
596                    return list;
597            }
598    
599            public void addPosTag(java.lang.String stringValue) {
600                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
601                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag, literal);
602            }
603    
604            public void addAllPosTag(List<java.lang.String> stringList) {
605                    for (java.lang.String o : stringList)
606                            addPosTag(o);
607            }
608    
609            public void removePosTag(java.lang.String stringValue) {
610                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
611                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag, literal);
612            }
613    
614            public void removeAllPosTag() {
615                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.posTag);
616    
617            }
618    
619            /**
620             * Domain property lemma
621             * with uri http://nlp2rdf.lod2.eu/schema/sso/lemma
622             */
623            public boolean existsLemma() {
624                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma);
625            }
626    
627            public boolean hasLemma(java.lang.String stringValue) {
628                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma);
629            }
630    
631            public int countLemma() {
632                    int count = 0;
633                    Iterator<java.lang.String> it = iterateLemma();
634                    while (it.hasNext()) {
635                            it.next();
636                            count++;
637                    }
638                    return count;
639            }
640    
641            public Iterator<java.lang.String> iterateLemma() {
642                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma);
643                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
644            }
645    
646            public List<java.lang.String> listLemma() {
647                    List<java.lang.String> list = new ArrayList<java.lang.String>();
648                    Iterator<java.lang.String> it = iterateLemma();
649                    while (it.hasNext()) {
650                            java.lang.String inst = it.next();
651                            list.add(inst);
652                    }
653                    return list;
654            }
655    
656            public void addLemma(java.lang.String stringValue) {
657                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
658                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma, literal);
659            }
660    
661            public void addAllLemma(List<java.lang.String> stringList) {
662                    for (java.lang.String o : stringList)
663                            addLemma(o);
664            }
665    
666            public void removeLemma(java.lang.String stringValue) {
667                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
668                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma, literal);
669            }
670    
671            public void removeAllLemma() {
672                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.lemma);
673    
674            }
675    
676            /**
677             * Domain property stem
678             * with uri http://nlp2rdf.lod2.eu/schema/sso/stem
679             */
680            public boolean existsStem() {
681                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem);
682            }
683    
684            public boolean hasStem(java.lang.String stringValue) {
685                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem);
686            }
687    
688            public int countStem() {
689                    int count = 0;
690                    Iterator<java.lang.String> it = iterateStem();
691                    while (it.hasNext()) {
692                            it.next();
693                            count++;
694                    }
695                    return count;
696            }
697    
698            public Iterator<java.lang.String> iterateStem() {
699                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem);
700                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
701            }
702    
703            public List<java.lang.String> listStem() {
704                    List<java.lang.String> list = new ArrayList<java.lang.String>();
705                    Iterator<java.lang.String> it = iterateStem();
706                    while (it.hasNext()) {
707                            java.lang.String inst = it.next();
708                            list.add(inst);
709                    }
710                    return list;
711            }
712    
713            public void addStem(java.lang.String stringValue) {
714                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
715                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem, literal);
716            }
717    
718            public void addAllStem(List<java.lang.String> stringList) {
719                    for (java.lang.String o : stringList)
720                            addStem(o);
721            }
722    
723            public void removeStem(java.lang.String stringValue) {
724                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
725                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem, literal);
726            }
727    
728            public void removeAllStem() {
729                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.stem);
730    
731            }
732    
733            /**
734             * Domain property superString
735             * with uri http://nlp2rdf.lod2.eu/schema/string/superString
736             */
737            public boolean existsSuperString() {
738                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString);
739            }
740    
741            public boolean hasSuperString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
742                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString, stringValue);
743            }
744    
745            public int countSuperString() {
746                    int count = 0;
747                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSuperString();
748                    while (it.hasNext()) {
749                            it.next();
750                            count++;
751                    }
752                    return count;
753            }
754    
755            public Iterator<eu.lod2.nlp2rdf.schema.str.String> iterateSuperString() {
756                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString);
757                    return it.mapWith(eu.lod2.nlp2rdf.schema.str.String.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.str.String.nullFilter);
758            }
759    
760            public List<eu.lod2.nlp2rdf.schema.str.String> listSuperString() {
761                    List<eu.lod2.nlp2rdf.schema.str.String> list = new ArrayList<eu.lod2.nlp2rdf.schema.str.String>();
762                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSuperString();
763                    while (it.hasNext()) {
764                            eu.lod2.nlp2rdf.schema.str.String inst = it.next();
765                            list.add(inst);
766                    }
767                    return list;
768            }
769    
770            public void addSuperString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
771                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString, stringValue);
772            }
773    
774            public void addAllSuperString(List<? extends eu.lod2.nlp2rdf.schema.str.IString> stringList) {
775                    for (eu.lod2.nlp2rdf.schema.str.IString o : stringList)
776                            addSuperString(o);
777    
778            }
779    
780            public void removeSuperString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
781                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString, stringValue);
782            }
783    
784            public void removeAllSuperString() {
785                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superString);
786            }
787    
788            /**
789             * Domain property subString
790             * with uri http://nlp2rdf.lod2.eu/schema/string/subString
791             */
792            public boolean existsSubString() {
793                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString);
794            }
795    
796            public boolean hasSubString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
797                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString, stringValue);
798            }
799    
800            public int countSubString() {
801                    int count = 0;
802                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSubString();
803                    while (it.hasNext()) {
804                            it.next();
805                            count++;
806                    }
807                    return count;
808            }
809    
810            public Iterator<eu.lod2.nlp2rdf.schema.str.String> iterateSubString() {
811                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString);
812                    return it.mapWith(eu.lod2.nlp2rdf.schema.str.String.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.str.String.nullFilter);
813            }
814    
815            public List<eu.lod2.nlp2rdf.schema.str.String> listSubString() {
816                    List<eu.lod2.nlp2rdf.schema.str.String> list = new ArrayList<eu.lod2.nlp2rdf.schema.str.String>();
817                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSubString();
818                    while (it.hasNext()) {
819                            eu.lod2.nlp2rdf.schema.str.String inst = it.next();
820                            list.add(inst);
821                    }
822                    return list;
823            }
824    
825            public void addSubString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
826                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString, stringValue);
827            }
828    
829            public void addAllSubString(List<? extends eu.lod2.nlp2rdf.schema.str.IString> stringList) {
830                    for (eu.lod2.nlp2rdf.schema.str.IString o : stringList)
831                            addSubString(o);
832    
833            }
834    
835            public void removeSubString(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
836                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString, stringValue);
837            }
838    
839            public void removeAllSubString() {
840                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subString);
841            }
842    
843            /**
844             * Domain property superStringTrans
845             * with uri http://nlp2rdf.lod2.eu/schema/string/superStringTrans
846             */
847            public boolean existsSuperStringTrans() {
848                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans);
849            }
850    
851            public boolean hasSuperStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
852                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans, stringValue);
853            }
854    
855            public int countSuperStringTrans() {
856                    int count = 0;
857                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSuperStringTrans();
858                    while (it.hasNext()) {
859                            it.next();
860                            count++;
861                    }
862                    return count;
863            }
864    
865            public Iterator<eu.lod2.nlp2rdf.schema.str.String> iterateSuperStringTrans() {
866                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans);
867                    return it.mapWith(eu.lod2.nlp2rdf.schema.str.String.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.str.String.nullFilter);
868            }
869    
870            public List<eu.lod2.nlp2rdf.schema.str.String> listSuperStringTrans() {
871                    List<eu.lod2.nlp2rdf.schema.str.String> list = new ArrayList<eu.lod2.nlp2rdf.schema.str.String>();
872                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSuperStringTrans();
873                    while (it.hasNext()) {
874                            eu.lod2.nlp2rdf.schema.str.String inst = it.next();
875                            list.add(inst);
876                    }
877                    return list;
878            }
879    
880            public void addSuperStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
881                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans, stringValue);
882            }
883    
884            public void addAllSuperStringTrans(List<? extends eu.lod2.nlp2rdf.schema.str.IString> stringList) {
885                    for (eu.lod2.nlp2rdf.schema.str.IString o : stringList)
886                            addSuperStringTrans(o);
887    
888            }
889    
890            public void removeSuperStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
891                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans, stringValue);
892            }
893    
894            public void removeAllSuperStringTrans() {
895                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.superStringTrans);
896            }
897    
898            /**
899             * Domain property subStringTrans
900             * with uri http://nlp2rdf.lod2.eu/schema/string/subStringTrans
901             */
902            public boolean existsSubStringTrans() {
903                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans);
904            }
905    
906            public boolean hasSubStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
907                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans, stringValue);
908            }
909    
910            public int countSubStringTrans() {
911                    int count = 0;
912                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSubStringTrans();
913                    while (it.hasNext()) {
914                            it.next();
915                            count++;
916                    }
917                    return count;
918            }
919    
920            public Iterator<eu.lod2.nlp2rdf.schema.str.String> iterateSubStringTrans() {
921                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans);
922                    return it.mapWith(eu.lod2.nlp2rdf.schema.str.String.statementMapper).filterDrop(eu.lod2.nlp2rdf.schema.str.String.nullFilter);
923            }
924    
925            public List<eu.lod2.nlp2rdf.schema.str.String> listSubStringTrans() {
926                    List<eu.lod2.nlp2rdf.schema.str.String> list = new ArrayList<eu.lod2.nlp2rdf.schema.str.String>();
927                    Iterator<eu.lod2.nlp2rdf.schema.str.String> it = iterateSubStringTrans();
928                    while (it.hasNext()) {
929                            eu.lod2.nlp2rdf.schema.str.String inst = it.next();
930                            list.add(inst);
931                    }
932                    return list;
933            }
934    
935            public void addSubStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
936                    addProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans, stringValue);
937            }
938    
939            public void addAllSubStringTrans(List<? extends eu.lod2.nlp2rdf.schema.str.IString> stringList) {
940                    for (eu.lod2.nlp2rdf.schema.str.IString o : stringList)
941                            addSubStringTrans(o);
942    
943            }
944    
945            public void removeSubStringTrans(eu.lod2.nlp2rdf.schema.str.IString stringValue) {
946                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans, stringValue);
947            }
948    
949            public void removeAllSubStringTrans() {
950                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.subStringTrans);
951            }
952    
953            /**
954             * Domain property anchorOf
955             * with uri http://nlp2rdf.lod2.eu/schema/string/anchorOf
956             */
957            public boolean existsAnchorOf() {
958                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf);
959            }
960    
961            public boolean hasAnchorOf(java.lang.String stringValue) {
962                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf);
963            }
964    
965            public java.lang.String getAnchorOf() {
966                    RDFNode n = getPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf);
967                    if (n instanceof Literal) {
968                            Literal l = (Literal) n;
969                            return (java.lang.String) (nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.getString(l));
970                    } else {
971                            log.warn("Could not convert anchorOf of " + getURI() + " (" + n + ") to type String");
972                            return null;
973                    }
974            }
975    
976            public void setAnchorOf(java.lang.String stringValue) {
977                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf);
978                    nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
979                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
980                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf, literal);
981            }
982    
983            public void removeAnchorOf() {
984                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.anchorOf);
985            }
986    
987            /**
988             * Domain property endIndex
989             * with uri http://nlp2rdf.lod2.eu/schema/string/endIndex
990             */
991            public boolean existsEndIndex() {
992                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex);
993            }
994    
995            public boolean hasEndIndex(java.lang.String stringValue) {
996                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex);
997            }
998    
999            public int countEndIndex() {
1000                    int count = 0;
1001                    Iterator<java.lang.String> it = iterateEndIndex();
1002                    while (it.hasNext()) {
1003                            it.next();
1004                            count++;
1005                    }
1006                    return count;
1007            }
1008    
1009            public Iterator<java.lang.String> iterateEndIndex() {
1010                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex);
1011                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
1012            }
1013    
1014            public List<java.lang.String> listEndIndex() {
1015                    List<java.lang.String> list = new ArrayList<java.lang.String>();
1016                    Iterator<java.lang.String> it = iterateEndIndex();
1017                    while (it.hasNext()) {
1018                            java.lang.String inst = it.next();
1019                            list.add(inst);
1020                    }
1021                    return list;
1022            }
1023    
1024            public void addEndIndex(java.lang.String stringValue) {
1025                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1026                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex, literal);
1027            }
1028    
1029            public void addAllEndIndex(List<java.lang.String> stringList) {
1030                    for (java.lang.String o : stringList)
1031                            addEndIndex(o);
1032            }
1033    
1034            public void removeEndIndex(java.lang.String stringValue) {
1035                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1036                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex, literal);
1037            }
1038    
1039            public void removeAllEndIndex() {
1040                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.endIndex);
1041    
1042            }
1043    
1044            /**
1045             * Domain property beginIndex
1046             * with uri http://nlp2rdf.lod2.eu/schema/string/beginIndex
1047             */
1048            public boolean existsBeginIndex() {
1049                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex);
1050            }
1051    
1052            public boolean hasBeginIndex(java.lang.String stringValue) {
1053                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex);
1054            }
1055    
1056            public int countBeginIndex() {
1057                    int count = 0;
1058                    Iterator<java.lang.String> it = iterateBeginIndex();
1059                    while (it.hasNext()) {
1060                            it.next();
1061                            count++;
1062                    }
1063                    return count;
1064            }
1065    
1066            public Iterator<java.lang.String> iterateBeginIndex() {
1067                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex);
1068                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
1069            }
1070    
1071            public List<java.lang.String> listBeginIndex() {
1072                    List<java.lang.String> list = new ArrayList<java.lang.String>();
1073                    Iterator<java.lang.String> it = iterateBeginIndex();
1074                    while (it.hasNext()) {
1075                            java.lang.String inst = it.next();
1076                            list.add(inst);
1077                    }
1078                    return list;
1079            }
1080    
1081            public void addBeginIndex(java.lang.String stringValue) {
1082                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1083                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex, literal);
1084            }
1085    
1086            public void addAllBeginIndex(List<java.lang.String> stringList) {
1087                    for (java.lang.String o : stringList)
1088                            addBeginIndex(o);
1089            }
1090    
1091            public void removeBeginIndex(java.lang.String stringValue) {
1092                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1093                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex, literal);
1094            }
1095    
1096            public void removeAllBeginIndex() {
1097                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.beginIndex);
1098    
1099            }
1100    
1101            /**
1102             * Domain property rightContext
1103             * with uri http://nlp2rdf.lod2.eu/schema/string/rightContext
1104             */
1105            public boolean existsRightContext() {
1106                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext);
1107            }
1108    
1109            public boolean hasRightContext(java.lang.String stringValue) {
1110                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext);
1111            }
1112    
1113            public int countRightContext() {
1114                    int count = 0;
1115                    Iterator<java.lang.String> it = iterateRightContext();
1116                    while (it.hasNext()) {
1117                            it.next();
1118                            count++;
1119                    }
1120                    return count;
1121            }
1122    
1123            public Iterator<java.lang.String> iterateRightContext() {
1124                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext);
1125                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
1126            }
1127    
1128            public List<java.lang.String> listRightContext() {
1129                    List<java.lang.String> list = new ArrayList<java.lang.String>();
1130                    Iterator<java.lang.String> it = iterateRightContext();
1131                    while (it.hasNext()) {
1132                            java.lang.String inst = it.next();
1133                            list.add(inst);
1134                    }
1135                    return list;
1136            }
1137    
1138            public void addRightContext(java.lang.String stringValue) {
1139                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1140                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext, literal);
1141            }
1142    
1143            public void addAllRightContext(List<java.lang.String> stringList) {
1144                    for (java.lang.String o : stringList)
1145                            addRightContext(o);
1146            }
1147    
1148            public void removeRightContext(java.lang.String stringValue) {
1149                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1150                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext, literal);
1151            }
1152    
1153            public void removeAllRightContext() {
1154                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.rightContext);
1155    
1156            }
1157    
1158            /**
1159             * Domain property leftContext
1160             * with uri http://nlp2rdf.lod2.eu/schema/string/leftContext
1161             */
1162            public boolean existsLeftContext() {
1163                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext);
1164            }
1165    
1166            public boolean hasLeftContext(java.lang.String stringValue) {
1167                    return hasProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext);
1168            }
1169    
1170            public int countLeftContext() {
1171                    int count = 0;
1172                    Iterator<java.lang.String> it = iterateLeftContext();
1173                    while (it.hasNext()) {
1174                            it.next();
1175                            count++;
1176                    }
1177                    return count;
1178            }
1179    
1180            public Iterator<java.lang.String> iterateLeftContext() {
1181                    ExtendedIterator<Statement> it = listProperties(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext);
1182                    return it.mapWith(nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.objectAsStringMapper).filterDrop(new NullFilter<java.lang.String>());
1183            }
1184    
1185            public List<java.lang.String> listLeftContext() {
1186                    List<java.lang.String> list = new ArrayList<java.lang.String>();
1187                    Iterator<java.lang.String> it = iterateLeftContext();
1188                    while (it.hasNext()) {
1189                            java.lang.String inst = it.next();
1190                            list.add(inst);
1191                    }
1192                    return list;
1193            }
1194    
1195            public void addLeftContext(java.lang.String stringValue) {
1196                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1197                    setPropertyValue(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext, literal);
1198            }
1199    
1200            public void addAllLeftContext(List<java.lang.String> stringList) {
1201                    for (java.lang.String o : stringList)
1202                            addLeftContext(o);
1203            }
1204    
1205            public void removeLeftContext(java.lang.String stringValue) {
1206                    Literal literal = nl.tudelft.tbm.eeni.owl2java.model.xsd.XsdUtils.createTypedLiteral((OntModel) getModel(), stringValue, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
1207                    removeProperty(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext, literal);
1208            }
1209    
1210            public void removeAllLeftContext() {
1211                    removeAll(eu.lod2.nlp2rdf.schema.tools.Vocabulary.leftContext);
1212    
1213            }
1214    
1215    }