src/main/java/org/apache/log4j/rule/RuleFactory.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.log4j.rule;

import java.util.Collection;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Stack;

/**
 * A Factory class which, given a string representation of the rule,
 * and a context stack, will
 * return a Rule ready for evaluation against events.
 * If an operator is requested that isn't supported,
 * an IllegalArgumentException is thrown.
 *
 * @author Scott Deboy (sdeboy@apache.org)
 */
public final class RuleFactory {
    /**
     * Singleton instance.
     */
    private static final RuleFactory FACTORY = new RuleFactory();
    /**
     * Rules.
     */
    private static final Collection RULES = new LinkedList();
    /**
     * AND operator literal.
     */
    private static final String AND_RULE = "&&";
    /**
     * OR operator literal.
     */
    private static final String OR_RULE = "||";
    /**
     * NOT operator literal.
     */
    private static final String NOT_RULE = "!";
    /**
     * Inequality operator literal.
     */
    private static final String NOT_EQUALS_RULE = "!=";
    /**
     * Equality operator literal.
     */
    private static final String EQUALS_RULE = "==";
    /**
     * Partial match operator literal.
     */
    private static final String PARTIAL_TEXT_MATCH_RULE = "~=";
    /**
     * Like operator literal.
     */
    private static final String LIKE_RULE = "like";
    /**
     * Exists operator literal.
     */
    private static final String EXISTS_RULE = "exists";
    /**
     * Less than operator literal.
     */
    private static final String LESS_THAN_RULE = "<";
    /**
     * Greater than operator literal.
     */
    private static final String GREATER_THAN_RULE = ">";
    /**
     * Less than or equal operator literal.
     */
    private static final String LESS_THAN_EQUALS_RULE = "<=";
    /**
     * Greater than or equal operator literal.
     */
    private static final String GREATER_THAN_EQUALS_RULE = ">=";

    static {
        RULES.add(AND_RULE);
        RULES.add(OR_RULE);
        RULES.add(NOT_RULE);
        RULES.add(NOT_EQUALS_RULE);
        RULES.add(EQUALS_RULE);
        RULES.add(PARTIAL_TEXT_MATCH_RULE);
        RULES.add(LIKE_RULE);
        RULES.add(EXISTS_RULE);
        RULES.add(LESS_THAN_RULE);
        RULES.add(GREATER_THAN_RULE);
        RULES.add(LESS_THAN_EQUALS_RULE);
        RULES.add(GREATER_THAN_EQUALS_RULE);
    }

    /**
     * Create instance.
     */
    private RuleFactory() {
        super();
    }

    /**
     * Get instance.
     * @return rule factory instance.
     */
    public static RuleFactory getInstance() {
        return FACTORY;
    }

    /**
     * Determine if specified string is a known operator.
     * @param symbol string
     * @return true if string is a known operator
     */
    public boolean isRule(final String symbol) {
        return ((symbol != null) && (RULES.contains(symbol.toLowerCase(Locale.ENGLISH))));
    }

    /**
     * Create rule from applying operator to stack.
     * @param symbol symbol
     * @param stack stack
     * @return new instance
     */
    public Rule getRule(final String symbol, final Stack stack) {
        if (AND_RULE.equals(symbol)) {
            return AndRule.getRule(stack);
        }

        if (OR_RULE.equals(symbol)) {
            return OrRule.getRule(stack);
        }

        if (NOT_RULE.equals(symbol)) {
            return NotRule.getRule(stack);
        }

        if (NOT_EQUALS_RULE.equals(symbol)) {
            return NotEqualsRule.getRule(stack);
        }

        if (EQUALS_RULE.equals(symbol)) {
            return EqualsRule.getRule(stack);
        }

        if (PARTIAL_TEXT_MATCH_RULE.equals(symbol)) {
            return PartialTextMatchRule.getRule(stack);
        }

        if (RULES.contains(LIKE_RULE) && LIKE_RULE.equalsIgnoreCase(symbol)) {
            return LikeRule.getRule(stack);
        }

        if (EXISTS_RULE.equalsIgnoreCase(symbol)) {
            return ExistsRule.getRule(stack);
        }

        if (LESS_THAN_RULE.equals(symbol)) {
            return InequalityRule.getRule(LESS_THAN_RULE, stack);
        }

        if (GREATER_THAN_RULE.equals(symbol)) {
            return InequalityRule.getRule(GREATER_THAN_RULE, stack);
        }

        if (LESS_THAN_EQUALS_RULE.equals(symbol)) {
            return InequalityRule.getRule(LESS_THAN_EQUALS_RULE, stack);
        }

        if (GREATER_THAN_EQUALS_RULE.equals(symbol)) {
            return InequalityRule.getRule(GREATER_THAN_EQUALS_RULE, stack);
        }
        throw new IllegalArgumentException("Invalid rule: " + symbol);
    }
}