com.mysema.rdfbean.ontology.AbstractOntology Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rdfbean-core Show documentation
The newest version!
/*
 * Copyright (c) 2010 Mysema Ltd.
 * All rights reserved.
 * 
 */
package com.mysema.rdfbean.ontology;

import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.Stack;

import com.google.common.collect.Multimap;
import com.mysema.rdfbean.model.UID;
import com.mysema.util.MultimapFactory;

/**
 * AbstractOntology provides a generic implementation of the Ontology interface
 * 
 * @author tiwe
 * @version $Id$
 */
public abstract class AbstractOntology implements Ontology {

    private final Multimap subtypes = MultimapFactory. createWithSet();

    private final Multimap supertypes = MultimapFactory. createWithSet();

    private final Multimap subproperties = MultimapFactory. createWithSet();

    private final Multimap superproperties = MultimapFactory. createWithSet();

    protected void initializeTypeHierarchy(Set types,
            Multimap directSubtypes,
            Multimap directSupertypes) {
        for (UID type : types) {
            subtypes.put(type, type);
            if (directSubtypes.containsKey(type)) {
                flatten(type, directSubtypes, subtypes);
            }
            if (directSupertypes.containsKey(type)) {
                flatten(type, directSupertypes, supertypes);
            }
        }
    }

    protected void initializePropertyHierarchy(Set properties,
            Multimap directSubproperties,
            Multimap directSuperproperties) {
        for (UID property : properties) {
            subproperties.put(property, property);
            if (directSubproperties.containsKey(property)) {
                flatten(property, directSubproperties, subproperties);
            }
            if (directSuperproperties.containsKey(property)) {
                flatten(property, directSuperproperties, superproperties);
            }
        }
    }

    private void flatten(UID id, Multimap direct, Multimap expanded) {
        Stack t = new Stack();
        t.addAll(direct.get(id));
        while (!t.isEmpty()) {
            UID supertype = t.pop();
            expanded.put(id, supertype);
            if (direct.containsKey(supertype)) {
                t.addAll(direct.get(supertype));
            }
        }
    }

    public Collection getSubtypes(UID uid) {
        Collection rv = subtypes.get(uid);
        return rv != null ? rv : Collections.singleton(uid);
    }

    public Collection getSupertypes(UID uid) {
        Collection rv = supertypes.get(uid);
        return rv != null ? rv : Collections. emptySet();
    }

    public Collection getSubproperties(UID uid) {
        Collection rv = subproperties.get(uid);
        return rv != null ? rv : Collections.singleton(uid);
    }

    public Collection getSuperproperties(UID uid) {
        Collection rv = superproperties.get(uid);
        return rv != null ? rv : Collections. emptySet();
    }

}