001: /*
002: (c) Copyright 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
003: All rights reserved - see end of file.
004: $Id: GraphTripleStoreBase.java,v 1.6 2008/01/02 12:09:51 andy_seaborne Exp $
005: */
006:
007: package com.hp.hpl.jena.mem;
008:
009: import java.util.Iterator;
010:
011: import com.hp.hpl.jena.graph.Graph;
012: import com.hp.hpl.jena.graph.Node;
013: import com.hp.hpl.jena.graph.Triple;
014: import com.hp.hpl.jena.graph.TripleMatch;
015: import com.hp.hpl.jena.graph.impl.TripleStore;
016: import com.hp.hpl.jena.util.iterator.ExtendedIterator;
017: import com.hp.hpl.jena.util.iterator.WrappedIterator;
018:
019: public abstract class GraphTripleStoreBase implements TripleStore {
020: protected final Graph parent;
021: protected NodeToTriplesMapBase subjects;
022: protected NodeToTriplesMapBase predicates;
023: protected NodeToTriplesMapBase objects;
024:
025: protected GraphTripleStoreBase(Graph parent,
026: NodeToTriplesMapBase subjects,
027: NodeToTriplesMapBase predicates,
028: NodeToTriplesMapBase objects) {
029: this .parent = parent;
030: this .subjects = subjects;
031: this .objects = objects;
032: this .predicates = predicates;
033: }
034:
035: /**
036: Destroy this triple store - discard the indexes.
037: */
038: public void close() {
039: subjects = predicates = objects = null;
040: }
041:
042: /**
043: Add a triple to this triple store.
044: */
045: public void add(Triple t) {
046: if (subjects.add(t)) {
047: predicates.add(t);
048: objects.add(t);
049: }
050: }
051:
052: /**
053: Remove a triple from this triple store.
054: */
055: public void delete(Triple t) {
056: if (subjects.remove(t)) {
057: predicates.remove(t);
058: objects.remove(t);
059: }
060: }
061:
062: /**
063: Clear this store, ie remove all triples from it.
064: */
065: public void clear() {
066: subjects.clear();
067: predicates.clear();
068: objects.clear();
069: }
070:
071: /**
072: Answer the size (number of triples) of this triple store.
073: */
074: public int size() {
075: return subjects.size();
076: }
077:
078: /**
079: Answer true iff this triple store is empty.
080: */
081: public boolean isEmpty() {
082: return subjects.isEmpty();
083: }
084:
085: public ExtendedIterator listSubjects() {
086: return WrappedIterator.createNoRemove(subjects.domain());
087: }
088:
089: public ExtendedIterator listPredicates() {
090: return WrappedIterator.createNoRemove(predicates.domain());
091: }
092:
093: public ExtendedIterator listObjects() {
094: return new ObjectIterator(objects.domain()) {
095: protected Iterator iteratorFor(Object y) {
096: return objects.iteratorForIndexed(y);
097: }
098: };
099: }
100:
101: /**
102: Answer true iff this triple store contains the (concrete) triple <code>t</code>.
103: */
104: public boolean contains(Triple t) {
105: return subjects.containsBySameValueAs(t);
106: }
107:
108: public boolean containsByEquality(Triple t) {
109: return subjects.contains(t);
110: }
111:
112: /**
113: Answer an ExtendedIterator returning all the triples from this store that
114: match the pattern <code>m = (S, P, O)</code>.
115:
116: <p>Because the node-to-triples maps index on each of subject, predicate,
117: and (non-literal) object, concrete S/P/O patterns can immediately select
118: an appropriate map. Because the match for literals must be by sameValueAs,
119: not equality, the optimisation is not applied for literals. [This is probably a
120: Bad Thing for strings.]
121:
122: <p>Practice suggests doing the predicate test <i>last</i>, because there are
123: "usually" many more statements than predicates, so the predicate doesn't
124: cut down the search space very much. By "practice suggests" I mean that
125: when the order went, accidentally, from S/O/P to S/P/O, performance on
126: (ANY, P, O) searches on largish models with few predicates declined
127: dramatically - specifically on the not-galen.owl ontology.
128: */
129: public ExtendedIterator find(TripleMatch tm) {
130: Triple t = tm.asTriple();
131: Node pm = t.getPredicate();
132: Node om = t.getObject();
133: Node sm = t.getSubject();
134:
135: if (sm.isConcrete())
136: return new StoreTripleIterator(parent, subjects.iterator(
137: sm, pm, om), subjects, predicates, objects);
138: else if (om.isConcrete())
139: return new StoreTripleIterator(parent, objects.iterator(om,
140: sm, pm), objects, subjects, predicates);
141: else if (pm.isConcrete())
142: return new StoreTripleIterator(parent, predicates.iterator(
143: pm, om, sm), predicates, subjects, objects);
144: else
145: return new StoreTripleIterator(parent, subjects
146: .iterateAll(), subjects, predicates, objects);
147: }
148: }
149:
150: /*
151: * (c) Copyright 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
152: * All rights reserved.
153: *
154: * Redistribution and use in source and binary forms, with or without
155: * modification, are permitted provided that the following conditions
156: * are met:
157: * 1. Redistributions of source code must retain the above copyright
158: * notice, this list of conditions and the following disclaimer.
159: * 2. Redistributions in binary form must reproduce the above copyright
160: * notice, this list of conditions and the following disclaimer in the
161: * documentation and/or other materials provided with the distribution.
162: * 3. The name of the author may not be used to endorse or promote products
163: * derived from this software without specific prior written permission.
164: *
165: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
166: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
167: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
168: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
169: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
170: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
171: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
172: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
173: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
174: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
175: */
|