Implemented support for enum foreign keys.

Author: CollinAlpert

README.md

@@ -20,7 +20,7 @@ Include the Maven artifact:
 <dependency>
     <groupId>com.github.collinalpert</groupId>
     <artifactId>java2db</artifactId>
-    <version>4.0</version>
+    <version>4.1</version>
 </dependency>
 ```
 Or include the [JAR](https://github.com/CollinAlpert/Java2DB/releases/latest) in your project. 
@@ -156,6 +156,50 @@ The asynchronous versions of methods which have a return value, e.g. `create`, `
 If you do not wish to use the computed value, e.g. for the `create` method, the `CallbackUtils` class offers an `empty()` method, which returns an empty `Consumer` that just does nothing. 
 Use this as an argument in the asynchronous methods, when needed.
 
+### Enums for static values
+Lets suppose you are using a "mood" in which you have certain moods (happy, sad, mad, etc.) stored. Now, to describe the mood 
+of a person you would obviously reference this table via a foreign key and add the `@ForeignKeyEntity` attribute to a POJO field you have defined for the "mood" table.
+For static tables, meaning tables which just contain informational values e.g. statuses which do not change, you can define an enum to keep track of the values.
+That way a complete entity is not always needed. Using the above example, it would look something like this:
+
+```java
+// An enum representing used in combination with the @ForeignKeyEntity must implement IdentifiableEnum. 
+public enum MoodTypes implements IdentifiableEnum {
+	
+    HAPPY(1), SAD(2), MAD(3);
+	
+    private final int id;
+	
+    MoodTypes(int id) {
+        this.id = id;
+    }
+
+    @Override
+    public long getId() {
+        return this.id;
+    }
+}
+```
+
+```java
+@TableName("person")
+public class Person extends BaseEntity {
+	
+    // All of the above fields.
+    
+    private int moodId;
+    
+    // You can still use the foreign key entity if you like, 
+    // but it becomes sort of redundant as soon as you use the enum.
+    @ForeignKeyEntity("moodId")
+    private Mood mood;
+    
+    // The enum value will be set to the value corresponding with the "moodId".
+    @ForeignKeyEntity("moodId")
+    private MoodTypes moodType;
+}
+``` 
+
 ### Column name deviations
 To be able to target any column naming conventions, it is possible to explicitly tell Java2DB which table column a POJO field targets with the `@ColumnName` attribute. Simply apply the attribute to a field.
 Note that when supplying a different name for a foreign key, the `@ForeignKeyEntity` annotation must still point to the name of the actual table's foreign key column. Here's an example in which the gender foreign key is not suffixed with "id" on the database: 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.collinalpert</groupId>
     <artifactId>java2db</artifactId>
-    <version>4.0</version>
+    <version>4.1</version>
     <packaging>jar</packaging>
 
     <name>Java2DB</name>
@@ -73,7 +73,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.4.0</version>
+            <version>5.4.1</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -136,8 +136,9 @@
                 </executions>
             </plugin>
             <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
-                <version>3.1.0</version>
+                <version>3.1.1</version>
                 <executions>
                     <execution>
                         <phase>package</phase>

src/main/java/com/github/collinalpert/java2db/annotations/ForeignKeyEntity.java

@@ -10,6 +10,13 @@
  * This property does not have to exist on the database.
  * Its parameter is the name of the foreign key column.
  *
+ * This annotation can be used on two types of objects:
+ * 1) Entities which represent real objects of foreign key tables. In this case the entity has to extend
+ * {@link com.github.collinalpert.java2db.entities.BaseEntity}. Because this entity represents a table it should extend {@code BaseEntity} anyway.
+ *
+ * 2) Foreign keys to a table with static values that can be represented by an enum because they don't change.
+ * In that case the enum must extend {@link com.github.collinalpert.java2db.contracts.IdentifiableEnum} and map the ids from the table.
+ *
  * @author Collin Alpert
  */
 @Target(ElementType.FIELD)

src/main/java/com/github/collinalpert/java2db/contracts/IdentifiableEnum.java

@@ -0,0 +1,11 @@
+package com.github.collinalpert.java2db.contracts;
+
+/**
+ * A contract for enums which represent foreign keys.
+ * Every enum used to represent a foreign key must implement this interface.
+ *
+ * @author Collin Alpert
+ */
+public interface IdentifiableEnum {
+	long getId();
+}

src/main/java/com/github/collinalpert/java2db/mappers/BaseMapper.java

@@ -2,17 +2,20 @@
 
 import com.github.collinalpert.java2db.annotations.ColumnName;
 import com.github.collinalpert.java2db.annotations.ForeignKeyEntity;
+import com.github.collinalpert.java2db.contracts.IdentifiableEnum;
 import com.github.collinalpert.java2db.entities.BaseEntity;
 import com.github.collinalpert.java2db.modules.ArrayModule;
 import com.github.collinalpert.java2db.utilities.IoC;
 import com.github.collinalpert.java2db.utilities.UniqueIdentifier;
 import com.github.collinalpert.java2db.utilities.Utilities;
 
+import java.lang.reflect.Field;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.LinkedList;
 import java.util.List;
@@ -22,6 +25,7 @@
 import java.util.stream.Stream;
 
 import static com.github.collinalpert.java2db.utilities.Utilities.tryAction;
