compares given object against template condition object . for built-in type t like string , number precisely , from type t located in subpackage of `` java.lang . '' given object is directly compared with template object . comparison for conditiontype #equals requires correct implementation of object #equals object , using inequalities requires type t implementing comparable . for other types the comparison of given object against template object is done using its getters ; value returned by @linkplain #ismet object operation is conjunction ` and ` operator of comparisons of each getter accessible in object of type t. getters of template object that return null or throw exception are not used in comparison . finally , if all getters return nulls are excluded it is interpreted as no filter match every pojo . if #simplesearchcondition conditiontype , object constructor with shared operator was used , then getters are compared using the same operator . if #simplesearchcondition map , object constructor with map of operators was used then for every getter specified operator is used gettersfor missing mapping are ignored . the way that comparison per-getter is done depending on operator type per getter - comparison for conditiontype #equals requires correct implementation of object #equals object , using inequalities requires that getter type implements comparable . for equality comparison and string type in template object either being built-in or getter from client provided type it is allowed to used asterisk at the beginning or at the end of text as wild card zero or more of any characters e.g. `` foo '' , `` foo '' or `` foo '' . inner asterisks are not interpreted as wild cards . example : simplesearchcondition < integer > ssc = new simplesearchcondition < integer > conditiontype.greater _ than , 10 ; ssc.ismet 20 ; / / true since 20 > 10 class entity public string getname ... public int getlevel ... public string getmessage ... entity template = new entity `` bbb '' , 10 , null ; ssc = new simplesearchcondition < entity > conditiontype.greater _ than , template ; ssc.ismet new entity `` aaa '' , 20 , `` some mesage '' ; / / false : is not met , expression ' `` aaa '' > `` bbb '' and 20 > 10 ' is not true / / since `` aaa '' is not greater than `` bbb '' ; not that message is null in template hence ingored ssc.ismet new entity `` ccc '' , 30 , `` other message '' ; / / true : is met , expression ' `` ccc '' > `` bbb '' and 30 > 10 ' is true map < string , conditiontype > map ; map.put `` name '' , conditiontype.equals ; map.put `` level '' , conditiontype.greater _ than ; ssc = new simplesearchcondition < entity > conditiontype.greater _ than , template ; ssc.ismet new entity `` ccc '' , 30 , `` other message '' ; / / false due to expression ' `` aaa '' == `` ccc '' and 30 > 10 '' ' note different operators concode_field_sep T condition concode_elem_sep List<SearchCondition<T>> scts concode_elem_sep ConditionType joiningType concode_elem_sep Set<ConditionType> SUPPORTED_TYPES concode_field_sep ConditionType getConditionType concode_elem_sep Object getValue concode_elem_sep T getCondition concode_elem_sep List<SearchCondition<T>> getSearchConditions concode_elem_sep String toSQL concode_elem_sep List<SearchCondition<T>> createConditions concode_elem_sep Map<String,Object> getGettersAndValues concode_elem_sep boolean isBuiltIn concode_elem_sep List<T> findAll concode_elem_sep PrimitiveStatement getStatement concode_elem_sep void accept
boolean function ( T arg0 ) { for ( SearchCondition < T > loc0 : scts ) { if ( ! loc0 . isMet ( arg0 ) ) { return false ; } } return true ; }