/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2001 Michael Powers

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see http://www.gnu.org
*/

package net.wotonomy.control;

import net.wotonomy.foundation.NSKeyValueCoding;
import net.wotonomy.foundation.NSMutableDictionary;
import net.wotonomy.foundation.NSSelector;
import net.wotonomy.foundation.internal.WotonomyException;

/**
* EOKeyValueQualifier performs a property-based
* comparison against a specified value.  The comparison 
* is specified in the form of a NSSelector.  The
* selector is expected to take two arguments, the
* property value on an object and the comparison value, 
* and return a Boolean indicating whether the object
* is qualified.  EOQualifier defines selectors that 
* may be used in creating EOKeyValueQualifiers.
*
* @author michael@mpowers.net
* @author yjcheung@intersectsoft.com
* @author $Author: cgruber $
* @version $Revision: 894 $
*/
public class EOKeyValueQualifier extends EOQualifier
	implements EOKeyValueArchiving, EOQualifierEvaluation
{
    private String key;
    private NSSelector selector;
    private Object value;

    /**
    * Constructor specifying a property key, a selector,
    * and a value for comparison.  The selector may be
    * one of the constant selectors defined on EOQualifier.
    */
    public EOKeyValueQualifier(
        String aKey,
        NSSelector aSelector,
        Object aValue )
    {
        key = aKey;
        selector = aSelector;
        value = aValue;
    }

    /**
    * Returns the key for this qualifier.
    */
    public String key()
    {
        return key;
    }

    /**
    * Returns the selector for this qualifier.
    */
    public NSSelector selector()
    {
        return selector;
    }

    /**
    * Returns the value for this qualifier.
    */
    public Object value()
    {
        return value;
    }

    /**
    * Evaluates this qualifier for the specified object,
    * and returns whether the object is qualified.
    * selector() is invoked on the value for key() on the
    * specified object, with value() as the parameter.
    */
    public boolean evaluateWithObject( Object anObject )
    {
        try
        {
            Object value;
            if ( anObject instanceof EOKeyValueCoding )
            {
                value = ((EOKeyValueCoding)anObject).valueForKey( key() );
            }
            else
            {
                value = EOKeyValueCodingSupport.valueForKey( anObject, key() );
            }
            return ((Boolean)selector.invoke( value(), value)).booleanValue();
        }
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
    }

    /**
    * Returns a string representation of this qualifier.
    */
    public String toString()
    {
        return "( " + key + " " + selector + " " + value + " )";
    }

	public void encodeWithKeyValueArchiver(EOKeyValueArchiver arch) {
		arch.encodeObject("EOKeyValueQualifier", "class");
		arch.encodeObject(key, "key");
		NSMutableDictionary d = new NSMutableDictionary(2);
		if (value instanceof String)
			d.setObjectForKey("NSString", "class");
		else if (value instanceof java.math.BigDecimal)
			d.setObjectForKey("NSDecimalNumber", "class");
		else if (value instanceof Number)
			d.setObjectForKey("NSNumber", "class");
		else if (value instanceof NSKeyValueCoding.Null)
			d.setObjectForKey("EONull", "class");
		if (value != null && !(value instanceof NSKeyValueCoding.Null))
			d.setObjectForKey(value.toString(), "value");
		arch.encodeObject(d, "value");
		String selname = null;
		if (selector.equals(EOQualifier.QualifierOperatorCaseInsensitiveLike))
			selname = "caseInsensitiveLike:";
		else if (selector.equals(EOQualifier.QualifierOperatorContains))
			selname = "contains:";
		else if (selector.equals(EOQualifier.QualifierOperatorEqual))
			selname = "isEqualTo:";
		else if (selector.equals(EOQualifier.QualifierOperatorGreaterThan))
			selname = "greaterThan:";
		else if (selector.equals(EOQualifier.QualifierOperatorGreaterThanOrEqualTo))
			selname = "greaterThanOrEqualTo:";
		else if (selector.equals(EOQualifier.QualifierOperatorLessThan))
			selname = "lessThan:";
		else if (selector.equals(EOQualifier.QualifierOperatorLessThanOrEqualTo))
			selname = "lessThanOrEqualTo:";
		else if (selector.equals(EOQualifier.QualifierOperatorLike))
			selname = "like:";
		else if (selector.equals(EOQualifier.QualifierOperatorNotEqual))
			selname = "isNotEqualTo:";
		else
			selname = selector.name() + ":";
		arch.encodeObject(selname, "selectorName");
	}

	public static Object decodeWithKeyValueUnarchiver(EOKeyValueUnarchiver arch) {
		String k = (String)arch.decodeObjectForKey("key");
		Object v = arch.decodeObjectForKey("value");
		NSSelector sel = null;
		String sname = (String)arch.decodeObjectForKey("selectorName");
		if (sname.equals("isEqualTo:"))
			sel = EOQualifier.QualifierOperatorEqual;
		else if (sname.equals("isNotEqualTo:"))
			sel = EOQualifier.QualifierOperatorNotEqual;
		else if (sname.equals("caseInsensitiveLike:"))
			sel = EOQualifier.QualifierOperatorCaseInsensitiveLike;
		else if (sname.equals("contains:"))
			sel = EOQualifier.QualifierOperatorContains;
		else if (sname.equals("greaterThan:"))
			sel = EOQualifier.QualifierOperatorGreaterThan;
		else if (sname.equals("greaterThanOrEqualTo:"))
			sel = EOQualifier.QualifierOperatorGreaterThanOrEqualTo;
		else if (sname.equals("lessThan:"))
			sel = EOQualifier.QualifierOperatorLessThan;
		else if (sname.equals("lessThanOrEqualTo:"))
			sel = EOQualifier.QualifierOperatorLessThanOrEqualTo;
		else if (sname.equals("like:"))
			sel = EOQualifier.QualifierOperatorLike;
		EOKeyValueQualifier q = new EOKeyValueQualifier(k, sel, v);
		return q;
	}

}

/*
 * $Log$
 * Revision 1.2  2006/02/16 16:47:14  cgruber
 * Move some classes in to "internal" packages and re-work imports, etc.
 *
 * Also use UnsupportedOperationExceptions where appropriate, instead of WotonomyExceptions.
 *
 * Revision 1.1  2006/02/16 13:19:57  cgruber
 * Check in all sources in eclipse-friendly maven-enabled packages.
 *
 * Revision 1.10  2003/08/12 01:43:04  chochos
 * formally implement EOQualifierEvaluation
 *
 * Revision 1.9  2003/08/11 19:39:30  chochos
 * special conditions for NSKeyValueCoding.NullValue -> EONull
 *
 * Revision 1.8  2003/08/09 01:22:51  chochos
 * qualifiers implement EOKeyValueArchiving
 *
 * Revision 1.7  2003/08/06 23:07:52  chochos
 * general code cleanup (mostly, removing unused imports)
 *
 * Revision 1.6  2001/10/31 15:26:06  mpowers
 * Fixed typo.
 *
 * Revision 1.5  2001/10/31 15:25:14  mpowers
 * Cleanup of qualifiers.
 *
 * Revision 1.4  2001/10/30 22:57:28  mpowers
 * EOQualifier framework is now working.
 *
 * Revision 1.3  2001/09/13 15:25:56  mpowers
 * Started implementation of the EOQualifier framework.
 *
 * Revision 1.2  2001/03/29 03:29:49  mpowers
 * Now using KeyValueCoding and Support instead of Introspector.
 *
 * Revision 1.1  2001/02/27 03:33:04  mpowers
 * Initial draft of the key-value qualifier.
 *
 *
 */