Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * #%L
    * Wikitty :: api
    * %%
    * Copyright (C) 2009 - 2010 CodeLutin, Benjamin Poussin
    * %%
    * This program 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 3 of the 
   * License, or (at your option) any later version.
   * 
   * This program 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 General Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public 
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * #L%
   */
  package org.nuiton.wikitty.storage;
  
  import java.util.Arrays;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 public class WikittySearchEngineInMemory implements WikittySearchEngine {

    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(WikittySearchEngineInMemory.class);
 
 
     public WikittySearchEngineInMemory(WikittyStorageInMemory wikittyStorage) {
         this. = wikittyStorage;
     }
 
     @Override
     public void clear(WikittyTransaction transaction) {
         // do nothing
     }
 
     @Override
     public void store(WikittyTransaction transactionCollection<Wikittywikittiesboolean force) {
         // do nothing
     }
 
     @Override
     public void delete(WikittyTransaction transactionCollection<StringidListthrows WikittyException {
         // do nothing
     }
 
     static private boolean checkRestriction(WikittySearchEngine searchEngine,
             WikittyTransaction transactionCondition conditionWikitty w) {
         WikittyQueryVisitorCheckCondition v =
                 new WikittyQueryVisitorCheckCondition(searchEnginetransactionw);
         condition.accept(v);
         boolean result = v.getResult();
         return result;
     }

    
comparateur generic qui accept deux objets de meme type en argument
 
     static public Comparator<ObjectgenericComparator = new Comparator<Object>() {
         public int compare(Object v1Object v2) {
             if (v1 == null && v2 == null) {
                 return 0;
             } else if (v1 == null) {
                 return -1;
             } else if (v2 == null) {
                 return 1;
             }
 
             if (v1 == v2 || v1.equals(v2)) {
                 return 0;
             }
 
             if (v1 instanceof Collection) {
                 v1 = CollectionUtils.get(v1, 0);
             }
             if (v2 instanceof Collection) {
                 v2 = CollectionUtils.get(v2, 0);
             }
             Comparable c1;
             Comparable c2;
             if (v1 instanceof Comparable) {
                 c1 = (Comparable)v1;
             } else {
                 return 0; // non comparable on retourne 0
             }
             if (v2 instanceof Comparable) {
                 c2 = (Comparable)v2;
             } else {
                 return 0; // non comparable on retourne 0
             }
 
             int result = c1.compareTo(c2);
             return result;
         }
     };
 
     static public class WikittyComparator implements Comparator<Wikitty> {
 
         protected List<org.nuiton.wikitty.entities.Elementasc;
         protected List<org.nuiton.wikitty.entities.Elementdesc;
 
             this. = asc;
             this. = desc;
         }

        
compare un champs de deux objets Wikitty
 
         protected int compareValue(Wikitty o1Wikitty o2org.nuiton.wikitty.entities.Element eboolean asc) {
             Object v1 = o1.getFqField(e.getValue());
             Object v2 = o2.getFqField(e.getValue());
 
             int result = .compare(v1v2);
             if (!asc) {
                 result = result * -1;
             }
             return result;
         }
 
         public int compare(Wikitty o1Wikitty o2) {
             int result = 0;
 
             for (org.nuiton.wikitty.entities.Element e : ) {
                 result = compareValue(o1o2etrue);
                 if (result != 0) {
                     return result;
                 }
             }
             
             for (org.nuiton.wikitty.entities.Element e : ) {
                 result = compareValue(o1o2efalse);
                 if (result != 0) {
                     return result;
                 }
             }
             return result;
         }
 
     }
 
     static public class FacetPredicate {
         WikittyTransaction tx;
         WikittyQuery query;
         Map<StringMultisettopic;
         
         public FacetPredicate(WikittySearchEngine searchEngine
                 WikittyTransaction txWikittyQuery query) {
             this. = searchEngine;
             this. = tx;
             this. = query;
 
              = LazyMap.decorate(new HashMap(), new Factory() {
                 public Object create() {
                     return TreeMultiset.create();
                 }
             });
 
         }
 
         public Map<StringList<FacetTopic>> getFacets() {
             Map<StringList<FacetTopic>> result = new HashMap<StringList<FacetTopic>>();
             for (String facetName : .keySet()) {
                 List<FacetTopiclist = new ArrayList<FacetTopic>();
                 Multiset b = .get(facetName);
                 for (Object topicName : b.elementSet()) {
                     int count = b.count(topicName);
                     // pour ajouter le topic il faut un minimum indique dans la query
                     if (count >= .getFacetMinCount()) {
                         FacetTopic ft = new FacetTopic(facetName, String.valueOf(topicName), count);
                         list.add(ft);
                     }
                 }
 
                 // on re-tri si besoin, sinon l'ordre par defaut est sur la valeur des topics
                 if (.getFacetSort() == .) {
                     Collections.sort(list.getFacetSort().);
                 }
 
                 // ... et on en prend que le nombre demande
                 if (list.size() > .getFacetLimit()) {
                     list = list.subList(0, .getFacetLimit());
                 }
                 result.put(facetNamelist);
             }
             return result;
         }
 
         public boolean add(Wikitty w) {
             boolean result = false;
             
             // create facet extension
             if (.isFacetExtension()) {
                 String facetName = ..getValue();
                 for (String extName : w.getExtensionNames()) {
                     .get(facetName).add(extName);
                     result = true;
                 }
             }
 
             // create facet field
             for (org.nuiton.wikitty.entities.Element e : .getFacetField()) {
                 if (..equals(e)) {
                     String facetName = ..getValue();
                     for (String extName : w.getExtensionNames()) {
                         .get(facetName).add(extName);
                         result = true;
                     }
                 } else {
                     String fqf = e.getValue();
                     Object value = w.getFqField(fqf);
                     if (value != null) {
                         if (value instanceof Collection) {
                             .get(fqf).addAll((Collection)value);
                         } else {
                             .get(fqf).add(value);
                         }
                         result = true;
                     }
                 }
             }
 
             // create facet query
             for (FacetQuery q : .getFacetQuery()) {
                 if (checkRestriction(q.getCondition(), w)) {
                     String facetName = q.getName();
                     if (facetName == null) {
                         facetName = q.getCondition().toString();
                     }
                     .get(facetName).add(facetName);
                     result = true;
                 }
             }
 
             return result;
         }
     }
     
     @Override
     public WikittyQueryResult<Map<StringObject>> findAllByQuery(WikittyTransaction transactionWikittyQuery query) {
 
         // la condition select du query, sera traite a la fin
         Select select = null;
         WikittyQuery queryWithoutSelect = query;
 
             if (query.isSelectQuery()) {
                 select = query.getSelect();
                 // copy de la query sans le select
                 queryWithoutSelect = query.getWhereQuery();
                 if (queryWithoutSelect.getCondition() == null) {
                     queryWithoutSelect.setCondition(new org.nuiton.wikitty.query.conditions.True());
                 }
 
             }
 
 
         int offset = queryWithoutSelect.getOffset();
         int limit = queryWithoutSelect.getLimit();
         List<Stringids = new LinkedList<String>();
         FacetPredicate facets = new FacetPredicate(thistransactionqueryWithoutSelect);
 
         ArrayList<Wikittywikitties =
                 new ArrayList<Wikitty>(.getWikitties().values());
 
         // on tri les wikitties selon l'ordre demande ...
         if (!queryWithoutSelect.getSortAscending().isEmpty()
                 || !queryWithoutSelect.getSortDescending().isEmpty() ) {
             Collections.sort(wikittiesnew WikittyComparator(
                     queryWithoutSelect.getSortAscending(), queryWithoutSelect.getSortDescending()));
         }
 
         int totalResult = 0;
         for (Wikitty w : wikitties) {
             String id = w.getWikittyId();
             Condition c = queryWithoutSelect.getCondition();
             if (!w.isDeleted()) {
                 if (checkRestriction(thistransactioncw)) {
                     totalResult++;
                     if (totalResult > offset && ids.size() < limit) {
                         // ajout en tant que resultat
                         ids.add(id);
                     }
                     facets.add(w);
                 }
             }
         }
 
         List<Map<StringObject>> values = new ArrayList<Map<StringObject>>(ids.size());
         List<Map<StringObject>> selectResult = null;
         if (select == null) {
             String idTag = ......getValue();
             for (Object id : ids) {
                 values.add(WikittyUtil.singletonMap(idTagid));
             }
         } else {
             // Extract data
             for (String id : ids) {
                 Wikitty w = .getWikitties().get(id);
                 Map<StringObjectmap = new LinkedHashMap<StringObject>(w.getFieldValue());
                 map.put(......getValue(), id);
                 values.add(map);
             }
 
             values = select.getFunction().call(queryvalues);
             selectResult = values;
         }
 
 
         WikittyQueryResult<Map<StringObject>> result =
                 new WikittyQueryResult<Map<StringObject>>(
                 queryWithoutSelect.getName(), offsettotalResult,
                 queryqueryWithoutSelect.getCondition().toString(),
                 valuesselectResultidsfacets.getFacets(), 0, 0);
 
         return result;
     }
 
     @Override
             String wikittyIdint depthboolean countWikittyQuery filter) {
         // FIXME
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     static public class WikittyQueryVisitorCheckCondition extends WikittyQueryVisitor {
 
         protected WikittySearchEngine searchEngine;
        
transaction used to check wikitty
 
         protected WikittyTransaction tx;
        
wikitty to check
 
         protected Wikitty w;
        
la pile d'evaluation des differencetes contraintes
 
         protected Deque<BooleanevalStack = new LinkedList<Boolean>();
 
         public boolean getResult() {
             Boolean result = .poll();
             if (result == null) {
                 // s'il n'y avait pas de condition, la stack est vide, donc
                 // c'est vrai
                 result = .;
             }
             return result;
         }
 
         public WikittyQueryVisitorCheckCondition(
                 WikittySearchEngine searchEngineWikittyTransaction txWikitty w) {
             this. = searchEngine;
             this. = tx;
             this. = w;
         }

        
Interface permettant de verifier une condition sur deux collections
 
         static private interface Predicate {
            
retourne vrai si la condition est validee

Parameters:
type type des elements des collections. Si null alors les collection contiennent des String (id ou nom extension)
value l'ensemble des valeur du champs
expected l'ensemble des valeurs attendue
Returns:
vrai si la condition est validee
 
             boolean check(FieldType typeCollection valuesCollection expected);
         }
 
         static private Predicate BetweenPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() == 2) {
                         // si on a pas deux valeur, c'est qu'on a pas min et max
                         Iterator i = expected.iterator();
                         Object min = i.next();
                         Object max = i.next();
                         for (Object fieldValue : values) {
                             // fieldValue doit etre comparable
                             if (fieldValue instanceof Comparable) {
                                 // recupere le type de la valeur
 
                                 result = ((ComparablefieldValue).compareTo(min) >= 0
                                         && ((ComparablefieldValue).compareTo(max) <= 0;
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate ContainsAllPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result = false;
                     if (values != null) {
                         expected = CollectionUtils.subtract(expectedvalues);
                         // si lorsqu'on retire tous les elements en commun avec la valeur
                         // du champs il ne reste plus rien, c'est que le containsAll est
                         // vrai
                         result = expected.isEmpty();
                     }
                     return result;
 
                 }
             };
 
         static private Predicate ContainsOnePredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result = false;
                     if (values != null) {
                         expected = CollectionUtils.retainAll(expectedvalues);
                         // si lorsqu'on retient tous les elements en commun avec la valeur
                         // du champs il ne reste plus rien, c'est que le containsOne est
                         // faux, donc il faut qu'il en reste
                         result = !expected.isEmpty();
                     }
                     return result;
                 }
             };
 
         static private Predicate EqualsPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result = false;
                     if (values != null && expected.size() > 0) {
                         // gestion des type STRING differement car il peut y avoir des '*'
                         if (type != null && type.getType() == .) {
                             Iterator i = expected.iterator();
                             String exp = String.valueOf(i.next());
                             for (Object fieldValue : values) {
                                 String val = String.valueOf(fieldValue);
                                 result = matchString(valexpfalse);
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         } else {
                             expected = CollectionUtils.subtract(expectedvalues);
                             // si lorsqu'on retire tous les elements en commun avec la valeur
                             // du champs il ne reste plus rien, c'est que le equals est
                             // vrai
                             result = expected.isEmpty();
                         }
                     }
                     return result;
 
                 }
             };
 
         static private Predicate EqualsIgnoreCaseAndAccentPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result = false;
                     if (values != null && expected.size() > 0) {
                         // gestion des type STRING differement car il peut y avoir des '*'
                         if (type != null && type.getType() == .) {
                             Iterator i = expected.iterator();
                             String exp = String.valueOf(i.next());
                             for (Object fieldValue : values) {
                                 String val = String.valueOf(fieldValue);
                                 result = matchString(valexptrue);
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         } else {
                             expected = CollectionUtils.subtract(expectedvalues);
                             // si lorsqu'on retire tous les elements en commun avec la valeur
                             // du champs il ne reste plus rien, c'est que le equals est
                             // vrai
                             result = expected.isEmpty();
                         }
                     }
                     return result;
 
                 }
             };
 
         static private Predicate GreaterPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         Object val = i.next();
                         for (Object fieldValue : values) {
                             // fieldValue doit etre comparable
                             if (fieldValue instanceof Comparable) {
                                 // recupere le type de la valeur
                                 result = ((ComparablefieldValue).compareTo(val) > 0;
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate GreaterOrEqualsPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         Object val = i.next();
                         for (Object fieldValue : values) {
                             // fieldValue doit etre comparable
                             if (fieldValue instanceof Comparable) {
                                 // recupere le type de la valeur
                                 result = ((ComparablefieldValue).compareTo(val) >= 0;
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate LessPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         Object val = i.next();
                         for (Object fieldValue : values) {
                             // fieldValue doit etre comparable
                             if (fieldValue instanceof Comparable) {
                                 // recupere le type de la valeur
                                 result = ((ComparablefieldValue).compareTo(val) < 0;
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate LessOrEqualsPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         Object val = i.next();
                         for (Object fieldValue : values) {
                             // fieldValue doit etre comparable
                             if (fieldValue instanceof Comparable) {
                                 // recupere le type de la valeur
                                 result = ((ComparablefieldValue).compareTo(val) <= 0;
                                 if (result) {
                                     // si une des valeurs correspond, on retourne true
                                     break;
                                 }
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate KeywordPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         String exp = String.valueOf(i.next());
                         for (Object fieldValue : values) {
                             String val = String.valueOf(fieldValue);
                             result = matchString(valexptrue);
                             if (result) {
                                 // si une des valeurs correspond, on retourne true
                                 break;
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate LikePredicate = new Predicate() {
             public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  false;
 
                     if (values != null && expected.size() > 0) {
                         // si on a pas une valeur, c'est pas bon :(
                         Iterator i = expected.iterator();
                         String exp = String.valueOf(i.next());
                         for (Object fieldValue : values) {
                             String val = String.valueOf(fieldValue);
                             result = matchString(valexptrue);
                             if (result) {
                                 // si une des valeurs correspond, on retourne true
                                 break;
                             }
                         }
                     }
                     return result;
                 }
             };
 
         static private Predicate NullPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  values == null || values.contains(null);
                     return result;
                 }
             };
 
         static private Predicate NotNullPredicate = new Predicate() {
                 public boolean check(FieldType typeCollection valuesCollection expected) {
                     boolean result =  values != null && !values.contains(null);
                     return result;
                 }
             };



        
check if string match other string.

Parameters:
s string
sub string to match with 's' parameter. This string can start or and with star '*'
ignoreCaseAndAccent if true match is done in ingore case mode
Returns:
true if sub match s
 
         static private boolean matchString(String sString subboolean ignoreCaseAndAccent) {
             if (ignoreCaseAndAccent) {
                 s = StringUtils.stripAccents(s);
                 s = s.toLowerCase();
 
                 sub = StringUtils.stripAccents(sub);
                 sub = sub.toLowerCase();
             }
             sub = sub.replaceAll("\\*"".*");
             sub = sub.replaceAll("\\?"".");
             
             boolean result = s.matches(sub);
             return result;
         }

        
Collecte les valeur possible de l'element demande

Parameters:
e l'element demande. Peut etre l'id, l'extension ou un champs. le champs pouvant contenir des * pour remplacer le nom de extension ou le nom du champs (ex: *.name, myext.*)
values une map avec en cle le nom du champs et en valeur la valeur du champs
 
         protected void collectFieldValue(
                 org.nuiton.wikitty.entities.Element e,
                 Map<StringCollectionvalues) {
             if (e instanceof ElementId) {
                 values.put(e.getValue(), Collections.singleton(.getWikittyId()));
             } else if (e instanceof ElementExtension) {
                 values.put(e.getValue(), .getExtensionNames());
             } else {
                 String fqf = e.getValue();
                 if (.hasField(fqf)) {
                     Object v = .getFqField(fqf);
                     values.put(fqfconvert(nullv));
                 } else {
                     String extName = WikittyExtension.extractExtensionName(fqf);
                     String fieldName = WikittyExtension.extractFieldName(fqf);
                     if ("*".equals(extName) && "*".equals(fieldName)) {
                         // on ajoute tous les champs de toutes les extensions
                         for (String f : .getAllFieldNames()) {
                             Object v = .getFqField(f);
                             values.put(fconvert(nullv));
                         }
                     } else if ("*".equals(fieldName)){
                         // on ajoute tous les champs de l'extension demandee
                         for (String f : .getExtension(extName).getFieldNames()) {
                             String fq = WikittyUtil.getFQFieldName(extNamef);
                             Object v = .getFqField(fq);
                             values.put(fqconvert(nullv));
                         }
                     } else if ("*".equals(extName)){
                         // on ajoute tous les champs ayant le nom demande
                         // quelque soit l'extension
                         for (String ext : .getExtensionNames()) {
                             for (String f : .getExtension(ext).getFieldNames()) {
                                 if (f.equals(fieldName)) {
                                     String fq = WikittyUtil.getFQFieldName(extf);
                                     Object v = .getFqField(fq);
                                     values.put(fqconvert(nullv));
                                 }
                             }
                         }
                     }
                 }
             }
         }

        
Converti o en une list de valeur compatible avec type

Parameters:
type le type dans lequel doit etre converti o
o la valeur a convertir, si o est une collection, chaque element de la collection est converti
Returns:
une nouvelle collection avec les elements dans le bon type
 
         protected Collection<Objectconvert(FieldType typeObject o) {
             Collection<Objectresult;
             try {
                 if (o instanceof Collection) {
                     // order of collection must be maintained, for that use LinkedHashSet
                     if (type == null) {
                         // if type is null don't change type (in case of id or extension
                         // or when we know object is already in right type)
                         result = new LinkedHashSet<Object>((Collection<Object>)o);
                     } else {
                         result = new LinkedHashSet<Object>();
                         for (Object v : (Collection)o) {
                             result.add(type.getContainedValidObject(v));
                         }
                     }
                 } else {
                     if (type != null) {
                         // if type is null don't change type (in case of id or extension
                         // or when we know object is already in right type)
                         o = type.getContainedValidObject(o);
                     }
                     result = Collections.singleton(o);
                 }
             } catch (Exception eee) {
                 // si on arrive pas a convertir on retourne null
                 result = null;
                 if (.isTraceEnabled()) {
                     .trace("not an error but can't convert string to wanted type"eee);
                 }
             }
             return result;
         }

        
Verifie qu'un predicat est vrai pour un element et une valeur attendu

Parameters:
predicate le predicat a verifier
element l'element mis en cause (id, extension, field)
expected la/les valeur(s) attendu(s)
Returns:
vrai si le predicat est verifie
 
         protected boolean check(Predicate predicate,
                 org.nuiton.wikitty.entities.Element elementObject expected) {
             if (element instanceof ElementField) {
                 String fqf = element.getValue();
                 // suppression du type dans l'element, car on en a pas besoin
                 String extName = WikittyUtil.getExtensionNameFromFQFieldName(fqf);
                 String fieldName = WikittyUtil.getFieldNameFromFQFieldName(fqf);
                 // on reconstruit fqf, sans l'optionnel 3eme composantes (Type)
                 fqf = WikittyUtil.getFQFieldName(extNamefieldName);
                 element = org.nuiton.wikitty.entities.Element.get(fqf);
             }
 
             boolean result = false;
 
             boolean isIndexed = true;
             Map<StringCollectionfieldValues = new HashMap<StringCollection>();
             collectFieldValue(elementfieldValues);
             for (String fqf : fieldValues.keySet()) {
                 FieldType type = null;
                 if (.hasField(fqf)) {
                     type = .getFieldType(fqf);
                     isIndexed = type.isIndexed();
                 }
                 Collection<Objectcontained = convert(typeexpected);
                 if (isIndexed && contained != null) {
                     // si on a reussi a convertir dans le bon type on fait la verif
                     Collection values;
                     values = fieldValues.get(fqf);
                     
                     result = predicate.check(typevaluescontained);
                     if (result) {
                         // on a reussi a verifie le predicat pour au moins un champs
                         // on renvoie donc true
                         break;
                     }
                 }
             }
             return result;
         }
 
         @Override
         public void visit(ConditionValueString o) {
             // do nothing
         }
 
         @Override
         public boolean visitEnter(WikittyQuery o) {
             // nothing to do
             return true;
         }
 
         @Override
         public void visitLeave(WikittyQuery oboolean enterOrMiddleResult) {
             // nothing to do
         }
 
         @Override
         public boolean visitEnter(org.nuiton.wikitty.query.conditions.And o) {
             .push(.);
             return true;
         }
 
         @Override
         public boolean visitMiddle(org.nuiton.wikitty.query.conditions.And o) {
             // l'evaluation du dernier element du and
             Boolean last = .pop();
             // la valeur courante du and
             Boolean currentValue = .pop();
 
             Boolean result = currentValue && last;
             .push(result);
 
             // si le and est deja faut ca ne sert a rien de d'evaluer la suite
             return result;
         }
 
         @Override
         public void visitLeave(org.nuiton.wikitty.query.conditions.And oboolean enterOrMiddleResult) {
             Boolean last = .;
             if (enterOrMiddleResult && o.getConditions().size()>0) {
                 // si enter ou middle on renvoye false, alors on a pas
                 // de nouvelle condition a prendre dans la pile sinon
                 // l'evaluation du dernier element du and
                 last = .pop();
             }
             // la valeur courante du and
             Boolean currentValue = .pop();
 
             Boolean result = currentValue && last;
             .push(result);
         }
 
         @Override
         public boolean visitEnter(org.nuiton.wikitty.query.conditions.Or o) {
             // si le or n'a aucun element, alors il est vrai
             if (o.getConditions().isEmpty()) {
                 .push(.);
             } else {
                 // sinon, il faut qu'un de ses elements soit vrai pour etre vrai
                 .push(.);
             }
             return true;
         }
 
         @Override
         public boolean visitMiddle(org.nuiton.wikitty.query.conditions.Or o) {
             // l'evaluation du dernier element du or
             Boolean last = .pop();
             // la valeur courante du or
             Boolean currentValue = .pop();
 
             Boolean result = currentValue || last;
             .push(result);
 
             // si le or est deja vrai, ca ne sert a rien d'evaluer la suite
             return !result;
         }
 
         @Override
         public void visitLeave(org.nuiton.wikitty.query.conditions.Or oboolean enterOrMiddleResult) {
             Boolean last = .;
             if (enterOrMiddleResult && o.getConditions().size()>0) {
                 // si enter ou middle on renvoye false, alors on a pas
                 // de nouvelle condition a prendre dans la pile sinon
                 // l'evaluation du dernier element du or
                 last = .pop();
             }
             // la valeur courante du or
             Boolean currentValue = .pop();
 
             Boolean result = currentValue || last;
             .push(result);
         }
 
         @Override
         public boolean visitEnter(Select o) {
             // do nothing
             return true;
         }
 
         @Override
         public boolean visitMiddle(Select o) {
             // do nothing
             return true;
         }
 
 
         @Override
         public void visitLeave(Select oboolean enterOrMiddleResult) {
             // do nothing
         }
 
         protected List<StringevalConditionValueAsList(List<ConditionValueo) {
             List<Stringresult = new ArrayList<String>(o.size());
             for (ConditionValue c : o) {
                 result.addAll(evalConditionValueAsList(c));
             }
             return result;
         }
 
         protected List<StringevalConditionValueAsList(ConditionValue o) {
            List<Stringresult = new ArrayList<String>();
            if (o instanceof Select) {
                WikittyQuery query = new WikittyQuery(o);
                // eval select
                WikittyQueryResult<StringselectResult =
                        .findAllByQuery(query).convertMapToSimpleString();
                result.addAll(selectResult.getAll());
            } else if (o instanceof ConditionValueString) {
                result.add(((ConditionValueString)o).getValue());
            } else {
                throw new WikittyException(String.format(
                        "ConditionValue type unsupported %s",
                        ClassUtils.getShortCanonicalName(o"null")));
            }
            return result;
        }
        protected String evalConditionValue(ConditionValue o) {