add negative addressing and wrap-around

Author: guFalcon

pom.xml

@@ -10,7 +10,7 @@
 
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jre-utils</artifactId>
-	<version>0.3.9</version>
+	<version>0.3.10</version>
 	<name>JreUtils</name>
 	<packaging>jar</packaging>
 

src/main/java/info/unterrainer/commons/jreutils/FieldParser.java

@@ -48,7 +48,7 @@ private <T> T parse(final Object instance, final Class<?> clazz)
 		if (pathArray.length == 0)
 			return null;
 
-		for (Field field : clazz.getDeclaredFields()) {
+		for (Field field : clazz.getDeclaredFields())
 			if (field.isAnnotationPresent(annotation) && field.getName().equals(currentPlain)) {
 				field.setAccessible(true);
 				Object fieldInstance = resolveInstanceOf(instance, field);
@@ -57,7 +57,6 @@ private <T> T parse(final Object instance, final Class<?> clazz)
 				advance();
 				return parse(fieldInstance, fieldInstance.getClass());
 			}
-		}
 
 		Class<?> c = clazz.getSuperclass();
 		while (c != null) {
@@ -69,30 +68,40 @@ private <T> T parse(final Object instance, final Class<?> clazz)
 		return null;
 	}
 
-	private Object resolveInstanceOf(Object instance, Field field)
+	private Object resolveInstanceOf(final Object instance, final Field field)
 			throws IllegalArgumentException, IllegalAccessException {
 		Object fieldInstance = field.get(instance);
 		Class<?> currentType = field.getType();
 		if (currentIndex == null)
-			return fieldInstance;
+			currentIndex = 0;
 
 		if (List.class.isAssignableFrom(currentType)) {
+			int size = ((List<?>) fieldInstance).size();
+			currentIndex = cap(currentIndex, size);
 			return ((List<?>) fieldInstance).get(currentIndex);
 		}
 		if (currentType.isArray()) {
+			int size = ((Object[]) fieldInstance).length;
+			currentIndex = cap(currentIndex, size);
 			return ((Object[]) fieldInstance)[currentIndex];
 		}
 		return fieldInstance;
 	}
 
