feat(api)!: add capabilities to nodes

alchemist-full/build.gradle.kts

@@ -7,6 +7,9 @@ import Libs.alchemist
  * GNU General Public License, with a linking exception,
  * as described in the file LICENSE in the Alchemist distribution"s top directory.
  */
+plugins {
+    application
+}
 
 dependencies {
     runtimeOnly(rootProject)
@@ -17,10 +20,6 @@ dependencies {
     testImplementation(alchemist("euclidean-geometry"))
 }
 
-plugins {
-    application
-}
-
 application {
     mainClass.set("it.unibo.alchemist.Alchemist")
 }

alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/implementations/nodes/AbstractNode.java

@@ -9,6 +9,7 @@
 package it.unibo.alchemist.model.implementations.nodes;
 
 import com.google.common.collect.MapMaker;
+import it.unibo.alchemist.model.interfaces.Capability;
 import it.unibo.alchemist.model.interfaces.Environment;
 import it.unibo.alchemist.model.interfaces.Molecule;
 import it.unibo.alchemist.model.interfaces.Node;
@@ -18,17 +19,21 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
 import java.util.Spliterator;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 
 /**
@@ -46,6 +51,7 @@ public abstract class AbstractNode<T> implements Node<T> {
     private final int id;
     private final List<Reaction<T>> reactions = new ArrayList<>();
     private final Map<Molecule, T> molecules = new LinkedHashMap<>();
+    private final Map<Class<? extends Capability>, Capability> capabilities = new HashMap<>();
 
     private static int idFromEnv(final Environment<?, ?> env) {
         MUTEX.acquireUninterruptibly();
@@ -190,6 +196,22 @@ public void setConcentration(final Molecule molecule, final T concentration) {
         molecules.put(molecule, concentration);
     }
 
+    @Override
+    public void addCapability(final Capability capability) {
+        this.capabilities.put(capability.getClass(), capability);
+    }
+
+    @Override
+    public Optional<Capability> asCapability(final Class<? extends Capability> type) {
+        return Optional.ofNullable(this.capabilities.get(type));
+    }
+
+    @Override
+    public Set<Capability> getCapabilities() {
+        return this.capabilities.entrySet().stream()
+                .map(Map.Entry::getValue).collect(Collectors.toSet());
+    }
+
     @Override
     public final Spliterator<Reaction<T>> spliterator() {
         return reactions.spliterator();

alchemist-interfaces/src/main/java/it/unibo/alchemist/model/interfaces/Node.java

@@ -10,6 +10,8 @@
 import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
 
 /**
  * @param <T>
@@ -116,4 +118,21 @@ public interface Node<T> extends Serializable, Iterable<Reaction<T>>, Comparable
      */
     void setConcentration(Molecule mol, T c);
 
+    /**
+     * Adds a capability to the node.
+     * @param capability the capability you want to add to the node
+     */
+    void addCapability(Capability capability);
+
+    /**
+     * @param type the type of capability to retrieve
+     * @return an optional with a capability of the requested type
+     */
+    Optional<Capability> asCapability(Class<? extends Capability> type);
+
+    /**
+     * @return a set of the capabilities added to the node
+     */
+    Set<Capability> getCapabilities();
+
 }

alchemist-interfaces/src/main/kotlin/it/unibo/alchemist/model/interfaces/Capability.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2010-2022, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.interfaces
+
+/**
+ * Represents a node capability.
+ */
+interface Capability
+git

build.gradle.kts

@@ -9,6 +9,7 @@
 import Libs.alchemist
 import Libs.incarnation
 import Util.fetchJavadocIOForDependency
+import Util.id
 import Util.testShadowJar
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
@@ -28,8 +29,6 @@ plugins {
     alias(libs.plugins.hugo)
 }
 
-val Provider<PluginDependency>.id get() = get().pluginId
-
 allprojects {
 
     with(rootProject.libs.plugins) {

buildSrc/src/main/kotlin/Util.kt

@@ -7,6 +7,7 @@ import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.Exec
 import org.gradle.kotlin.dsl.register
+import org.gradle.plugin.use.PluginDependency
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.net.URL
@@ -113,4 +114,9 @@ object Util {
             }
         }
     }
+
+    /**
+     * Directly accesses the plugin id.
+     */
+    val Provider<PluginDependency>.id get() = get().pluginId
 }