net.fortytwo.sesametools.RandomValueFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Common utilities for Sesametools
The newest version!
package net.fortytwo.sesametools;

import org.openrdf.model.BNode;
import org.openrdf.model.Literal;
import org.openrdf.model.Resource;
import org.openrdf.model.Statement;
import org.openrdf.model.IRI;
import org.openrdf.model.Value;
import org.openrdf.model.ValueFactory;
import org.openrdf.model.vocabulary.XMLSchema;

import java.util.Random;
import java.util.UUID;

/**
 * A utility for generating random values and statements
 *
 * @author Joshua Shinavier (http://fortytwo.net)
 */
public class RandomValueFactory {
    private static final int MAXINT = 65535;

    private static final int MIN_LABEL_LENGTH = 1;
    private static final int MAX_LABEL_LENGTH = 100;

    private static final String[] languages = {"en", "fr", "de"};

    private enum ValueType {
        URI, /*Bnode,*/ LITERAL
    }

    private enum LiteralKind {
        PLAIN, WITH_LANGUAGE, TYPED
    }

    private enum LiteralType {
        STRING, INT, DOUBLE
    }

    private ValueFactory valueFactory;
    private Random rand = new Random();

    public RandomValueFactory(final ValueFactory vf) {
        this.valueFactory = vf;
    }

    public Statement randomStatement() {
        return randomStatement(randomResource());
    }

    public Statement randomStatement(final Resource context) {
        Resource subj = randomResource();
        IRI pred = randomIRI();
        Value obj = randomValue();
        return valueFactory.createStatement(subj, pred, obj, context);
    }

    public Resource randomResource() {
        ValueType type;
        do {
            type = randomValueType();
        } while (ValueType.LITERAL == type);
        return (Resource) randomValue(type);
    }

    public Value randomValue() {
        ValueType type = randomValueType();
        return randomValue(type);
    }

    public IRI randomIRI() {
        return valueFactory.createIRI("urn:uuid:" + UUID.randomUUID().toString().replace("-", ""));
    }

    public BNode randomBNode() {
        return valueFactory.createBNode();
    }

    public Literal randomLiteral() {
        LiteralKind kind = LiteralKind.values()[rand.nextInt(MAXINT) % LiteralKind.values().length];
        Literal l = null;

        switch (kind) {
            case PLAIN:
                l = valueFactory.createLiteral(randomStringLabel());
                break;
            case WITH_LANGUAGE:
                l = valueFactory.createLiteral(randomStringLabel(), randomLanguage());
                break;
            case TYPED:
                l = randomTypedLiteral();
                break;
        }

        return l;
    }

    public Literal randomTypedLiteral() {
        LiteralType type = LiteralType.values()[rand.nextInt(MAXINT) % LiteralType.values().length];
        Literal l = null;

        switch (type) {
            case INT:
                l = valueFactory.createLiteral(rand.nextInt(MAXINT));
                break;
            case DOUBLE:
                l = valueFactory.createLiteral(rand.nextDouble());
                break;
            case STRING:
                l = valueFactory.createLiteral(randomStringLabel(), XMLSchema.STRING);
                break;
        }

        return l;
    }

    private ValueType randomValueType() {
        return ValueType.values()[rand.nextInt(MAXINT) % ValueType.values().length];
    }

    private Value randomValue(final ValueType type) {
        Value v = null;
        switch (type) {
            case URI:
                v = randomIRI();
                break;
            //case Bnode:
            //    v = randomBNode();
            //    break;
            case LITERAL:
                v = randomLiteral();
                break;
        }
        return v;
    }

    private String randomLanguage() {
        return languages[rand.nextInt(MAXINT) % languages.length];
    }

    private String randomLabel(final int minlen, final int maxlen) {
        int n = minlen + rand.nextInt(maxlen - minlen);
        byte[] b = new byte[n];
        int range = '~' - ' ';

        // For now, use only "safe" characters.
        for (int i = 0; i < n; i++) {
            b[i] = (byte) (' ' + rand.nextInt(range));
        }

        return new String(b);
    }

    private String randomStringLabel() {
        return randomLabel(MIN_LABEL_LENGTH, MAX_LABEL_LENGTH);
    }

}