VocabularyStore.I18nStringValueCache Class Reference

Inheritance diagram for VocabularyStore.I18nStringValueCache:

Collaboration diagram for VocabularyStore.I18nStringValueCache:

Package Functions
	I18nStringValueCache (Property p, boolean inverse)
Literal	get (String iri, String preferredLang)
Literal	getCached (String iri, String preferredLang)
Collection< Literal >	pickBestValue (Set< RDFNode > candidates)
K	get (String iri)
K	getCached (String iri)

Private Member Functions
Literal	getBestMatch (Collection< Literal > candidates, String preferredLang)
int	getMatchLength (String langTag1, String langTag2)
K	pickBestFromModel (Model m, String iri)
Set< RDFNode >	getValues (Resource r)
Set< RDFNode >	getInverseValues (Resource r)

Private Attributes
final Property	property
final boolean	inverse
final Map< String, K >	cache

Constructor & Destructor Documentation

I18nStringValueCache()

I18nStringValueCache ( Property  p, boolean  inverse  )

package

                                                                  {
                        super (p, inverse);
                }

References VocabularyStore.ValueCache< Collection< Literal > >.inverse.

Member Function Documentation

get() [1/2]

K get ( String  iri )

packageinherited

                                  {
                        if (cache.containsKey(iri)) {
                                return cache.get(iri);
                        }
                        K best = null;
                        if (dataSource.canDescribe(iri)) {
                                best = pickBestFromModel(dataSource.describeResource(iri), iri);
                        }
                        cache.put(iri, best);
                        return best;
                }

get() [2/2]

Literal get ( String  iri, String  preferredLang  )

package

                                                              {
                        return getBestMatch(get(iri), preferredLang);
                }

References VocabularyStore.I18nStringValueCache.getBestMatch().

Referenced by VocabularyStore.getDescription(), VocabularyStore.getInverseLabel(), and VocabularyStore.getLabel().

getBestMatch()

Literal getBestMatch ( Collection< Literal >  candidates, String  preferredLang  )

private

                                                                                                   {
                        if (candidates == null) return null;
                        Literal bestMatch = null;
                        int bestMatchLength = -1;
                        for (Literal l: candidates) {
                                int matchLength = getMatchLength(l.getLanguage(), preferredLang);
                                if (matchLength >= bestMatchLength) {
                                        bestMatch = l;
                                        bestMatchLength = matchLength;
                                }
                        }
                        return bestMatch;
                }

References VocabularyStore.I18nStringValueCache.getMatchLength().

Referenced by VocabularyStore.I18nStringValueCache.get(), and VocabularyStore.I18nStringValueCache.getCached().

getCached() [1/2]

K getCached ( String  iri )

packageinherited

                                        {
                        return cache.get(iri);
                }

getCached() [2/2]

Literal getCached ( String  iri, String  preferredLang  )

package

                                                                    {
                        return getBestMatch(getCached(iri), preferredLang);
                }

References VocabularyStore.I18nStringValueCache.getBestMatch().

Referenced by VocabularyStore.getCachedLabel().

getInverseValues()

Set<RDFNode> getInverseValues ( Resource  r )

privateinherited

                                                                  {
                        Set<RDFNode> nodes = new HashSet<RDFNode>();
                        StmtIterator it = r.listProperties(OWL.inverseOf);
                        while (it.hasNext()) {
                                RDFNode object = it.next().getObject();
                                if (!object.isResource()) continue;
                                StmtIterator it2 = object.asResource().listProperties(property);
                                while (it2.hasNext()) {
                                        nodes.add(it2.next().getObject());
                                }
                        }
                        return nodes;
                }

getMatchLength()

int getMatchLength ( String  langTag1, String  langTag2  )

private

                                                                             {
                        // TODO: This is very dodgy. It reports a decent match between "xx" and "xxx". Requires some research to do properly.
                        int i = 0;
                        while (i < langTag1.length() && i < langTag2.length()) {
                                char c1 = langTag1.charAt(i);
                                char c2 = langTag2.charAt(i);
                                if (Character.toLowerCase(c1) != Character.toLowerCase(c2)) break;
                                i++;
                        }
                        return i;
                }

Referenced by VocabularyStore.I18nStringValueCache.getBestMatch().

getValues()

Set<RDFNode> getValues ( Resource  r )

privateinherited

                                                           {
                        Set<RDFNode> nodes = new HashSet<RDFNode>();
                        StmtIterator it = r.listProperties(property);
                        while (it.hasNext()) {
                                nodes.add(it.next().getObject());
                        }
                        return nodes;
                }

pickBestFromModel()

K pickBestFromModel ( Model  m, String  iri  )

privateinherited

                                                                 {
                        Resource r = m.getResource(iri);
                        Set<RDFNode> nodes = inverse ? getInverseValues(r) : getValues(r);
                        return pickBestValue(nodes);
                }

pickBestValue()

Collection<Literal> pickBestValue ( Set< RDFNode >  candidates )

package

                                                                           {
                        Collection<Literal> result = new ArrayList<Literal>(candidates.size());
                        for (RDFNode node: candidates) {
                                if (!node.isLiteral()) continue;
                                Literal l = node.asLiteral();
                                String dt = l.getDatatypeURI();
                                if (dt == null || dt.equals(XSD.xstring.getURI()) || dt.equals(RDF.getURI() + "langString")) {
                                        result.add(l);
                                }
                        }
                        return result;
                }

Member Data Documentation

cache

final Map<String, K> cache

privateinherited

inverse

final boolean inverse

privateinherited

property

final Property property

privateinherited