ExistsFilter
Code IndexAdd Codota to your IDE (free)

Best code snippets using com.evolveum.midpoint.prism.query.ExistsFilter(Showing top 15 results out of 315)

origin: Evolveum/midpoint

@SuppressWarnings("CloneDoesntCallSuperClone")
@Override
public ObjectFilter clone() {
  ObjectFilter f = filter != null ? filter.clone() : null;
  return new ExistsFilter(fullPath, definition, f);
}
origin: Evolveum/midpoint

public ExistsFilter(@NotNull ItemPath fullPath, ItemDefinition definition, ObjectFilter filter) {
  this.fullPath = fullPath;
  this.definition = definition;
  this.filter = filter;
  checkConsistence(true);
}
origin: Evolveum/midpoint

public static <C extends Containerable> ExistsFilter createExists(ItemPath itemPath, PrismContainerDefinition<C> containerDef,
                                 ObjectFilter filter) throws SchemaException {
  ItemDefinition itemDefinition = FilterUtils.findItemDefinition(itemPath, containerDef);
  return new ExistsFilter(itemPath, itemDefinition, filter);
}
origin: Evolveum/midpoint

private static MapXNode serializeExistsFilter(ExistsFilter filter, PrismSerializer<RootXNode> xnodeSerializer) throws SchemaException{
  MapXNode content = new MapXNode();
  serializePath(content, filter.getFullPath(), filter);
  if (filter.getFilter() != null){
    content.put(ELEMENT_FILTER, serializeFilter(filter.getFilter(), xnodeSerializer));
  }
  return createFilter(CLAUSE_EXISTS, content);
}
origin: Evolveum/midpoint

public ExistsRestriction(InterpretationContext context, ExistsFilter filter, JpaEntityDefinition baseEntityDefinition,
             Restriction parent) {
  super(context, filter, filter.getFullPath(), null, baseEntityDefinition, parent);
}
origin: Evolveum/midpoint

@Override
public String debugDump() {
  return debugDump(0);
}
origin: Evolveum/midpoint

private static ExistsFilter parseExistsFilter(MapXNode clauseXMap, PrismContainerDefinition pcd, boolean preliminaryParsingOnly, PrismContext prismContext) throws SchemaException{
  ItemPath path = getPath(clauseXMap);
  XNode subXFilter = clauseXMap.get(ELEMENT_FILTER);
  ObjectFilter subFilter = null;
  PrismContainerDefinition subPcd = pcd != null ? pcd.findContainerDefinition(path) : null;
  if (subXFilter != null && subXFilter instanceof MapXNode) {
    subFilter = parseFilterInternal((MapXNode) subXFilter, subPcd, preliminaryParsingOnly, prismContext);
  }
  if (preliminaryParsingOnly) {
    return null;
  } else {
    // to report exception only when the filter is really to be used
    checkExtraElements(clauseXMap, ELEMENT_PATH, ELEMENT_FILTER);
    return ExistsFilter.createExists(path, pcd, subFilter);
  }
}
origin: Evolveum/midpoint

@Test
public void test520ExistsUndefined() throws Exception {
  System.out.println("===[ test520ExistsUndefined ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = QueryBuilder.queryFor(UserType.class, prismContext)
      .exists(UserType.F_ASSIGNMENT).undefined()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", new ItemPath(UserType.F_ASSIGNMENT), existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}
origin: Evolveum/midpoint

@Override
public String debugDump(int indent) {
  StringBuilder sb = new StringBuilder();
  DebugUtil.indentDebugDump(sb, indent);
  sb.append("EXISTS: ");
  sb.append(fullPath);
  sb.append('\n');
  DebugUtil.indentDebugDump(sb, indent + 1);
  sb.append("DEF: ");
  if (getDefinition() != null) {
    sb.append(getDefinition().toString());
  } else {
    sb.append("null");
  }
  if (filter != null) {
    sb.append(filter.debugDump(indent + 1));
  }
  return sb.toString();
}
origin: Evolveum/midpoint

@Test
public void test156ExistsAndSomething() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
        .none()
      .and().all()
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      AndFilter.createAnd(
          ExistsFilter.createExists(
              new ItemPath(UserType.F_ASSIGNMENT),
              userPcd,
              NoneFilter.createNone()
          ),
          AllFilter.createAll()
      )
  );
  compare(actual, expected);
}
origin: Evolveum/midpoint

