ISPN-7756 Rename all pseudo-JPA filtering classes to Ickle

client/hotrod-client/src/test/java/org/infinispan/client/hotrod/event/EmbeddedCompatClientListenerWithDslFilterTest.java

@@ -44,7 +44,7 @@
 import org.infinispan.query.remote.ProtobufMetadataManager;
 import org.infinispan.query.remote.client.FilterResult;
 import org.infinispan.query.remote.client.ProtobufMetadataManagerConstants;
-import org.infinispan.query.remote.impl.filter.JPACacheEventFilterConverterFactory;
+import org.infinispan.query.remote.impl.filter.IckleCacheEventFilterConverterFactory;
 import org.infinispan.util.logging.Log;
 import org.infinispan.util.logging.LogFactory;
 import org.testng.annotations.Test;
@@ -70,9 +70,9 @@ protected void createCacheManagers() throws Throwable {
 
       // Register the filter/converter factory. This should normally be discovered by the server via class path instead
       // of being added manually here, but this is ok in a test.
-      JPACacheEventFilterConverterFactory factory = new JPACacheEventFilterConverterFactory();
+      IckleCacheEventFilterConverterFactory factory = new IckleCacheEventFilterConverterFactory();
       for (int i = 0; i < NUM_NODES; i++) {
-         server(i).addCacheEventFilterConverterFactory(JPACacheEventFilterConverterFactory.FACTORY_NAME, factory);
+         server(i).addCacheEventFilterConverterFactory(IckleCacheEventFilterConverterFactory.FACTORY_NAME, factory);
       }
 
       remoteCache = client(0).getCache();

client/hotrod-client/src/test/java/org/infinispan/client/hotrod/event/EmbeddedCompatContinuousQueryTest.java

@@ -41,7 +41,7 @@
 import org.infinispan.query.remote.CompatibilityProtoStreamMarshaller;
 import org.infinispan.query.remote.ProtobufMetadataManager;
 import org.infinispan.query.remote.client.ProtobufMetadataManagerConstants;
-import org.infinispan.query.remote.impl.filter.JPAContinuousQueryProtobufCacheEventFilterConverterFactory;
+import org.infinispan.query.remote.impl.filter.IckleContinuousQueryProtobufCacheEventFilterConverterFactory;
 import org.infinispan.test.TestingUtil;
 import org.infinispan.util.ControlledTimeService;
 import org.infinispan.util.KeyValuePair;
@@ -72,9 +72,9 @@ protected void createCacheManagers() throws Throwable {
 
       // Register the filter/converter factory. This should normally be discovered by the server via class path instead
       // of being added manually here, but this is ok in a test.
-      JPAContinuousQueryProtobufCacheEventFilterConverterFactory factory = new JPAContinuousQueryProtobufCacheEventFilterConverterFactory();
+      IckleContinuousQueryProtobufCacheEventFilterConverterFactory factory = new IckleContinuousQueryProtobufCacheEventFilterConverterFactory();
       for (int i = 0; i < NUM_NODES; i++) {
-         server(i).addCacheEventFilterConverterFactory(JPAContinuousQueryProtobufCacheEventFilterConverterFactory.FACTORY_NAME, factory);
+         server(i).addCacheEventFilterConverterFactory(IckleContinuousQueryProtobufCacheEventFilterConverterFactory.FACTORY_NAME, factory);
          TestingUtil.replaceComponent(server(i).getCacheManager(), TimeService.class, timeService, true);
       }
 

client/hotrod-client/src/test/java/org/infinispan/client/hotrod/event/RemoteContinuousQueryTest.java

@@ -37,7 +37,7 @@
 import org.infinispan.query.dsl.QueryFactory;
 import org.infinispan.query.dsl.embedded.testdomain.User;
 import org.infinispan.query.remote.client.ProtobufMetadataManagerConstants;
-import org.infinispan.query.remote.impl.filter.JPAContinuousQueryProtobufCacheEventFilterConverterFactory;
+import org.infinispan.query.remote.impl.filter.IckleContinuousQueryProtobufCacheEventFilterConverterFactory;
 import org.infinispan.test.TestingUtil;
 import org.infinispan.util.ControlledTimeService;
 import org.infinispan.util.KeyValuePair;
@@ -68,9 +68,9 @@ protected void createCacheManagers() throws Throwable {
 
       // Register the filter/converter factory. This should normally be discovered by the server via class path instead
       // of being added manually here, but this is ok in a test.
-      JPAContinuousQueryProtobufCacheEventFilterConverterFactory factory = new JPAContinuousQueryProtobufCacheEventFilterConverterFactory();
+      IckleContinuousQueryProtobufCacheEventFilterConverterFactory factory = new IckleContinuousQueryProtobufCacheEventFilterConverterFactory();
       for (int i = 0; i < NUM_NODES; i++) {
-         server(i).addCacheEventFilterConverterFactory(JPAContinuousQueryProtobufCacheEventFilterConverterFactory.FACTORY_NAME, factory);
+         server(i).addCacheEventFilterConverterFactory(IckleContinuousQueryProtobufCacheEventFilterConverterFactory.FACTORY_NAME, factory);
          TestingUtil.replaceComponent(server(i).getCacheManager(), TimeService.class, timeService, true);
       }
 

client/hotrod-client/src/test/java/org/infinispan/client/hotrod/event/RemoteListenerWithDslFilterTest.java

@@ -42,7 +42,7 @@
 import org.infinispan.query.dsl.embedded.testdomain.User;
 import org.infinispan.query.remote.client.FilterResult;
 import org.infinispan.query.remote.client.ProtobufMetadataManagerConstants;
-import org.infinispan.query.remote.impl.filter.JPACacheEventFilterConverterFactory;
+import org.infinispan.query.remote.impl.filter.IckleCacheEventFilterConverterFactory;
 import org.infinispan.util.logging.Log;
 import org.infinispan.util.logging.LogFactory;
 import org.testng.annotations.Test;
@@ -68,9 +68,9 @@ protected void createCacheManagers() throws Throwable {
 
       // Register the filter/converter factory. This should normally be discovered by the server via class path instead
       // of being added manually here, but this is ok in a test.
-      JPACacheEventFilterConverterFactory factory = new JPACacheEventFilterConverterFactory();
+      IckleCacheEventFilterConverterFactory factory = new IckleCacheEventFilterConverterFactory();
       for (int i = 0; i < NUM_NODES; i++) {
-         server(i).addCacheEventFilterConverterFactory(JPACacheEventFilterConverterFactory.FACTORY_NAME, factory);
+         server(i).addCacheEventFilterConverterFactory(IckleCacheEventFilterConverterFactory.FACTORY_NAME, factory);
       }
 
       remoteCache = client(0).getCache();

query/src/main/java/org/infinispan/query/Search.java

@@ -13,8 +13,8 @@
 import org.infinispan.query.dsl.QueryFactory;
 import org.infinispan.query.dsl.embedded.impl.EmbeddedQueryEngine;
 import org.infinispan.query.dsl.embedded.impl.EmbeddedQueryFactory;
-import org.infinispan.query.dsl.embedded.impl.JPACacheEventFilterConverter;
-import org.infinispan.query.dsl.embedded.impl.JPAFilterAndConverter;
+import org.infinispan.query.dsl.embedded.impl.IckleCacheEventFilterConverter;
+import org.infinispan.query.dsl.embedded.impl.IckleFilterAndConverter;
 import org.infinispan.query.dsl.impl.BaseQuery;
 import org.infinispan.query.impl.SearchManagerImpl;
 import org.infinispan.query.logging.Log;
@@ -40,8 +40,8 @@ public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult>
    }
 
    public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult> makeFilter(String queryString, Map<String, Object> namedParameters) {
-      JPAFilterAndConverter<K, V> filterAndConverter = new JPAFilterAndConverter<>(queryString, namedParameters, ReflectionMatcher.class);
-      return new JPACacheEventFilterConverter<>(filterAndConverter);
+      IckleFilterAndConverter<K, V> filterAndConverter = new IckleFilterAndConverter<>(queryString, namedParameters, ReflectionMatcher.class);
+      return new IckleCacheEventFilterConverter<>(filterAndConverter);
    }
 
    public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult> makeFilter(Query query) {

query/src/main/java/org/infinispan/query/continuous/impl/ContinuousQueryImpl.java

@@ -46,8 +46,8 @@ public <C> void addContinuousQueryListener(String queryString, ContinuousQueryLi
    @Override
    public <C> void addContinuousQueryListener(String queryString, Map<String, Object> namedParameters, ContinuousQueryListener<K, C> listener) {
       EntryListener<K, V, C> entryListener = new EntryListener<>(listener);
-      JPAContinuousQueryCacheEventFilterConverter<K, V, ContinuousQueryResult<V>> filterConverter
-            = new JPAContinuousQueryCacheEventFilterConverter<>(queryString, namedParameters, ReflectionMatcher.class);
+      IckleContinuousQueryCacheEventFilterConverter<K, V, ContinuousQueryResult<V>> filterConverter
+            = new IckleContinuousQueryCacheEventFilterConverter<>(queryString, namedParameters, ReflectionMatcher.class);
       cache.addListener(entryListener, filterConverter, null);
       listeners.add(entryListener);
    }

query/src/main/java/org/infinispan/query/continuous/impl/ContinuousQueryResult.java

@@ -95,7 +95,7 @@ public ContinuousQueryResult readObject(ObjectInput input) throws IOException, C
 
       @Override
       public Integer getId() {
-         return ExternalizerIds.JPA_CONTINUOUS_QUERY_RESULT;
+         return ExternalizerIds.ICKLE_CONTINUOUS_QUERY_RESULT;
       }
 
       @Override

query/src/main/java/org/infinispan/query/continuous/impl/JPAContinuousQueryCacheEventFilterConverter.java → query/src/main/java/org/infinispan/query/continuous/impl/IckleContinuousQueryCacheEventFilterConverter.java

@@ -27,7 +27,7 @@
  * @author anistor@redhat.com
  * @since 8.0
  */
-public class JPAContinuousQueryCacheEventFilterConverter<K, V, C> extends AbstractCacheEventFilterConverter<K, V, C>
+public class IckleContinuousQueryCacheEventFilterConverter<K, V, C> extends AbstractCacheEventFilterConverter<K, V, C>
       implements IndexedFilter<K, V, C> {
 
    /**
@@ -57,7 +57,7 @@ public class JPAContinuousQueryCacheEventFilterConverter<K, V, C> extends Abstra
     */
    protected ObjectFilter objectFilter;
 
-   public JPAContinuousQueryCacheEventFilterConverter(String queryString, Map<String, Object> namedParameters, Class<? extends Matcher> matcherImplClass) {
+   public IckleContinuousQueryCacheEventFilterConverter(String queryString, Map<String, Object> namedParameters, Class<? extends Matcher> matcherImplClass) {
       if (queryString == null || matcherImplClass == null) {
          throw new IllegalArgumentException("Arguments cannot be null");
       }
@@ -130,13 +130,13 @@ public C filterAndConvert(K key, V oldValue, Metadata oldMetadata, V newValue, M
 
    @Override
    public String toString() {
-      return "JPAContinuousQueryCacheEventFilterConverter{queryString='" + queryString + "'}";
+      return "IckleContinuousQueryCacheEventFilterConverter{queryString='" + queryString + "'}";
    }
 
-   public static final class Externalizer extends AbstractExternalizer<JPAContinuousQueryCacheEventFilterConverter> {
+   public static final class Externalizer extends AbstractExternalizer<IckleContinuousQueryCacheEventFilterConverter> {
 
       @Override
-      public void writeObject(ObjectOutput output, JPAContinuousQueryCacheEventFilterConverter filterAndConverter) throws IOException {
+      public void writeObject(ObjectOutput output, IckleContinuousQueryCacheEventFilterConverter filterAndConverter) throws IOException {
          output.writeUTF(filterAndConverter.queryString);
          Map<String, Object> namedParameters = filterAndConverter.namedParameters;
          if (namedParameters != null) {
@@ -152,7 +152,7 @@ public void writeObject(ObjectOutput output, JPAContinuousQueryCacheEventFilterC
       }
 
       @Override
-      public JPAContinuousQueryCacheEventFilterConverter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
+      public IckleContinuousQueryCacheEventFilterConverter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
          String queryString = input.readUTF();
          int paramsSize = UnsignedNumeric.readUnsignedInt(input);
          Map<String, Object> namedParameters = null;
@@ -165,17 +165,17 @@ public JPAContinuousQueryCacheEventFilterConverter readObject(ObjectInput input)
             }
          }
          Class<? extends Matcher> matcherImplClass = (Class<? extends Matcher>) input.readObject();
-         return new JPAContinuousQueryCacheEventFilterConverter(queryString, namedParameters, matcherImplClass);
+         return new IckleContinuousQueryCacheEventFilterConverter(queryString, namedParameters, matcherImplClass);
       }
 
       @Override
       public Integer getId() {
-         return ExternalizerIds.JPA_CONTINUOUS_QUERY_CACHE_EVENT_FILTER_CONVERTER;
+         return ExternalizerIds.ICKLE_CONTINUOUS_QUERY_CACHE_EVENT_FILTER_CONVERTER;
       }
 
       @Override
-      public Set<Class<? extends JPAContinuousQueryCacheEventFilterConverter>> getTypeClasses() {
-         return Collections.singleton(JPAContinuousQueryCacheEventFilterConverter.class);
+      public Set<Class<? extends IckleContinuousQueryCacheEventFilterConverter>> getTypeClasses() {
+         return Collections.singleton(IckleContinuousQueryCacheEventFilterConverter.class);
       }
    }
 }

query/src/main/java/org/infinispan/query/continuous/impl/JPAContinuousQueryFilterIndexingServiceProvider.java → query/src/main/java/org/infinispan/query/continuous/impl/IckleContinuousQueryFilterIndexingServiceProvider.java

@@ -19,40 +19,40 @@
  */
 @MetaInfServices(FilterIndexingServiceProvider.class)
 @SuppressWarnings("unused")
-public class JPAContinuousQueryFilterIndexingServiceProvider extends BaseJPAFilterIndexingServiceProvider {
+public class IckleContinuousQueryFilterIndexingServiceProvider extends BaseJPAFilterIndexingServiceProvider {
 
    private final Object joiningEvent;
    private final Object updatedEvent;
    private final Object leavingEvent;
 
-   public JPAContinuousQueryFilterIndexingServiceProvider() {
+   public IckleContinuousQueryFilterIndexingServiceProvider() {
       this(ContinuousQueryResult.ResultType.JOINING, ContinuousQueryResult.ResultType.UPDATED, ContinuousQueryResult.ResultType.LEAVING);
    }
 
-   protected JPAContinuousQueryFilterIndexingServiceProvider(Object joiningEvent, Object updatedEvent, Object leavingEvent) {
+   protected IckleContinuousQueryFilterIndexingServiceProvider(Object joiningEvent, Object updatedEvent, Object leavingEvent) {
       this.joiningEvent = joiningEvent;
       this.updatedEvent = updatedEvent;
       this.leavingEvent = leavingEvent;
    }
 
    @Override
    public boolean supportsFilter(IndexedFilter<?, ?, ?> indexedFilter) {
-      return indexedFilter.getClass() == JPAContinuousQueryCacheEventFilterConverter.class;
+      return indexedFilter.getClass() == IckleContinuousQueryCacheEventFilterConverter.class;
    }
 
    @Override
    protected Matcher getMatcher(IndexedFilter<?, ?, ?> indexedFilter) {
-      return ((JPAContinuousQueryCacheEventFilterConverter) indexedFilter).getMatcher();
+      return ((IckleContinuousQueryCacheEventFilterConverter) indexedFilter).getMatcher();
    }
 
    @Override
    protected String getQueryString(IndexedFilter<?, ?, ?> indexedFilter) {
-      return ((JPAContinuousQueryCacheEventFilterConverter) indexedFilter).getQueryString();
+      return ((IckleContinuousQueryCacheEventFilterConverter) indexedFilter).getQueryString();
    }
 
    @Override
    protected Map<String, Object> getNamedParameters(IndexedFilter<?, ?, ?> indexedFilter) {
-      return ((JPAContinuousQueryCacheEventFilterConverter) indexedFilter).getNamedParameters();
+      return ((IckleContinuousQueryCacheEventFilterConverter) indexedFilter).getNamedParameters();
    }
 
    @Override

query/src/main/java/org/infinispan/query/dsl/embedded/impl/EmbeddedQuery.java

@@ -24,7 +24,7 @@ final class EmbeddedQuery extends BaseEmbeddedQuery {
 
    private final QueryEngine queryEngine;
 
-   private JPAFilterAndConverter<?, ?> filter;
+   private IckleFilterAndConverter<?, ?> filter;
 
    EmbeddedQuery(QueryEngine queryEngine, QueryFactory queryFactory, AdvancedCache<?, ?> cache,
                  String queryString, Map<String, Object> namedParameters, String[] projection,
@@ -39,7 +39,7 @@ public void resetQuery() {
       filter = null;
    }
 
-   private JPAFilterAndConverter createFilter() {
+   private IckleFilterAndConverter createFilter() {
       // filter is created first time only
       if (filter == null) {
          filter = queryEngine.createAndWireFilter(queryString, namedParameters);

query/src/main/java/org/infinispan/query/dsl/embedded/impl/JPACacheEventFilterConverter.java → query/src/main/java/org/infinispan/query/dsl/embedded/impl/IckleCacheEventFilterConverter.java

@@ -19,11 +19,11 @@
  * @author anistor@redhat.com
  * @since 7.2
  */
-public class JPACacheEventFilterConverter<K, V, C> extends AbstractCacheEventFilterConverter<K, V, C> implements IndexedFilter<K, V, C> {
+public class IckleCacheEventFilterConverter<K, V, C> extends AbstractCacheEventFilterConverter<K, V, C> implements IndexedFilter<K, V, C> {
 
-   protected final JPAFilterAndConverter<K, V> filterAndConverter;
+   protected final IckleFilterAndConverter<K, V> filterAndConverter;
 
-   public JPACacheEventFilterConverter(JPAFilterAndConverter<K, V> filterAndConverter) {
+   public IckleCacheEventFilterConverter(IckleFilterAndConverter<K, V> filterAndConverter) {
       this.filterAndConverter = filterAndConverter;
    }
 
@@ -37,27 +37,27 @@ public C filterAndConvert(K key, V oldValue, Metadata oldMetadata, V newValue, M
       return (C) filterAndConverter.filterAndConvert(key, newValue, newMetadata);
    }
 
-   public static final class Externalizer extends AbstractExternalizer<JPACacheEventFilterConverter> {
+   public static final class Externalizer extends AbstractExternalizer<IckleCacheEventFilterConverter> {
 
       @Override
-      public void writeObject(ObjectOutput output, JPACacheEventFilterConverter object) throws IOException {
+      public void writeObject(ObjectOutput output, IckleCacheEventFilterConverter object) throws IOException {
          output.writeObject(object.filterAndConverter);
       }
 
       @Override
-      public JPACacheEventFilterConverter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
-         JPAFilterAndConverter filterAndConverter = (JPAFilterAndConverter) input.readObject();
-         return new JPACacheEventFilterConverter(filterAndConverter);
+      public IckleCacheEventFilterConverter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
+         IckleFilterAndConverter filterAndConverter = (IckleFilterAndConverter) input.readObject();
+         return new IckleCacheEventFilterConverter(filterAndConverter);
       }
 
       @Override
       public Integer getId() {
-         return ExternalizerIds.JPA_CACHE_EVENT_FILTER_CONVERTER;
+         return ExternalizerIds.ICKLE_CACHE_EVENT_FILTER_CONVERTER;
       }
 
       @Override
-      public Set<Class<? extends JPACacheEventFilterConverter>> getTypeClasses() {
-         return Collections.singleton(JPACacheEventFilterConverter.class);
+      public Set<Class<? extends IckleCacheEventFilterConverter>> getTypeClasses() {
+         return Collections.singleton(IckleCacheEventFilterConverter.class);
       }
    }
 }