Develop

.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+[*.{xml,yml,yaml,json}]
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

.gitignore

@@ -15,3 +15,15 @@ buildNumber.properties
 .project
 # JDT-specific (Eclipse Java Development Tools)
 .classpath
+
+.idea/
+*.iml
+*.iws
+*.ipr
+*.log
+*.tmp
+*.bak
+*.swp
+*.swo
+*.DS_Store
+.air/

core/pom.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+          <groupId>com.euonia</groupId>
+          <artifactId>parent</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>core</artifactId>
+    <name>euonia core module</name>
+
+    <description>Core module of the Euonia framework</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.12.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.5.3</version>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

core/src/main/java/com/euonia/annotation/Required.java

@@ -0,0 +1,15 @@
+package com.euonia.annotation;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.PARAMETER})
+@Validation(validator = RequiredValidator.class)
+public @interface Required {
+
+    boolean allowEmpty() default false;
+
+    String message() default "";
+
+    Class<? extends Annotation> annotation() default Required.class;
+}

core/src/main/java/com/euonia/annotation/RequiredValidator.java

@@ -0,0 +1,18 @@
+package com.euonia.annotation;
+
+import com.euonia.tuple.Duet;
+
+public class RequiredValidator implements Validator<Required> {
+    @Override
+    public Duet<Boolean, String> validate(Required annotation, Object value) {
+        Duet<Boolean, String> result;
+        if (value == null) {
+            result = new Duet<>(false, annotation.message().isEmpty() ? "Value is required" : annotation.message());
+        } else if (!annotation.allowEmpty() && value instanceof String string && string.isEmpty()) {
+            result = new Duet<>(false, annotation.message().isEmpty() ? "Value must not be empty" : annotation.message());
+        } else {
+            result = new Duet<>(true, "");
+        }
+        return result;
+    }
+}

core/src/main/java/com/euonia/annotation/Validation.java

@@ -0,0 +1,12 @@
+package com.euonia.annotation;
+
+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.ANNOTATION_TYPE)
+public @interface Validation {
+    Class<? extends Validator<?>> validator();
+}

core/src/main/java/com/euonia/annotation/Validator.java

@@ -0,0 +1,9 @@
+package com.euonia.annotation;
+
+import com.euonia.tuple.Duet;
+
+import java.lang.annotation.Annotation;
+
+public interface Validator<A extends Annotation> {
+    Duet<Boolean, String> validate(A annotation, Object value);
+}

core/src/main/java/com/euonia/core/ObjectId.java

