org.argeo.api.acr/src/org/argeo/api/acr/search/ContentFilter.java

   1 package org.argeo.api.acr.search;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.List;
   6 import java.util.function.Consumer;
   7
   8 import javax.xml.namespace.QName;
   9
  10 import org.argeo.api.acr.QNamed;
  11
  12 /** A constraint filtering based ona given composition (and/or). */
  13 public abstract class ContentFilter<COMPOSITION extends Composition> implements Constraint {
  14         // even though not necessary, we use a list in order to have a predictable order
  15         private List<Constraint> constraints = new ArrayList<>();
  16
  17         private COMPOSITION composition;
  18
  19         boolean negateNextOperator = false;
  20
  21         @SuppressWarnings("unchecked")
  22         ContentFilter(Class<COMPOSITION> clss) {
  23                 if (clss == null)
  24                         this.composition = null;
  25                 else if (Intersection.class.isAssignableFrom(clss))
  26                         this.composition = (COMPOSITION) new Intersection(this);
  27                 else if (Union.class.isAssignableFrom(clss))
  28                         this.composition = (COMPOSITION) new Union(this);
  29                 else
  30                         throw new IllegalArgumentException("Unkown composition " + clss);
  31         }
  32
  33         /*
  34          * LOGICAL OPERATORS
  35          */
  36
  37         public COMPOSITION all(Consumer<AndFilter> and) {
  38                 AndFilter subFilter = new AndFilter();
  39                 and.accept(subFilter);
  40                 addConstraint(subFilter);
  41                 return composition;
  42         }
  43
  44         public COMPOSITION any(Consumer<OrFilter> or) {
  45                 OrFilter subFilter = new OrFilter();
  46                 or.accept(subFilter);
  47                 addConstraint(subFilter);
  48                 return composition;
  49         }
  50
  51         public ContentFilter<COMPOSITION> not() {
  52                 negateNextOperator = !negateNextOperator;
  53                 return this;
  54         }
  55
  56         /*
  57          * NON WEBDAV
  58          */
  59         public COMPOSITION isContentClass(QName... contentClass) {
  60                 addConstraint(new IsContentClass(contentClass));
  61                 return composition;
  62         }
  63
  64         public COMPOSITION isContentClass(QNamed... contentClass) {
  65                 addConstraint(new IsContentClass(contentClass));
  66                 return composition;
  67         }
  68
  69         /*
  70          * COMPARISON OPERATORS
  71          */
  72
  73         public COMPOSITION eq(QName attr, Object value) {
  74                 addConstraint(new Eq(attr, value));
  75                 return composition;
  76         }
  77
  78         public COMPOSITION eq(QNamed attr, Object value) {
  79                 return eq(attr.qName(), value);
  80         }
  81
  82         public COMPOSITION lt(QName attr, Object value) {
  83                 addConstraint(new Lt(attr, value));
  84                 return composition;
  85         }
  86
  87         public COMPOSITION lt(QNamed attr, Object value) {
  88                 return lt(attr.qName(), value);
  89         }
  90
  91         public COMPOSITION lte(QName attr, Object value) {
  92                 addConstraint(new Lte(attr, value));
  93                 return composition;
  94         }
  95
  96         public COMPOSITION lte(QNamed attr, Object value) {
  97                 return lte(attr.qName(), value);
  98         }
  99
 100         public COMPOSITION gt(QName attr, Object value) {
 101                 addConstraint(new Gt(attr, value));
 102                 return composition;
 103         }
 104
 105         public COMPOSITION gt(QNamed attr, Object value) {
 106                 return gt(attr.qName(), value);
 107         }
 108
 109         public COMPOSITION gte(QName attr, Object value) {
 110                 addConstraint(new Gte(attr, value));
 111                 return composition;
 112         }
 113
 114         public COMPOSITION gte(QNamed attr, Object value) {
 115                 return gte(attr.qName(), value);
 116         }
 117
 118         public COMPOSITION like(QName attr, String pattern) {
 119                 addConstraint(new Like(attr, pattern));
 120                 return composition;
 121         }
 122
 123         public COMPOSITION like(QNamed attr, String pattern) {
 124                 return like(attr.qName(), pattern);
 125         }
 126
 127         /*
 128          * PROPERTIES CONSTRAINTS
 129          */
 130
 131         public COMPOSITION isDefined(QName attr) {
 132                 addConstraint(new IsDefined(attr));
 133                 return composition;
 134         }
 135
 136         public COMPOSITION isDefined(QNamed attr) {
 137                 return isDefined(attr.qName());
 138         }
 139
 140         /*
 141          * UTILITIES
 142          */
 143         protected void addConstraint(Constraint operator) {
 144                 checkAddConstraint();
 145                 Constraint operatorToAdd;
 146                 if (negateNextOperator) {
 147                         operatorToAdd = new Not(operator);
 148                         negateNextOperator = false;
 149                 } else {
 150                         operatorToAdd = operator;
 151                 }
 152                 constraints.add(operatorToAdd);
 153         }
 154
 155         /** Checks that the root operator is not set. */
 156         private void checkAddConstraint() {
 157                 if (composition == null && !constraints.isEmpty())
 158                         throw new IllegalStateException("An operator is already registered (" + constraints.iterator().next()
 159                                         + ") and no composition is defined");
 160         }
 161
 162         /*
 163          * ACCESSORs
 164          */
 165         public Collection<Constraint> getConstraints() {
 166                 return constraints;
 167         }
 168
 169         public boolean isUnion() {
 170                 return composition instanceof Union;
 171         }
 172
 173         /*
 174          * CLASSES
 175          */
 176
 177 //      public static void main(String[] args) {
 178 //              AndFilter filter = new AndFilter();
 179 //              filter.eq(new QName("test"), "test").and().not().eq(new QName("type"), "integer");
 180 //
 181 //              OrFilter unionFilter = new OrFilter();
 182 //              unionFilter.all((f) -> {
 183 //                      f.eq(DName.displayname, "").and().eq(DName.creationdate, "");
 184 //              }).or().not().any((f) -> {
 185 //                      f.eq(DName.creationdate, "").or().eq(DName.displayname, "");
 186 //              });
 187 //
 188 //      }
 189
 190 }