+import static com.github.collinalpert.java2db.utilities.Utilities.tryGetValue;
 
 /**
  * Default mapper for converting a {@link ResultSet} to the respective Java entity.
@@ -138,32 +142,31 @@ private <E extends BaseEntity> void setFields(ResultSet set, E entity, String id
 		var fields = Utilities.getEntityFields(entity.getClass(), true);
 		for (var field : fields) {
 			field.setAccessible(true);
+
 			if (field.getAnnotation(ForeignKeyEntity.class) != null) {
-				var foreignKeyColumnName = field.getAnnotation(ForeignKeyEntity.class).value();
-				if (!BaseEntity.class.isAssignableFrom(field.getType())) {
-					throw new IllegalArgumentException(String.format("Type %s, which is annotated as a foreign key, does not extend BaseEntity.", field.getType().getSimpleName()));
-				}
 
-				// This block is for checking if the foreign key is null.
-				// That means that the corresponding foreign key entity must be set to null.
-				var foreignKeyName = "";
-				try {
-					var foreignKeyField = field.getDeclaringClass().getDeclaredField(foreignKeyColumnName);
-					foreignKeyName = foreignKeyField.getName();
-					if (foreignKeyField.getAnnotation(ColumnName.class) != null) {
-						foreignKeyName = foreignKeyField.getAnnotation(ColumnName.class).value();
-					}
-				} catch (NoSuchFieldException e) {
-					//Oh boi, you've done it now!
-					for (var declaredField : field.getDeclaringClass().getDeclaredFields()) {
-						if (declaredField.getAnnotation(ColumnName.class) != null && declaredField.getAnnotation(ColumnName.class).value().equals(foreignKeyColumnName)) {
-							foreignKeyName = declaredField.getAnnotation(ColumnName.class).value();
-							break;
-						}
+				if (field.getType().isEnum()) {
+					if (!IdentifiableEnum.class.isAssignableFrom(field.getType())) {
+						throw new IllegalArgumentException(String.format("The enum %s used in %s was annotated with a ForeignKeyEntity attribute but does not extend IdentifiableEnum.", field.getType().getSimpleName(), field.getDeclaringClass().getSimpleName()));
 					}
+
+					var foreignKeyName = getForeignKeyName(field);
+					var foundEnum = Arrays.stream(field.getType().getEnumConstants())
+							.map(x -> (IdentifiableEnum) x)
+							.filter(x -> Long.valueOf(tryGetValue(() -> getAccessibleField(field.getDeclaringClass(), foreignKeyName).get(entity)).toString()) == x.getId())
+							.findFirst();
+
+					foundEnum.ifPresent(identifiableEnum -> tryAction(() -> field.set(entity, field.getType().cast(identifiableEnum))));
+
+					continue;
 				}
 
-				if (set.getObject((identifier == null ? Utilities.getTableName(entity.getClass()) : identifier) + "_" + foreignKeyName) == null) {
+				if (!BaseEntity.class.isAssignableFrom(field.getType())) {
+					throw new IllegalArgumentException(String.format("Type %s, which is annotated as a foreign key, does not extend BaseEntity.", field.getType().getSimpleName()));
+				}
+
+				// If foreign key is null, the corresponding entity must also be null.
+				if (set.getObject((identifier == null ? Utilities.getTableName(entity.getClass()) : identifier) + "_" + getForeignKeyName(field)) == null) {
 					continue;
 				}
 
@@ -196,4 +199,29 @@ private <E extends BaseEntity> void setFields(ResultSet set, E entity, String id
 			tryAction(() -> field.set(entity, value));
 		}
 	}
+
+	private String getForeignKeyName(Field field) {
+		var foreignKeyColumnName = field.getAnnotation(ForeignKeyEntity.class).value();
+
+		try {
+			var foreignKeyField = field.getDeclaringClass().getDeclaredField(foreignKeyColumnName);
+			return Utilities.getColumnName(foreignKeyField);
+		} catch (NoSuchFieldException e) {
+			//Oh boi, you've done it now! This case occurs when a foreign key field gets altered by a ColumnName attribute.
+			for (var declaredField : field.getDeclaringClass().getDeclaredFields()) {
+				ColumnName columnName;
+				if ((columnName = declaredField.getAnnotation(ColumnName.class)) != null && columnName.value().equals(foreignKeyColumnName)) {
+					return columnName.value();
+				}
+			}
+		}
+
+		return "";
+	}
+
+	private Field getAccessibleField(Class<?> clazz, String name) throws NoSuchFieldException {
+		var field = clazz.getDeclaredField(name);
+		field.setAccessible(true);
+		return field;
+	}
 }

src/main/java/com/github/collinalpert/java2db/utilities/Utilities.java

@@ -76,6 +76,10 @@ public static List<TableColumnReference> getAllFields(Class<? extends BaseEntity
 	public static List<TableColumnReference> getAllFields(Class<? extends BaseEntity> instanceClass, String alias) {
 		var fields = new LinkedList<TableColumnReference>();
 		for (var field : getEntityFields(instanceClass, true)) {
+			if (field.getType().isEnum()) {
+				continue;
+			}
+
 			if (field.getAnnotation(ForeignKeyEntity.class) != null) {
 				var tempAlias = UniqueIdentifier.generate(getTableName(field.getType()).substring(0, 1), field.getName());
 				fields.add(new TableColumnReference(getTableName(instanceClass), field, tempAlias, alias));
@@ -197,4 +201,20 @@ public static <E extends Throwable> void tryAction(ThrowableRunnable<E> runnable
 			e.printStackTrace();
 		}
 	}
+
+	/**
+	 * Tries to perform a certain supplier and retrieve its value while considering a checked exception that could occur.
+	 *
+	 * @param supplier The {@code Supplier} to try to execute.
+	 * @param <T>      The type of value to return.
+	 * @param <E>      The type of checked exception.
+	 * @return The value returned by the supplier, assuming it can be excecuted without throwing an exception.
+	 */
+	public static <T, E extends Throwable> T tryGetValue(ThrowableSupplier<T, E> supplier) {
+		try {
+			return supplier.fetch();
+		} catch (Throwable e) {
+			throw new RuntimeException("Underlying method threw an exception.", e);
+		}
+	}
 }