-	private String withoutIndex(String current) {
+	private int cap(final int index, final int size) {
+		if (index >= 0)
+			return index % size;
+		return index % size + size;
+	}
+
+	private String withoutIndex(final String current) {
 		int pos = current.indexOf(":");
 		if (pos == -1)
 			return current;
 		return current.substring(0, pos);
 	}
 
-	private Integer index(String current) {
+	private Integer index(final String current) {
 		try {
 			int pos = current.indexOf(":");
 			if (pos == -1)

src/test/java/info/unterrainer/commons/jreutils/ReflectingTests.java

@@ -19,13 +19,13 @@ public void TestReadingFields() {
 		List<String> results = Reflecting.getPathsOf(Test1Class.class, MyType.class, ContainsMyType.class);
 		assertThat(results).containsAll(List.of("myType", "usedClass.myType"));
 	}
-	
+
 	@Test
 	public void TestReadingFieldsContainsFieldsInArrays() {
 		List<String> results = Reflecting.getPathsOf(Test1Class.class, MyType.class, ContainsMyType.class);
 		assertThat(results).containsAll(List.of("myTypeArray", "usedClassArray.myType"));
 	}
-	
+
 	@Test
 	public void TestReadingFieldsContainsFieldsInGenericLists() {
 		List<String> results = Reflecting.getPathsOf(Test1Class.class, MyType.class, ContainsMyType.class);
@@ -52,7 +52,7 @@ public void TestWritingOfFieldInArray() throws IllegalArgumentException, Illegal
 		assertThat(tc.getMyTypeArray()[1].getName()).isNull();
 		assertThat(tc.getMyTypeArray()[3].getName()).isEqualTo("gluppy");
 	}
-	
+
 	@Test
 	public void TestWritingOfFieldInList() throws IllegalArgumentException, IllegalAccessException {
 		Test1Class tc = new Test1Class();
@@ -64,7 +64,7 @@ public void TestWritingOfFieldInList() throws IllegalArgumentException, IllegalA
 		assertThat(tc.getMyTypeList().get(1).getName()).isNull();
 		assertThat(tc.getMyTypeList().get(3).getName()).isEqualTo("gluppy");
 	}
-	
+
 	@Test
 	public void TestWritingOfFieldInUsedClassInArray() throws IllegalArgumentException, IllegalAccessException {
 		Test1Class tc = new Test1Class();
@@ -76,7 +76,7 @@ public void TestWritingOfFieldInUsedClassInArray() throws IllegalArgumentExcepti
 		assertThat(tc.getUsedClassArray()[1].getMyType().getName()).isNull();
 		assertThat(tc.getUsedClassArray()[2].getMyType().getName()).isEqualTo("gluppy");
 	}
-	
+
 	@Test
 	public void TestWritingOfFieldInUsedClassInList() throws IllegalArgumentException, IllegalAccessException {
 		Test1Class tc = new Test1Class();
@@ -88,7 +88,40 @@ public void TestWritingOfFieldInUsedClassInList() throws IllegalArgumentExceptio
 		assertThat(tc.getUsedClassList().get(1).getMyType().getName()).isNull();
 		assertThat(tc.getUsedClassList().get(2).getMyType().getName()).isEqualTo("gluppy");
 	}
-	
+
+	@Test
+	public void TestIndexOfListEmptyReturnsFirstEntry() throws IllegalArgumentException, IllegalAccessException {
+		Test1Class tc = new Test1Class();
+		MyType mt = Reflecting.getFieldByPath("usedClassList.myType", tc, ContainsMyType.class);
+		mt.setName("blubb");
+		assertThat(tc.getUsedClassList().get(0).getMyType().getName()).isEqualTo("blubb");
+	}
+
+	@Test
+	public void TestIndexOfListOverflowJustStartsFromBeginning()
+			throws IllegalArgumentException, IllegalAccessException {
+		Test1Class tc = new Test1Class();
+		MyType mt = Reflecting.getFieldByPath("usedClassList:3.myType", tc, ContainsMyType.class);
+		mt.setName("blubb");
+		assertThat(tc.getUsedClassList().get(0).getMyType().getName()).isEqualTo("blubb");
+	}
+
+	@Test
+	public void TestIndexOfListUnderflowJustStartsFromTheEnd() throws IllegalArgumentException, IllegalAccessException {
+		Test1Class tc = new Test1Class();
+		MyType mt = Reflecting.getFieldByPath("usedClassList:-1.myType", tc, ContainsMyType.class);
+		mt.setName("blubb");
+		assertThat(tc.getUsedClassList().get(2).getMyType().getName()).isEqualTo("blubb");
+	}
+
+	@Test
+	public void TestIndexOfListNegativeOverflowWrapsAsWell() throws IllegalArgumentException, IllegalAccessException {
+		Test1Class tc = new Test1Class();
+		MyType mt = Reflecting.getFieldByPath("usedClassList:-4.myType", tc, ContainsMyType.class);
+		mt.setName("blubb");
+		assertThat(tc.getUsedClassList().get(2).getMyType().getName()).isEqualTo("blubb");
+	}
+
 	@Test
 	public void TestWritingOfFieldInUsedClass() throws IllegalArgumentException, IllegalAccessException {
 		Test1Class tc = new Test1Class();

src/test/java/info/unterrainer/commons/jreutils/dtos/Test1Class.java

@@ -21,10 +21,11 @@ public class Test1Class {
 	private String className;
 	@ContainsMyType
 	private List<Test1OtherClass> usedClassList = List.of(new Test1OtherClass(), new Test1OtherClass(),
-			new Test1OtherClass(), new Test1OtherClass());
+			new Test1OtherClass());
 	@ContainsMyType
 	private Test1OtherClass[] usedClassArray = List
-			.of(new Test1OtherClass(), new Test1OtherClass(), new Test1OtherClass()).toArray(new Test1OtherClass[0]);
+			.of(new Test1OtherClass(), new Test1OtherClass(), new Test1OtherClass())
+			.toArray(new Test1OtherClass[0]);
 	@ContainsMyType
 	private Test1OtherClass usedClass = new Test1OtherClass();
 }