out_fuzz_files = [op_name + "_fuzz.cc" for op_name in op_names]
    native.genrule(
        name = name + "_genrule",
        outs = out_fuzz_files,
        srcs = api_def_srcs,
        tools = [":op_fuzz_gen_tool"],
        cmd = ("$(location :op_fuzz_gen_tool) " +

        responseData.setResponseBody(new byte[0]);
        final Rule rule = ruleManager.getRule(responseData);
        assertNotNull(rule);
        assertEquals("fileRule", rule.getRuleId());
        CloseableUtil.closeQuietly(responseData);
    }

    public void test_checkRule() {
        final Rule rule = ruleManager.getRule(new ResponseData());
        assertNotNull(rule);

        name = gen_op_lib_exec,
        srcs = [src],
        srcs_version = "PY3",
        python_version = "PY3",
        deps = py_deps,
    )

    registered_op = "registered_" + name
    native.genrule(
        name = registered_op,
        srcs = [],
        outs = [name + ".inc.cc"],
        cmd = "$(location %s) --output=$@ --gen_register_op=true" % gen_op_lib_exec,
        tools = [":" + gen_op_lib_exec],

    protected final List<Rule> ruleList = new ArrayList<>();

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.rule.RuleManager#getRule(org.codelibs.fess.crawler.entity.ResponseData)
     */
    @Override
    public Rule getRule(final ResponseData responseData) {
        for (final Rule rule : ruleList) {
            if (rule.match(responseData)) {
                return rule;
            }

load("//tensorflow:strict.default.bzl", "py_strict_binary")
load("//tensorflow:tensorflow.bzl", "tf_cc_test")
load("//tensorflow:tensorflow.default.bzl", "filegroup", "genrule")
load("//tensorflow/compiler/aot:tfcompile.bzl", "tf_library")
load("//tensorflow/compiler/mlir:glob_lit_test.bzl", "glob_lit_tests")

package(
    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
    default_visibility = ["//visibility:private"],

        # because builds may run concurrently with tests, and tests need to be
        # able to assume that they have control of the full GPU.
        out_nodes_file = "out_nodes_" + freeze_name
        native.genrule(
            name = ("gen_" + out_nodes_file),
            srcs = [config],
            outs = [out_nodes_file],
            cmd = ("CUDA_VISIBLE_DEVICES='' " +
                   "$(location " + tfcompile_tool + ")" +

 */
package org.codelibs.fess.crawler.rule;

import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * @author shinsuke
 *
 */
public interface RuleManager {

    Rule getRule(ResponseData responseData);

    void addRule(Rule rule);

    void addRule(int index, Rule rule);

    boolean removeRule(Rule rule);

    boolean hasRule(Rule rule);

interface MetadataRuleWrapper {
    DisplayName getDisplayName();

    boolean isClassBased();

    Collection<SpecConfigurableRule> getClassRules();

    SpecRuleAction<? super ComponentMetadataDetails> getRule();

    void addClassRule(SpecConfigurableRule ruleAction);

    }

    @Override
    public void addClassRule(SpecConfigurableRule classRule) {
        classRules.add(classRule);
    }

    @Override
    public SpecRuleAction<? super ComponentMetadataDetails> getRule() {
        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public DisplayName getDisplayName() {

        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public SpecRuleAction<? super ComponentMetadataDetails> getRule() {
        return ruleAction;
    }