// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.ui_1_5.filtering.nonpublic;

/**
 * An abstract representation of a <b>LIKE</b> SQL <i>WHERE</i> clause.<p>
 * <a href="../../../Licence.txt">Licence</a><br>
 * <p/>
 * This <b>FormQueryFilter</b> is <a href="FormQueryFilterNotable.html"><b>NOT</b><i>able</i></a>.<p>
 * <p/>
 * This form of <b>FormQueryFilter</b> is only used with Strings (both as
 * Columns and comparison values) to determine if the column <i>contains</i>
 * the comparison value.  The form of the <i>contains</i> currently is
 * limited to: CONTAINS, STARTS_WITH, ENDS_WITH.<p>
 * <p/>
 * See <a href="FormQueryFilter.html">FormQueryFilter</a><br>
 * See <a href="FormQueryFilterFactory.html">FormQueryFilterFactory</a><p>
 * <p/>
 * Exceptions: All problems caught when the parameter(s) are checked (as
 * indicated/implied in the @param tags) will generate an IllegalArgumentException,
 * and means the API user has a problem.  If a NullPointerException (or some
 * others, like: ClassCastException or ArrayIndexOutOfBoundsException) is thrown,
 * it means the API developer has a problem.  Any Exception that is explicitly
 * thrown in the API, but unrelated to a parameter, will be listed in the throws
 * clause (and hopefully in the tag @throws).  These may (but probably won't) be
 * checked Exceptions.
 *
 * @author George Smith
 * @version 1.0 08/08/08
 */

public abstract class AbstractFQFReferenceAndLikeValue
//        extends AbstractFQFReferenceLike
{
//    private String mValue;
//
//    /**
//     * Constructor that supports the <b>LIKE</b> SQL <i>WHERE</i> clause.<p>
//     *
//     * @param pType      The Type (CONTAINS, STARTS_WITH, or ENDS_WITH) for this FormQueryFilter.
//     * @param pFinder    !null
//     * @param pReference !null (the eventual Column Type must equal String or this Filter is ignored).
//     * @param pValue     String that is to be used for <i>contains</i> checking (!null).
//     */
//    protected AbstractFQFReferenceAndLikeValue( WhereClauseType pType, Finder pFinder, String pReference,
//                                                String pValue )
//    {
//        super( pType, pFinder, pReference );
//
//        IllegalArgument.ifNull( "Value", mValue = pValue );
//    }
//
//    /**
//     * Accessor for the value that the column is to be checked against.<p>
//     *
//     * @return column checked against value.
//     */
//    public final String getValue()
//    {
//        return mValue;
//    }
//
//    protected boolean LLequalsSameTypeAndReference( AbstractFQFReference pThem )
//    {
//        AbstractFQFReferenceAndLikeValue them = (AbstractFQFReferenceAndLikeValue) pThem;
//        return equal( this.mValue, them.mValue );
//    }
//
//    /**
//     * Helper method for <b>toString()</b> that provides a more efficient
//     * mechanism for the recursive decent of a FormQueryFilter <i>tree</i>.<p>
//     *
//     * @param pSB the StringBuilder to build the FormQueryFilter into.<p>
//     */
//    protected void toStringHelper( StringBuilder pSB )
//    {
//        toStringReference( pSB );
//        pSB.append( ' ' );
//        pSB.append( getType().getToStr() );
//        pSB.append( ' ' );
//        toStringValue( pSB, getValue() );
//    }
//
//    protected void LLpopulate( HierarchicalDataSink.Node pNode )
//    {
//        super.LLpopulate( pNode );
//        pNode.setAttribute( "Value", getValue() );
//    }
//
//    protected abstract static class FQFLikeValueRehydrateFactory
//            extends FQFReferenceNoChildrenRehydrateFactory
//    {
//        protected final HierarchicalDesiccatable create( HierarchicalDataSource.Node pSourceNode,
//                                                         Finder pFinder, String pReference )
//        {
//            return create( pFinder, pReference, requiredNonEmpty( pSourceNode, "Value" ) );
//        }
//
//        abstract protected HierarchicalDesiccatable create( Finder pFinder, String pReference, String pValue );
//    }
}