@Test
public void test150ExistsWithEquals() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
      .item(AssignmentType.F_DESCRIPTION).startsWith("desc1")
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      ExistsFilter.createExists(
          new ItemPath(UserType.F_ASSIGNMENT),
          userPcd,
          SubstringFilter.createSubstring(
              new ItemPath(AssignmentType.F_DESCRIPTION),
              assCtd.findPropertyDefinition(AssignmentType.F_DESCRIPTION),
              getPrismContext(),
              null, "desc1", true, false)
      )
      );
  compare(actual, expected);
}
origin: Evolveum/midpoint

public static <C extends Containerable> ExistsFilter createExists(ItemPath itemPath, Class<C> clazz, PrismContext prismContext,
                                 ObjectFilter filter) {
  ItemDefinition itemDefinition = FilterUtils.findItemDefinition(itemPath, clazz, prismContext);
  return new ExistsFilter(itemPath, itemDefinition, filter);
}
origin: Evolveum/midpoint

public ExistsFilter cloneEmpty() {
  return new ExistsFilter(fullPath, definition, null);
}
origin: Evolveum/midpoint

@Test
public void test500ExistsAll() throws Exception {
  System.out.println("===[ test500ExistsAll ]===");
  // GIVEN
  PrismContext prismContext = PrismTestUtil.getPrismContext();
  // WHEN
  ObjectFilter filter = QueryBuilder.queryFor(UserType.class, prismContext)
      .exists(UserType.F_ASSIGNMENT).all()
      .buildFilter();
  System.out.println("Original filter:\n" + filter.debugDump());
  // THEN
  ObjectFilter simplified = ObjectQueryUtil.simplify(filter);
  System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified));
  assertTrue("Wrong simplified filter: " + simplified, simplified instanceof ExistsFilter);
  ExistsFilter existsSimplified = (ExistsFilter) simplified;
  assertEquals("Wrong simplified filter path", new ItemPath(UserType.F_ASSIGNMENT), existsSimplified.getFullPath());
  assertTrue("Wrong simplified filter subfilter: " + existsSimplified.getFilter(), ObjectQueryUtil.isAll(existsSimplified.getFilter()));
}
origin: Evolveum/midpoint

@Test
public void test151ExistsWithEquals2() throws Exception{
  ObjectQuery actual = QueryBuilder.queryFor(UserType.class, getPrismContext())
      .exists(UserType.F_ASSIGNMENT)
      .item(AssignmentType.F_NOTE).endsWith("DONE.")
      .build();
  ComplexTypeDefinition assCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByCompileTimeClass(AssignmentType.class);
  PrismContainerDefinition userPcd = getPrismContext().getSchemaRegistry().findContainerDefinitionByCompileTimeClass(UserType.class);
  ObjectQuery expected = ObjectQuery.createObjectQuery(
      ExistsFilter.createExists(
          new ItemPath(UserType.F_ASSIGNMENT),
          userPcd,
          SubstringFilter.createSubstring(
              new ItemPath(AssignmentType.F_NOTE),
              assCtd.findPropertyDefinition(AssignmentType.F_NOTE),
              getPrismContext(),
              null, "DONE.", false, true)
      )
  );
  compare(actual, expected);
}
com.evolveum.midpoint.prism.queryExistsFilter

Javadoc

TODO think about creating abstract ItemFilter (ItemRelatedFilter) for this filter and ValueFilter.

Most used methods

  • getFilter
  • getFullPath
  • createExists
  • getDefinition
  • <init>
  • checkConsistence
  • cloneEmpty
  • debugDump
  • setFilter

Popular classes and methods

  • getContentResolver (Context)
  • getResourceAsStream (ClassLoader)
    Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
  • setRequestProperty (URLConnection)
    Sets the value of the specified request header field. The value will only be used by the current URL
  • FileNotFoundException (java.io)
    Thrown when a file specified by a program cannot be found.
  • Proxy (java.net)
    This class represents a proxy setting, typically a type (http, socks) and a socket address. A Proxy
  • Stack (java.util)
    Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables us
  • Vector (java.util)
    Vector is an implementation of List, backed by an array and synchronized. All optional operations in
  • Executors (java.util.concurrent)
    Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
  • ThreadPoolExecutor (java.util.concurrent)
    An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
  • JFrame (javax.swing)

For IntelliJ IDEA,
Android Studio or Eclipse

  • Codota IntelliJ IDEA pluginCodota Android Studio pluginCode IndexSign in
  • EnterpriseFAQAboutContact Us
  • Terms of usePrivacy policyCodeboxFind Usages
Add Codota to your IDE (free)