refactor(impression): Improve impression entity snapshots

Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/ActiveEntity.kt

@@ -9,16 +9,19 @@ class ActiveEntity @JvmOverloads constructor(
     timestamp: Long = System.currentTimeMillis(),
     private val _evidences: MutableList<String> = mutableListOf(),
 ) : BlockContent("active_entity_$timestamp", "impression") {
-    val evidences: List<String> get() = _evidences
+    val evidences: List<String>
+        get() = synchronized(_evidences) { _evidences.toList() }
 
     private val _subject = AtomicReference("UNKNOWN")
     val subject: String get() = _subject.get()
 
     private val _projectedFeatures: MutableMap<String, Double> = mutableMapOf()
-    val projectedFeatures: Map<String, Double> get() = _projectedFeatures
+    val projectedFeatures: Map<String, Double>
+        get() = synchronized(_projectedFeatures) { _projectedFeatures.toMap() }
 
     private val _projectedImpressions: MutableMap<String, Double> = mutableMapOf()
-    val projectedImpressions: Map<String, Double> get() = _projectedImpressions
+    val projectedImpressions: Map<String, Double>
+        get() = synchronized(_projectedImpressions) { _projectedImpressions.toMap() }
 
     fun addEvidence(evidence: String) = synchronized(_evidences) {
         _evidences.add(evidence)

Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/Entity.kt

@@ -7,7 +7,7 @@ import kotlin.concurrent.withLock
 
 class Entity @JvmOverloads constructor(
     val uuid: String = UUID.randomUUID().toString(),
-    private val subject: String,
+    val subject: String,
     private val relations: MutableMap<String, MutableMap<String, Double>> = mutableMapOf(),
     private val impressions: MutableMap<String, IndexableData> = mutableMapOf(),
     private val features: MutableMap<String, IndexableData> = mutableMapOf()
@@ -105,6 +105,16 @@ class Entity @JvmOverloads constructor(
         }.toSet()
     }
 
+
+    fun showFeatures(): Set<FeatureView> = featureLock.withLock {
+        features.map {
+            FeatureView(
+                it.key,
+                it.value.confidence
+            )
+        }.toSet()
+    }
+
     data class IndexableData(
         var confidence: Double
     ) {
@@ -127,6 +137,11 @@ class Entity @JvmOverloads constructor(
         val relations: Map<String, Double>
     )
 
+    data class FeatureView(
+        val feature: String,
+        val confidence: Double
+    )
+
     @Suppress("ArrayInDataClass")
     data class ImpressionView(
         val impression: String,

Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/ImpressionCore.java

@@ -0,0 +1,51 @@
+package work.slhaf.partner.core.cognition.impression;
+
+import com.alibaba.fastjson2.JSONObject;
+import org.jetbrains.annotations.NotNull;
+import work.slhaf.partner.framework.agent.factory.capability.annotation.CapabilityCore;
+import work.slhaf.partner.framework.agent.factory.capability.annotation.CapabilityMethod;
+import work.slhaf.partner.framework.agent.state.State;
+import work.slhaf.partner.framework.agent.state.StateSerializable;
+
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+@CapabilityCore(value = "cognition")
+public class ImpressionCore implements StateSerializable {
+
+    private final ConcurrentHashMap<String, Entity> knownEntities = new ConcurrentHashMap<>();
+
+    @CapabilityMethod
+    public void updateRelation(){
+    }
+
+    @CapabilityMethod
+    public void updateImpression(){
+    }
+
+    @CapabilityMethod
+    public void showImpressions(){
+    }
+
+    @CapabilityMethod
+    public void projectEntity(Set<ActiveEntity> activeEntities){
+    }
+
+    @Override
+    public @NotNull Path statePath() {
+        return Path.of("core", "impression.json");
+    }
+
+    @Override
+    public void load(@NotNull JSONObject state) {
+
+    }
+
+
+    @Override
+    public @NotNull State convert() {
+        State state = new State();
+        return state;
+    }
+}