001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.language.simple.types; 018 019 /** 020 * Types of binary operators supported 021 */ 022 public enum BinaryOperatorType { 023 024 EQ, GT, GTE, LT, LTE, NOT_EQ, CONTAINS, NOT_CONTAINS, REGEX, NOT_REGEX, 025 IN, NOT_IN, IS, NOT_IS, RANGE, NOT_RANGE; 026 027 public static BinaryOperatorType asOperator(String text) { 028 if ("==".equals(text)) { 029 return EQ; 030 } else if (">".equals(text)) { 031 return GT; 032 } else if (">=".equals(text)) { 033 return GTE; 034 } else if ("<".equals(text)) { 035 return LT; 036 } else if ("<=".equals(text)) { 037 return LTE; 038 } else if ("!=".equals(text)) { 039 return NOT_EQ; 040 } else if ("contains".equals(text)) { 041 return CONTAINS; 042 } else if ("not contains".equals(text)) { 043 return NOT_CONTAINS; 044 } else if ("regex".equals(text)) { 045 return REGEX; 046 } else if ("not regex".equals(text)) { 047 return NOT_REGEX; 048 } else if ("in".equals(text)) { 049 return IN; 050 } else if ("not in".equals(text)) { 051 return NOT_IN; 052 } else if ("is".equals(text)) { 053 return IS; 054 } else if ("not is".equals(text)) { 055 return NOT_IS; 056 } else if ("range".equals(text)) { 057 return RANGE; 058 } else if ("not range".equals(text)) { 059 return NOT_RANGE; 060 } 061 throw new IllegalArgumentException("Operator not supported: " + text); 062 } 063 064 public static String getOperatorText(BinaryOperatorType operator) { 065 if (operator == EQ) { 066 return "=="; 067 } else if (operator == GT) { 068 return ">"; 069 } else if (operator == GTE) { 070 return ">="; 071 } else if (operator == LT) { 072 return "<"; 073 } else if (operator == LTE) { 074 return "<="; 075 } else if (operator == NOT_EQ) { 076 return "!="; 077 } else if (operator == CONTAINS) { 078 return "contains"; 079 } else if (operator == NOT_CONTAINS) { 080 return "not contains"; 081 } else if (operator == REGEX) { 082 return "regex"; 083 } else if (operator == NOT_REGEX) { 084 return "not regex"; 085 } else if (operator == IN) { 086 return "in"; 087 } else if (operator == NOT_IN) { 088 return "not in"; 089 } else if (operator == IS) { 090 return "is"; 091 } else if (operator == NOT_IS) { 092 return "not is"; 093 } else if (operator == RANGE) { 094 return "range"; 095 } else if (operator == NOT_RANGE) { 096 return "not range"; 097 } 098 return ""; 099 } 100 101 /** 102 * Parameter types a binary operator supports on the right hand side. 103 * <ul> 104 * <li>Literal - Only literals enclosed by single quotes</li> 105 * <li>LiteralWithFunction - literals which may have embedded functions enclosed by single quotes</li> 106 * <li>Function - A function</li> 107 * <li>NumericValue - A numeric value</li> 108 * <li>BooleanValue - A boolean value</li> 109 * <li>NullValue - A null value</li> 110 * </ul> 111 */ 112 public enum ParameterType { 113 Literal, LiteralWithFunction, Function, NumericValue, BooleanValue, NullValue; 114 115 public boolean isLiteralSupported() { 116 return this == Literal; 117 } 118 119 public boolean isLiteralWithFunctionSupport() { 120 return this == LiteralWithFunction; 121 } 122 123 public boolean isFunctionSupport() { 124 return this == Function; 125 } 126 127 public boolean isNumericValueSupported() { 128 return this == NumericValue; 129 } 130 131 public boolean isBooleanValueSupported() { 132 return this == BooleanValue; 133 } 134 135 public boolean isNullValueSupported() { 136 return this == NullValue; 137 } 138 } 139 140 /** 141 * Returns the types of right hand side parameters this operator supports. 142 * 143 * @param operator the operator 144 * @return <tt>null</tt> if accepting all types, otherwise the array of accepted types 145 */ 146 public static ParameterType[] supportedParameterTypes(BinaryOperatorType operator) { 147 if (operator == EQ) { 148 return null; 149 } else if (operator == GT) { 150 return null; 151 } else if (operator == GTE) { 152 return null; 153 } else if (operator == LT) { 154 return null; 155 } else if (operator == LTE) { 156 return null; 157 } else if (operator == NOT_EQ) { 158 return null; 159 } else if (operator == CONTAINS) { 160 return null; 161 } else if (operator == NOT_CONTAINS) { 162 return null; 163 } else if (operator == REGEX) { 164 return new ParameterType[]{ParameterType.Literal, ParameterType.Function}; 165 } else if (operator == NOT_REGEX) { 166 return new ParameterType[]{ParameterType.Literal, ParameterType.Function}; 167 } else if (operator == IN) { 168 return null; 169 } else if (operator == NOT_IN) { 170 return null; 171 } else if (operator == IS) { 172 return new ParameterType[]{ParameterType.LiteralWithFunction, ParameterType.Function}; 173 } else if (operator == NOT_IS) { 174 return new ParameterType[]{ParameterType.LiteralWithFunction, ParameterType.Function}; 175 } else if (operator == RANGE) { 176 return new ParameterType[]{ParameterType.LiteralWithFunction, ParameterType.Function}; 177 } else if (operator == NOT_RANGE) { 178 return new ParameterType[]{ParameterType.LiteralWithFunction, ParameterType.Function}; 179 } 180 return null; 181 } 182 183 @Override 184 public String toString() { 185 return getOperatorText(this); 186 } 187 188 }