From 3f7edd0968c66cede99dc424db39761cb4cb1cf0 Mon Sep 17 00:00:00 2001 From: JeremyStarTM Date: Mon, 8 Jul 2024 13:46:30 +0200 Subject: [PATCH] Add more Immutable* types --- .../staropensource/sosengine/base/Engine.java | 6 +- .../types/immutable/ImmutableArrayList.java | 211 +++++++++++++++++ .../ImmutableHashMap.java} | 69 +++--- .../immutable/ImmutableLinkedHashMap.java | 160 +++++++++++++ .../types/immutable/ImmutableLinkedList.java | 214 ++++++++++++++++++ base/src/main/java/module-info.java | 2 + .../opengl/src/main/java/module-info.java | 5 + graphics/src/main/java/module-info.java | 5 + .../vulkan/src/main/java/module-info.java | 5 + slf4j-compat/src/main/java/module-info.java | 5 + testapp/src/main/java/module-info.java | 6 + 11 files changed, 649 insertions(+), 39 deletions(-) create mode 100644 base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableArrayList.java rename base/src/main/java/de/staropensource/sosengine/base/types/{ImmutableMap.java => immutable/ImmutableHashMap.java} (53%) create mode 100644 base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedHashMap.java create mode 100644 base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedList.java diff --git a/base/src/main/java/de/staropensource/sosengine/base/Engine.java b/base/src/main/java/de/staropensource/sosengine/base/Engine.java index ebf0209..9a051c5 100644 --- a/base/src/main/java/de/staropensource/sosengine/base/Engine.java +++ b/base/src/main/java/de/staropensource/sosengine/base/Engine.java @@ -33,8 +33,8 @@ import de.staropensource.sosengine.base.logging.CrashHandler; import de.staropensource.sosengine.base.logging.Logger; import de.staropensource.sosengine.base.logging.LoggerInstance; import de.staropensource.sosengine.base.types.CodePart; -import de.staropensource.sosengine.base.types.ImmutableMap; import de.staropensource.sosengine.base.types.dependency.DependencyVector; +import de.staropensource.sosengine.base.types.immutable.ImmutableHashMap; import de.staropensource.sosengine.base.utility.DependencyResolver; import de.staropensource.sosengine.base.utility.Miscellaneous; import de.staropensource.sosengine.base.utility.PlaceholderEngine; @@ -94,7 +94,7 @@ public final class Engine implements SubsystemMainClass { */ @NotNull @Getter - private ImmutableMap<@NotNull SubsystemMainClass, @NotNull DependencyVector> subsystems = new ImmutableMap<>(); + private ImmutableHashMap<@NotNull SubsystemMainClass, @NotNull DependencyVector> subsystems = new ImmutableHashMap<>(); /** * Indicates if the engine is shutting down. @@ -282,7 +282,7 @@ public final class Engine implements SubsystemMainClass { if (subsystemsMap.get(subsystem) == null) subsystemsMap.remove(subsystem); - subsystems = new ImmutableMap<>(subsystemsMap); + subsystems = new ImmutableHashMap<>(subsystemsMap); } /** diff --git a/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableArrayList.java b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableArrayList.java new file mode 100644 index 0000000..f88440f --- /dev/null +++ b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableArrayList.java @@ -0,0 +1,211 @@ +/* + * STAROPENSOURCE ENGINE SOURCE FILE + * Copyright (c) 2024 The StarOpenSource Engine Contributors + * Licensed under the GNU Affero General Public License v3 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.staropensource.sosengine.base.types.immutable; + +import org.jetbrains.annotations.NotNull; + +import java.util.*; +import java.util.function.UnaryOperator; + +/** + * An unmodifiable {@link ArrayList}. + * {@inheritDoc} + * + * @since 1-alpha1 + */ +@SuppressWarnings({ "unused" }) +public class ImmutableArrayList extends ArrayList { + /** + * Creates a new immutable array list. + * + * @since 1-alpha1 + */ + public ImmutableArrayList() {} + + /** + * Converts a {@link LinkedList} into a {@link ImmutableArrayList}. + * + * @param list {@link List} to convert + * @since 1-alpha1 + */ + public ImmutableArrayList(@NotNull List list) { + super.addAll(list); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean add(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean remove(Object o) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean addAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean addAll(int index, @NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean removeAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public boolean retainAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void replaceAll(UnaryOperator operator) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void sort(Comparator c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void clear() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public E set(int index, E element) throws UnsupportedOperationException { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void add(int index, E element) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public E remove(int index) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void addFirst(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public void addLast(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public E removeFirst() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, array list is immutable + */ + @Override + public E removeLast() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableArrayList"); + } +} diff --git a/base/src/main/java/de/staropensource/sosengine/base/types/ImmutableMap.java b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableHashMap.java similarity index 53% rename from base/src/main/java/de/staropensource/sosengine/base/types/ImmutableMap.java rename to base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableHashMap.java index 8e666b1..8cab490 100644 --- a/base/src/main/java/de/staropensource/sosengine/base/types/ImmutableMap.java +++ b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableHashMap.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package de.staropensource.sosengine.base.types; +package de.staropensource.sosengine.base.types.immutable; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -33,131 +33,128 @@ import java.util.function.BiFunction; * @since 1-alpha1 */ @SuppressWarnings({ "unused" }) -public class ImmutableMap extends HashMap { +public class ImmutableHashMap extends HashMap { /** - * Creates a new immutable map. + * Creates a new immutable hash map. * * @since 1-alpha1 */ - public ImmutableMap() {} + public ImmutableHashMap() {} /** - * Converts a {@link Map} into a {@link ImmutableMap}. + * Converts a {@link Map} into a {@link ImmutableHashMap}. * * @param map {@link Map} to convert * @since 1-alpha1 */ - public ImmutableMap(@NotNull Map map) { + public ImmutableHashMap(@NotNull Map map) { for (K key : map.keySet()) super.put(key, map.get(key)); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Nullable @Override public V put(K key, V value) { - return null; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Nullable @Override public V remove(Object key) { - return null; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Override - public void putAll(@NotNull Map m) {} + public void putAll(@NotNull Map m) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); + } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Override - public void clear() {} + public void clear() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); + } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Override - public void replaceAll(BiFunction function) {} + public void replaceAll(BiFunction function) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); + } + /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Nullable @Override public V putIfAbsent(K key, V value) { - return null; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Override public boolean remove(Object key, Object value) { - return false; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Override public boolean replace(K key, V oldValue, V newValue) { - return false; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Nullable @Override public V replace(K key, V value) { - return null; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } /** - * Note: This method is a stub.
* {@inheritDoc} * - * @since 1-alpha1 + * @throws UnsupportedOperationException always, hash map is immutable */ @Nullable @Override public V merge(K key, @NotNull V value, @NotNull BiFunction remappingFunction) { - return null; + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableHashMap"); } } diff --git a/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedHashMap.java b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedHashMap.java new file mode 100644 index 0000000..c9f216a --- /dev/null +++ b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedHashMap.java @@ -0,0 +1,160 @@ +/* + * STAROPENSOURCE ENGINE SOURCE FILE + * Copyright (c) 2024 The StarOpenSource Engine Contributors + * Licensed under the GNU Affero General Public License v3 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.staropensource.sosengine.base.types.immutable; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.function.BiFunction; + +/** + * An unmodifiable {@link Map}. + * {@inheritDoc} + * + * @since 1-alpha1 + */ +@SuppressWarnings({ "unused" }) +public class ImmutableLinkedHashMap extends LinkedHashMap { + /** + * Creates a new immutable linked hash map. + * + * @since 1-alpha1 + */ + public ImmutableLinkedHashMap() {} + + /** + * Converts a {@link Map} into a {@link ImmutableLinkedHashMap}. + * + * @param map {@link Map} to convert + * @since 1-alpha1 + */ + public ImmutableLinkedHashMap(@NotNull Map map) { + for (K key : map.keySet()) + super.put(key, map.get(key)); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Nullable + @Override + public V put(K key, V value) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Nullable + @Override + public V remove(Object key) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Override + public void putAll(@NotNull Map m) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Override + public void clear() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Override + public void replaceAll(BiFunction function) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Nullable + @Override + public V putIfAbsent(K key, V value) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Override + public boolean remove(Object key, Object value) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Override + public boolean replace(K key, V oldValue, V newValue) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Nullable + @Override + public V replace(K key, V value) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked hash map is immutable + */ + @Nullable + @Override + public V merge(K key, @NotNull V value, @NotNull BiFunction remappingFunction) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedHashMap"); + } +} diff --git a/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedList.java b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedList.java new file mode 100644 index 0000000..b335dd1 --- /dev/null +++ b/base/src/main/java/de/staropensource/sosengine/base/types/immutable/ImmutableLinkedList.java @@ -0,0 +1,214 @@ +/* + * STAROPENSOURCE ENGINE SOURCE FILE + * Copyright (c) 2024 The StarOpenSource Engine Contributors + * Licensed under the GNU Affero General Public License v3 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.staropensource.sosengine.base.types.immutable; + +import org.jetbrains.annotations.NotNull; + +import java.util.Collection; +import java.util.Comparator; +import java.util.LinkedList; +import java.util.List; +import java.util.function.UnaryOperator; + +/** + * An unmodifiable {@link LinkedList}. + * {@inheritDoc} + * + * @since 1-alpha1 + */ +@SuppressWarnings({ "unused" }) +public class ImmutableLinkedList extends LinkedList { + /** + * Creates a new immutable linked list. + * + * @since 1-alpha1 + */ + public ImmutableLinkedList() {} + + /** + * Converts a {@link LinkedList} into a {@link ImmutableLinkedList}. + * + * @param list {@link List} to convert + * @since 1-alpha1 + */ + public ImmutableLinkedList(@NotNull List list) { + super.addAll(list); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean add(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean remove(Object o) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean addAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean addAll(int index, @NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean removeAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public boolean retainAll(@NotNull Collection c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void replaceAll(UnaryOperator operator) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void sort(Comparator c) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void clear() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public E set(int index, E element) throws UnsupportedOperationException { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void add(int index, E element) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public E remove(int index) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void addFirst(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public void addLast(E e) { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public E removeFirst() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException always, linked list is immutable + */ + @Override + public E removeLast() { + throw new UnsupportedOperationException("This method cannot be executed on an ImmutableLinkedList"); + } +} diff --git a/base/src/main/java/module-info.java b/base/src/main/java/module-info.java index a8b0a9a..e42c994 100644 --- a/base/src/main/java/module-info.java +++ b/base/src/main/java/module-info.java @@ -26,6 +26,7 @@ module sosengine.base { exports de.staropensource.sosengine.base.logging.implementation; exports de.staropensource.sosengine.base.types; exports de.staropensource.sosengine.base.types.dependency; + exports de.staropensource.sosengine.base.types.immutable; exports de.staropensource.sosengine.base.types.vectors; exports de.staropensource.sosengine.base.types.versioning; exports de.staropensource.sosengine.base.utility; @@ -51,6 +52,7 @@ module sosengine.base { opens de.staropensource.sosengine.base.logging.implementation; opens de.staropensource.sosengine.base.types; opens de.staropensource.sosengine.base.types.dependency; + opens de.staropensource.sosengine.base.types.immutable; opens de.staropensource.sosengine.base.types.vectors; opens de.staropensource.sosengine.base.types.versioning; opens de.staropensource.sosengine.base.utility; diff --git a/graphics/opengl/src/main/java/module-info.java b/graphics/opengl/src/main/java/module-info.java index 78961f6..9687f4e 100644 --- a/graphics/opengl/src/main/java/module-info.java +++ b/graphics/opengl/src/main/java/module-info.java @@ -1,3 +1,8 @@ +/** + * Defines the OpenGL Graphics API and {@code opengl} subsystem, which allows for communicating with the graphics card via OpenGL. + * + * @since 1-alpha1 + */ module sosengine.opengl { // Dependencies // -> Subsystems diff --git a/graphics/src/main/java/module-info.java b/graphics/src/main/java/module-info.java index 0da3c80..7e5ef3e 100644 --- a/graphics/src/main/java/module-info.java +++ b/graphics/src/main/java/module-info.java @@ -1,3 +1,8 @@ +/** + * Defines the {@code graphics} subsystem, which allows creating windows and drawing pixels onto the screen. + * + * @since 1-alpha1 + */ module sosengine.graphics { // Dependencies // -> Subsystems diff --git a/graphics/vulkan/src/main/java/module-info.java b/graphics/vulkan/src/main/java/module-info.java index 5d6674f..41146bf 100644 --- a/graphics/vulkan/src/main/java/module-info.java +++ b/graphics/vulkan/src/main/java/module-info.java @@ -1,3 +1,8 @@ +/** + * Defines the Vulkan Graphics API and {@code vulkan} subsystem, which allows for communicating with the graphics card via Vulkan. + * + * @since 1-alpha1 + */ module sosengine.vulkan { // Dependencies // -> Subsystems diff --git a/slf4j-compat/src/main/java/module-info.java b/slf4j-compat/src/main/java/module-info.java index a40c7c2..3b9271b 100644 --- a/slf4j-compat/src/main/java/module-info.java +++ b/slf4j-compat/src/main/java/module-info.java @@ -1,3 +1,8 @@ +/** + * Defines the {@code slf4j-compat} subsystem, which helps bridging the gap between SLF4J and the sos!engine by forwarding all SLF4J calls to the engine you love. + * + * @since 1-alpha1 + */ module sosengine.slf4j_compat { // Dependencies // -> Subsystems diff --git a/testapp/src/main/java/module-info.java b/testapp/src/main/java/module-info.java index f45f672..feff3d5 100644 --- a/testapp/src/main/java/module-info.java +++ b/testapp/src/main/java/module-info.java @@ -1,3 +1,9 @@ +/** + * Defines the sos!engine test application, used by engine developers to test their changes. + * This module is very uninteresting for non-engine developers. + * + * @since 1-alpha1 + */ open module sosengine.testapp { // Dependencies // -> Subsystems