extras/rya.forwardchain/src/main/java/org/apache/rya/forwardchain/strategy/AbstractRuleExecutionStrategy.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.rya.forwardchain.strategy;

import org.apache.rya.api.domain.StatementMetadata;
import org.apache.rya.forwardchain.ForwardChainException;

import org.apache.rya.forwardchain.rule.AbstractConstructRule;
import org.apache.rya.forwardchain.rule.AbstractInconsistencyRule;
import org.apache.rya.forwardchain.rule.AbstractUpdateRule;

/**
 * Base class for rule application strategies, which can execute a single
 * forward chaining (materialization) rule at a time. Subclasses may provide
 * implementations of methods to execute whichever they support of construct
 * rules, update rules, and inconsistency rules. The default behavior for all
 * kinds is to throw an {@link UnsupportedOperationException}.
 */
public abstract class AbstractRuleExecutionStrategy {
    protected int requiredLevel = 0;

    /**
     * Execute a rule corresponding to a "CONSTRUCT" query. Throws an
     * UnsupportedOperationException if not explicitly overridden.
     * @param rule The construct rule to apply; assumed not null.
     * @param metadata Additional metadata to add to any inferred triples;
     *  assumed not null.
     * @return The number of inferred triples. Higher-level forward chaining
     *  strategies may rely on the accuracy of this number.
     * @throws ForwardChainException if execution failed.
     */
    public long executeConstructRule(AbstractConstructRule rule,
            StatementMetadata metadata) throws ForwardChainException {
        throw new UnsupportedOperationException("Rule execution strategy does not support construct rules.");
    };

    /**
     * Execute a rule corresponding to an update query. Throws an
     * UnsupportedOperationException if not explicitly overridden.
     * @param rule The update rule to apply; assumed not null.
     * @param metadata Additional metadata to add to any updated triples;
     *  assumed not null.
     * @return The number of inferences made. Higher-level forward chaining
     *  strategies may rely on the accuracy of this number.
     * @throws ForwardChainException if execution failed.
     */
    public long executeUpdateRule(AbstractUpdateRule rule,
            StatementMetadata metadata) throws ForwardChainException {
        throw new UnsupportedOperationException("Rule execution strategy does not support update rules.");
    };

    /**
     * Execute a rule capable of detecting inconsistencies. Throws an
     * UnsupportedOperationException if not explicitly overridden.
     * @param rule The inconsistency rule to apply; assumed not null.
     * @param metadata Additional metadata associated with inconsistencies;
     *  assumed not null.
     * @return The number of inconsistencies found.
     * @throws ForwardChainException if execution failed.
     */
    public long executeInconsistencyRule(AbstractInconsistencyRule rule,
            StatementMetadata metadata) throws ForwardChainException {
        throw new UnsupportedOperationException("Rule execution strategy does not perform inconsistency detection.");
    }

    /**
     * Initialize the strategy and make any preparations for executing rules.
     * Does nothing by default; subclasses should override if necessary.
     * @throws ForwardChainException
     */
    public void initialize() throws ForwardChainException { };

    /**
     * Shut down the strategy and perform any appropriate cleanup. Does nothing
     * by default; subclasses should override if necessary.
     * @throws ForwardChainException
     */
    public void shutDown() throws ForwardChainException { }

    /**
     * Indicate that a rule need only be applied if one of the source statements
     * is is at least this derivation level, i.e. took this many steps to derive
     * itself. Subclasses may use this for optimization, but are not guaranteed
     * to.
     * @param derivationLevel Forward chaining level of statements that should
     *  be used to trigger rules. If not set, defaults to zero which should have
     *  no effect.
     */
    public void setRequiredLevel(int derivationLevel) {
        this.requiredLevel = derivationLevel;
    };
}