litesoft
@ 947
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
// 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 SQL <i>WHERE</i> clause that supports a * column and comparison value.<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 currently used to support: * EQUALS, LESSTHAN, and GREATERTHAN.<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 AbstractFQFReferenceAndValue // extends AbstractFQFReferenceAndBoxedType { // private Object mValue; // // /** // * Constructor that supports a Column and comparison value SQL <i>WHERE</i> clause.<p> // * <p/> // * Note: Both the type of the Column and the type of the Value should be // * comparable. For the SQL generation, the Value object's toString() // * method is used for <i>conversion</i>.<p> // * // * @param pType The Type (EQUALS, LESSTHAN, and GREATERTHAN) for this FormQueryFilter. // * @param pFinder !null // * @param pReference !null // */ // protected AbstractFQFReferenceAndValue( WhereClauseType pType, Finder pFinder, String pReference ) // { // super( pType, pFinder, pReference ); // } // // /** // * Accessor for the comparison value.<p> // * // * @return the comparison value (!null). // */ // public final Object getValue() // { // return mValue; // } // // protected boolean LLequalsSameTypesAndReference( AbstractFQFReferenceAndBoxedType pThem ) // { // AbstractFQFReferenceAndValue them = (AbstractFQFReferenceAndValue) 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 setValue( Boolean pValue ) // { // LLsetValue( BoxedBoolean.class, pValue ); // } // // protected void setValue( Date pValue ) // { // LLsetValue( BoxedDate.class, pValue ); // } // // protected void setValue( Double pValue ) // { // LLsetValue( BoxedDouble.class, pValue ); // } // // protected void setValue( Float pValue ) // { // LLsetValue( BoxedFloat.class, pValue ); // } // // protected void setValue( Integer pValue ) // { // LLsetValue( BoxedInteger.class, pValue ); // } // // protected void setValue( Long pValue ) // { // LLsetValue( BoxedLong.class, pValue ); // } // // protected void setValue( Short pValue ) // { // LLsetValue( BoxedShort.class, pValue ); // } // // protected void setValue( String pValue ) // { // LLsetValue( BoxedString.class, pValue ); // } // // private void LLsetValue( Class pBoxedTypeClass, Object pValue ) // { // mBoxedTypeClass = pBoxedTypeClass; // IllegalArgument.ifNull( "Value", mValue = pValue ); // } // // protected void LLpopulate( HierarchicalDataSink.Node pNode ) // { // super.LLpopulate( pNode ); // AbstractBoxedSimpleType zBoxedSimpleType; // try // { // zBoxedSimpleType = (AbstractBoxedSimpleType) mBoxedTypeClass.newInstance(); // } // catch ( InstantiationException e ) // { // throw new RuntimeException( e ); // } // catch ( IllegalAccessException e ) // { // throw new RuntimeException( e ); // } // AbstractBoxedSimpleType.BackDoor.setObjectValue( zBoxedSimpleType, mValue ); // zBoxedSimpleType.desiccate( pNode ); // } // // protected abstract static class FQFRefNValueRehydrateFactory // extends FQFReferenceWithChildrenRehydrateFactory // { // protected HierarchicalDesiccatable create( HierarchicalRehydrateFactoryFactory pFactoryFactory, // // HierarchicalDataSource.Node pSourceNode, // // Finder pFinder, String pReference ) // { // Object zChild = pFactoryFactory.rehydrateNextChild( pSourceNode, pFinder ); // if ( !(zChild instanceof AbstractBoxedSimpleType) ) // { // throw new IllegalArgumentException( "Got a " + pSourceNode.getName() + // ", but instead of expected Value(BoxedSimpleType), got a " + // (zChild == null ? "null" : zChild.getClass().getName()) ); // } // pSourceNode.assertNoMoreChildren(); // AbstractFQFReferenceAndValue zFQF = create( pFinder, pReference ); // zFQF.LLsetValue( zChild.getClass(), ((AbstractBoxedSimpleType) zChild).getBoxedValue() ); // return zFQF; // } // // abstract protected AbstractFQFReferenceAndValue create( Finder pFinder, String pReference ); // } } |