Merge branch 'develop'

Author: guFalcon

pom.xml

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

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

@@ -72,15 +72,17 @@ private Object resolveInstanceOf(final Object instance, final Field field)
 			throws IllegalArgumentException, IllegalAccessException {
 		Object fieldInstance = field.get(instance);
 		Class<?> currentType = field.getType();
-		if (currentIndex == null)
-			currentIndex = 0;
 
 		if (List.class.isAssignableFrom(currentType)) {
+			if (currentIndex == null)
+				return (fieldInstance);
 			int size = ((List<?>) fieldInstance).size();
 			currentIndex = cap(currentIndex, size);
 			return ((List<?>) fieldInstance).get(currentIndex);
 		}
 		if (currentType.isArray()) {
+			if (currentIndex == null)
+				return (fieldInstance);
 			int size = ((Object[]) fieldInstance).length;
 			currentIndex = cap(currentIndex, size);
 			return ((Object[]) fieldInstance)[currentIndex];

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

@@ -19,7 +19,24 @@ public class Reflecting {
 	 * 'myField.myArray:0.myVar')
 	 *
 	 * @param classToScan         the class to start scanning in
-	 * @param fieldTypeToFind     the type to search for
+	 * @param annotationToScanFor the annotation the fields we should scan are
+	 *                            annotated with
+	 * @return a list of paths where the given fields have been found
+	 */
+	public List<String> getPathsOf(final Class<?> classToScan, final Class<? extends Annotation> annotationToScanFor) {
+		return getPathsOf(classToScan, null, annotationToScanFor, "");
+	}
+
+	/**
+	 * Scans object tree connected by annotated fields for a given class using
+	 * reflection and returns found paths.<br>
+	 * <br>
+	 * Resolves generic Lists and Arrays as well (example for indexing:
+	 * 'myField.myArray:0.myVar')
+	 *
+	 * @param classToScan         the class to start scanning in
+	 * @param fieldTypeToFind     the type to search for or null, if you have no
+	 *                            type-restriction for your search
 	 * @param annotationToScanFor the annotation the fields we should scan are
 	 *                            annotated with
 	 * @return a list of paths where the given fields have been found
@@ -43,9 +60,8 @@ private void getFields(final Class<?> classToScan, final Class<?> typeToFind,
 
 			if (field.isAnnotationPresent(annotation)) {
 				Class<?> currentType = resolveTypeOf(field);
-				if (typeToFind.isAssignableFrom(currentType)) {
+				if (typeToFind == null || typeToFind.isAssignableFrom(currentType)) {
 					paths.add(currentPath + field.getName());
-					continue;
 				}
 				paths.addAll(getPathsOf(currentType, typeToFind, annotation, currentPath + field.getName() + "."));
 			}

src/main/java/info/unterrainer/commons/jreutils/logging/FieldLogger.java

@@ -0,0 +1,42 @@
+package info.unterrainer.commons.jreutils.logging;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import info.unterrainer.commons.jreutils.Reflecting;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class FieldLogger {
+
+	public static String log(final Object instance, final Class<?> clazz) {
+		List<String> paths = Reflecting.getPathsOf(clazz, LogField.class);
+		StringBuilder sb = new StringBuilder();
+		for (String path : paths) {
+			try {
+				Object o = Reflecting.getFieldByPath(path, instance, LogField.class);
+				sb.append(path);
+				sb.append(": ");
+				if (o == null)
+					sb.append("null");
+				else if (o instanceof List) {
+					String s = ((List<?>) o).stream().map(Object::toString).collect(Collectors.joining(", "));
+					sb.append("[");
+					sb.append(s);
+					sb.append("]");
+				} else if (o.getClass().isArray()) {
+					String s = Arrays.stream((Object[]) o).map(Object::toString).collect(Collectors.joining(", "));
+					sb.append("[");
+					sb.append(s);
+					sb.append("]");
+				} else
+					sb.append(o.toString());
+				sb.append(System.lineSeparator());
+			} catch (IllegalArgumentException | IllegalAccessException e) {
+				// NOOP
+			}
+		}
+		return sb.toString();
+	}
+}

src/main/java/info/unterrainer/commons/jreutils/logging/LogField.java

@@ -0,0 +1,11 @@
+package info.unterrainer.commons.jreutils.logging;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface LogField {
+}

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

@@ -0,0 +1,38 @@
+package info.unterrainer.commons.jreutils;
+
+import org.junit.jupiter.api.Test;
+
+import info.unterrainer.commons.jreutils.dtos.Test1Class;
+import info.unterrainer.commons.jreutils.logging.FieldLogger;
+
+public class FieldLoggerTests {
+
+	@Test
+	public void TestReadingFields() {
+		Test1Class t = new Test1Class();
+		t.setName("name");
+		t.setVendor("vendor");
+		t.setType(2L);
+		t.setAddress("This is an address.");
+		t.setClassName("Classname should not be visible because it's not annotated correctly.");
+		StringBuilder sb = new StringBuilder();
+		sb.append("=========================================");
+		sb.append(System.lineSeparator());
+		sb.append(FieldLogger.log(t, Test1Class.class));
+		sb.append("=========================================");
+		sb.append(System.lineSeparator());
+		System.out.println(sb.toString());
+	}
+
+	@Test
+	public void TestReadingLists() {
+		Test1Class t = new Test1Class();
+		StringBuilder sb = new StringBuilder();
+		sb.append("=========================================");
+		sb.append(System.lineSeparator());
+		sb.append(FieldLogger.log(t, Test1Class.class));
+		sb.append("=========================================");
+		sb.append(System.lineSeparator());
+		System.out.println(sb.toString());
+	}
+}

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

@@ -20,6 +20,12 @@ public void TestReadingFields() {
 		assertThat(results).containsAll(List.of("myType", "usedClass.myType"));
 	}
 
+	@Test
+	public void TestReadingFieldsWithNullTypeGetsAll() {
+		List<String> results = Reflecting.getPathsOf(Test1Class.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);
@@ -89,14 +95,6 @@ public void TestWritingOfFieldInUsedClassInList() throws IllegalArgumentExceptio
 		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 {

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

@@ -2,20 +2,28 @@
 
 import java.util.List;
 
+import info.unterrainer.commons.jreutils.logging.LogField;
 import lombok.Data;
 
 @Data
 public class Test1Class {
 
+	@LogField
 	private String name;
 	@ContainsMyType
+	@LogField
 	private List<MyType> myTypeList = List.of(new MyType(), new MyType(), new MyType(), new MyType());
+	@LogField
 	private String vendor;
+	@LogField
 	private Long type;
 	@ContainsMyType
+	@LogField
 	private MyType myType = new MyType();
+	@LogField
 	private String address;
 	@ContainsMyType
+	@LogField
 	private MyType[] myTypeArray = List.of(new MyType(), new MyType(), new MyType(), new MyType(), new MyType())
 			.toArray(new MyType[0]);
 	private String className;