Add convinient query methods in Aeromapper to return a List of result (#76)

The current query methods needed to use processor to be able to convert a result set into an array list.
The code looked too verbose and needed repetition.
The newly added convenient query methods abstract away that implementation and returns the list of result.

Added by: https://github.com/sujeet100.

Author: sujeet100

src/main/java/com/aerospike/mapper/tools/AeroMapper.java

@@ -520,6 +520,22 @@ public <T> void query(QueryPolicy policy, @NotNull Class<T> clazz, @NotNull Proc
         }
     }
 
+    @Override
+    public <T> List<T> query(Class<T> clazz, Filter filter) {
+        return query(null, clazz, filter);
+    }
+
+    @Override
+    public <T> List<T> query(QueryPolicy policy, Class<T> clazz, Filter filter) {
+        List<T> result = new ArrayList<>();
+        Processor<T> resultProcessor = record -> {
+            result.add(record);
+            return true;
+        };
+        query(policy, clazz, resultProcessor, filter);
+        return result;
+    }
+
     @Override
     public <T> VirtualList<T> asBackedList(@NotNull Object object, @NotNull String binName, Class<T> elementClazz) {
         return new VirtualList<>(this, object, binName, elementClazz);

src/main/java/com/aerospike/mapper/tools/IAeroMapper.java

@@ -1,5 +1,6 @@
 package com.aerospike.mapper.tools;
 
+import java.util.List;
 import java.util.function.Function;
 
 import javax.validation.constraints.NotNull;
@@ -277,6 +278,31 @@ public interface IAeroMapper extends IBaseAeroMapper {
      */
     <T> void query(QueryPolicy policy, @NotNull Class<T> clazz, @NotNull Processor<T> processor, Filter filter);
 
+    /**
+     * Perform a secondary index query with the specified query policy
+     * and returns the list of records converted to the appropriate class.
+     * <p/>
+     * The query policy used will be the one associated with the passed classtype.
+     *
+     * @param clazz     - the class used to determine which set to scan and to convert the returned records to.
+     * @param filter    - the filter used to determine which secondary index to use. If this filter is null, every record in the set
+     *                  associated with the passed classtype will be scanned, effectively turning the query into a scan
+     * @return List of records converted to the appropriate class
+     */
+    <T> List<T> query(@NotNull Class<T> clazz, Filter filter);
+
+    /**
+     * Perform a secondary index query with the specified query policy
+     * and returns the list of records converted to the appropriate class.
+     *
+     * @param policy    - The query policy to use. If this parameter is not passed, the query policy associated with the passed classtype will be used
+     * @param clazz     - the class used to determine which set to scan and to convert the returned records to.
+     * @param filter    - the filter used to determine which secondary index to use. If this filter is null, every record in the set
+     *                  associated with the passed classtype will be scanned, effectively turning the query into a scan
+     * @return List of records converted to the appropriate class
+     */
+    <T> List<T> query(QueryPolicy policy, @NotNull Class<T> clazz, Filter filter);
+
     /**
      * Create a virtual list against an attribute on a class. The list does all operations to the database and does not affect the underlying
      * class, and is useful for situation when operations are needed to affect the database without having to return all the elements on the

src/test/java/com/aerospike/mapper/QueryTest.java

@@ -1,12 +1,18 @@
 package com.aerospike.mapper;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toList;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.jupiter.api.Test;
 
 import com.aerospike.client.AerospikeException;
+import com.aerospike.client.exp.Exp;
 import com.aerospike.client.policy.QueryPolicy;
 import com.aerospike.client.query.Filter;
 import com.aerospike.client.query.IndexType;
@@ -46,31 +52,52 @@ public int getAge() {
         public String toString() {
             return String.format("id:%d, name:%s, age:%d", id, name, age);
         }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            A a = (A) o;
+            return id == a.id && age == a.age && Objects.equals(name, a.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(id, name, age);
+        }
     }
 
+    private List<A> data = new ArrayList<A>() {{
+        add(new A(1, "Tim", 312));
+        add(new A(2, "Bob", 44));
+        add(new A(3, "Sue", 56));
+        add(new A(4, "Rob", 23));
+        add(new A(5, "Jim", 32));
+        add(new A(6, "Bob", 78));
+        add(new A(7, "Fred", 23));
+        add(new A(8, "Wilma", 11));
+        add(new A(9, "Barney", 54));
+        add(new A(10, "Steve", 72));
+        add(new A(11, "Bam Bam", 19));
+        add(new A(12, "Betty", 34));
+        add(new A(13, "Del", 7));
+        add(new A(14, "Khon", 98));
+        add(new A(15, "Dave", 21));
+        add(new A(16, "Mike", 32));
+        add(new A(17, "Darren", 14));
+        add(new A(18, "Lucy", 45));
+        add(new A(19, "Gertrude", 36));
+        add(new A(20, "Lucinda", 63));
+    }};
+
     private AeroMapper populate() {
         client.truncate(null, "test", "testScan", null);
         AeroMapper mapper = new AeroMapper.Builder(client).build();
-        mapper.save(new A(1, "Tim", 312),
-                new A(2, "Bob", 44),
-                new A(3, "Sue", 56),
-                new A(4, "Rob", 23),
-                new A(5, "Jim", 32),
-                new A(6, "Bob", 78),
-                new A(7, "Fred", 23),
-                new A(8, "Wilma", 11),
-                new A(9, "Barney", 54),
-                new A(10, "Steve", 72),
-                new A(11, "Bam Bam", 19),
-                new A(12, "Betty", 34),
-                new A(13, "Del", 7),
-                new A(14, "Khon", 98),
-                new A(15, "Dave", 21),
-                new A(16, "Mike", 32),
-                new A(17, "Darren", 14),
-                new A(18, "Lucy", 45),
-                new A(19, "Gertrude", 36),
-                new A(20, "Lucinda", 63));
+        mapper.save(data.toArray());
 
         try {
             client.createIndex(null, "test", "testScan", "age_idx", "age", IndexType.NUMERIC).waitTillComplete();
@@ -104,4 +131,34 @@ public void queryTestWithAbort() {
         }, Filter.range("age", 30, 54));
         assertEquals(1, counter.get());
     }
+
+    @Test
+    public void queryTestReturnsList() {
+        AeroMapper mapper = populate();
+
+        List<A> result = mapper.query(A.class, Filter.range("age", 30, 54));
+
+        List<A> expected = data.stream()
+                               .filter(d -> d.age >= 30 && d.age <= 54)
+                               .sorted(comparing(A::getId))
+                               .collect(toList());
+        assertEquals(7, result.size());
+        assertEquals(expected, result.stream().sorted(comparing(A::getId)).collect(toList()));
+    }
+
+    @Test
+    public void queryWithQueryPolicyTestReturnsList() {
+        AeroMapper mapper = populate();
+        QueryPolicy queryPolicy = new QueryPolicy();
+        queryPolicy.filterExp = Exp.build(Exp.eq(Exp.stringBin("name"), Exp.val("Bob")));
+
+        List<A> result = mapper.query(queryPolicy, A.class, Filter.range("age", 44, 78));
+
+        List<A> expected = data.stream()
+                               .filter(d -> d.age >= 44 && d.age <= 78 && d.name.equals("Bob"))
+                               .sorted(comparing(A::getId))
+                               .collect(toList());
+        assertEquals(2, result.size());
+        assertEquals(expected, result.stream().sorted(comparing(A::getId)).collect(toList()));
+    }
 }