001 /**
002 * =========================================
003 * LibFormula : a free Java formula library
004 * =========================================
005 *
006 * Project Info: http://reporting.pentaho.org/libformula/
007 *
008 * (C) Copyright 2006-2007, by Pentaho Corporation and Contributors.
009 *
010 * This library is free software; you can redistribute it and/or modify it under the terms
011 * of the GNU Lesser General Public License as published by the Free Software Foundation;
012 * either version 2.1 of the License, or (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
015 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
016 * See the GNU Lesser General Public License for more details.
017 *
018 * You should have received a copy of the GNU Lesser General Public License along with this
019 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
020 * Boston, MA 02111-1307, USA.
021 *
022 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
023 * in the United States and other countries.]
024 *
025 *
026 * ------------
027 * $Id: NotEqualOperator.java 3521 2007-10-16 10:55:14Z tmorgner $
028 * ------------
029 * (C) Copyright 2006-2007, by Pentaho Corporation.
030 */
031 package org.jfree.formula.operators;
032
033 import org.jfree.formula.lvalues.TypeValuePair;
034 import org.jfree.formula.EvaluationException;
035 import org.jfree.formula.FormulaContext;
036 import org.jfree.formula.typing.TypeRegistry;
037 import org.jfree.formula.typing.ExtendedComparator;
038 import org.jfree.formula.typing.coretypes.LogicalType;
039
040 /**
041 * Creation-Date: 31.10.2006, 16:34:11
042 *
043 * @author Thomas Morgner
044 */
045 public class NotEqualOperator implements InfixOperator
046 {
047 private static final TypeValuePair RETURN_TRUE = new TypeValuePair(LogicalType.TYPE, Boolean.TRUE);
048 private static final TypeValuePair RETURN_FALSE = new TypeValuePair(LogicalType.TYPE, Boolean.FALSE);
049
050 public NotEqualOperator()
051 {
052 }
053
054 public TypeValuePair evaluate(final FormulaContext context,
055 final TypeValuePair value1, final TypeValuePair value2)
056 throws EvaluationException
057 {
058 final TypeRegistry typeRegistry = context.getTypeRegistry();
059
060 final ExtendedComparator comparator =
061 typeRegistry.getComparator(value1.getType(), value2.getType());
062 final boolean result = comparator.isEqual
063 (value1.getType(), value1.getValue(),
064 value2.getType(), value2.getValue());
065
066 if (result == false)
067 {
068 return RETURN_TRUE;
069 }
070 else
071 {
072 return RETURN_FALSE;
073 }
074 }
075
076 public int getLevel()
077 {
078 return 400;
079 }
080
081 public String toString()
082 {
083 return "<>";
084 }
085
086 /**
087 * Defines the bind-direction of the operator. That direction defines, in
088 * which direction a sequence of equal operators is resolved.
089 *
090 * @return true, if the operation is left-binding, false if right-binding
091 */
092 public boolean isLeftOperation()
093 {
094 return true;
095 }
096
097 /**
098 * Defines, whether the operation is associative. For associative operations,
099 * the evaluation order does not matter, if the operation appears more than
100 * once in an expression, and therefore we can optimize them a lot better than
101 * non-associative operations (ie. merge constant parts and precompute them
102 * once).
103 *
104 * @return true, if the operation is associative, false otherwise
105 */
106 public boolean isAssociative()
107 {
108 return false;
109 }
110
111 }