@@ -0,0 +1,149 @@
+package com.euonia.core;
+
+import java.util.UUID;
+
+/**
+ * ObjectId is a class that represents a unique identifier for an object.
+ * It can be generated using different algorithms such as Snowflake, GUID,
+ * Random, and ULID.
+ * The value of the ObjectId can be of type long, String, UUID, or Integer.
+ * The class provides methods to generate ObjectIds using different algorithms
+ * and overrides the hashCode, equals, and toString methods for proper
+ * functionality.
+ * The ObjectId class is immutable, meaning that once an ObjectId is created,
+ * its value cannot be changed.
+ * This ensures that the uniqueness of the identifier is maintained throughout
+ * its lifecycle.
+ */
+public final class ObjectId {
+    private final Object value;
+
+    /**
+     * Gets the value of the ObjectId.
+     *
+     * @return the value of the ObjectId
+     */
+    public Object getValue() {
+        return value;
+    }
+
+    /**
+     * Constructs an ObjectId with the specified value.
+     *
+     * @param value the value of the ObjectId
+     */
+    public ObjectId(long value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs an ObjectId with the specified value.
+     *
+     * @param value the value of the ObjectId
+     */
+    public ObjectId(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs an ObjectId with the specified value.
+     *
+     * @param value the value of the ObjectId
+     */
+    public ObjectId(UUID value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs an ObjectId with the specified value.
+     *
+     * @param value the value of the ObjectId
+     */
+    public ObjectId(Integer value) {
+        this.value = value;
+    }
+
+    /**
+     * Generates a new ObjectId using the Snowflake algorithm.
+     *
+     * @return a new ObjectId
+     */
+    public static ObjectId snowflake() {
+        return new ObjectId(SnowflakeId.getInstance().nextId());
+    }
+
+    /**
+     * Generates a new ObjectId using the GUID algorithm.
+     *
+     * @return a new ObjectId
+     */
+    public static ObjectId guid() {
+        return new ObjectId(UUID.randomUUID());
+    }
+
+    /**
+     * Generates a new ObjectId using the Random algorithm.
+     *
+     * @return a new ObjectId
+     */
+    public static ObjectId random() {
+        return new ObjectId(UUID.randomUUID());
+    }
+
+    /**
+     * Generates a new ObjectId using the ULID algorithm.
+     *
+     * @return a new ObjectId
+     */
+    public static ObjectId ulid() {
+        return new ObjectId(ULID.generate());
+    }
+
+    public <T> T getValue(Class<T> type) {
+        if (type.isInstance(value)) {
+            return type.cast(value);
+        }
+        return null;
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null || getClass() != obj.getClass())
+            return false;
+        ObjectId objectId = (ObjectId) obj;
+        return value.equals(objectId.value);
+    }
+
+    @Override
+    public String toString() {
+
+        if (value instanceof UUID target) {
+            return target.toString();
+        }
+
+        if (value instanceof Integer target) {
+            return target.toString();
+        }
+
+        if (value instanceof Long target) {
+            return target.toString();
+        }
+
+        if (value instanceof String target) {
+            return target;
+        }
+
+        if (value instanceof ULID target) {
+            return target.toString();
+        }
+
+        return value.toString();
+    }
+}

core/src/main/java/com/euonia/core/Pair.java

@@ -0,0 +1,18 @@
+package com.euonia.core;
+
+/**
+ * A generic class that represents a pair of key and value. The key must be comparable to ensure that pairs can be sorted based on their keys.
+ *
+ * @param key   the key of the pair
+ * @param value the value associated with the key
+ * @param <K>   the type of the key
+ * @param <V>   the type of the value
+ */
+public record Pair<K extends Comparable<K>, V>(K key, V value) {
+    public static <K extends Comparable<K>, V> Pair<K, V> of(K key, V value) {
+        if (key == null) {
+            throw new IllegalArgumentException("key is null");
+        }
+        return new Pair<>(key, value);
+    }
+}

core/src/main/java/com/euonia/core/PriorityQueue.java

@@ -0,0 +1,53 @@
+package com.euonia.core;
+
+import java.util.Comparator;
+
+public class PriorityQueue<E, K extends Comparable<K>> {
+    private final java.util.PriorityQueue<Pair<K, E>> queue;
+
+    public PriorityQueue() {
+        this.queue = new java.util.PriorityQueue<>(Comparator.comparing(Pair::key));
+    }
+
+    /**
+     * Inserts the specified element into this priority queue with the given priority.
+     *
+     * @param value    the element to be added
+     * @param priority the priority of the element
+     */
+    public void add(E value, K priority) {
+        queue.add(new Pair<>(priority, value));
+    }
+
+    /**
+     * Retrieves and removes the head of this queue, or returns null if this queue is empty.
+     *
+     * @return the value of the highest priority element, or null if the queue is empty
+     */
+    public E poll() {
+        Pair<K, E> pair = queue.poll();
+        return pair != null ? pair.value() : null;
+    }
+
+    /**
+     * Retrieves, but does not remove, the head of this queue. This method differs from peek only in that it throws an exception if this queue is empty.
+     *
+     * @return the value of the highest priority element, or null if the queue is empty
+     */
+    public E peek() {
+        Pair<K, E> pair = queue.peek();
+        return pair != null ? pair.value() : null;
+    }
+
+    public void clear() {
+        queue.clear();
+    }
+
+    public int size() {
+        return queue.size();
+    }
+
+    public boolean isEmpty() {
+        return queue.isEmpty();
+    }
+}