Revert "removed comments"

This reverts commit d194d9e18d.

analysis_model.h

@@ -2,28 +2,50 @@
 #include <mutex>
 #include <condition_variable>
 
+/**
+ * Implementiert das Reader-Writer Problem mit:
+ * - Mehrere gleichzeitige Leser
+ * - Exklusiver Zugriff für Schreiber
+ * - Verhindert Writer-Starvation
+ */
 class AnalysisModel {
-    int value = 0;             
-    int reader_count = 0;      
+    int value = 0;              // Das geteilte Analysemodell (vereinfacht)
+    int reader_count = 0;       // Zählt aktive Leser
     
-    std::mutex model_mutex;     
-    std::mutex count_mutex;     
-    std::condition_variable no_writer; 
+    // Synchronisationsprimitive
+    std::mutex model_mutex;     // Schützt Schreibzugriffe (exklusiv)
+    std::mutex count_mutex;     // Schützt Leserzähler
+    std::condition_variable no_writer; // Garantiert Fairness
 
 public:
+    /**
+     * Lesender Zugriff
+     * @return Aktueller Wert des Modells
+     * 
+     * Funktionsweise:
+     * 1. Sperrt count_mutex und inkrementiert reader_count
+     * 2. Erster Leser sperrt model_mutex (blockiert Writer)
+     * 3. Entsperrt count_mutex während des Lesens
+     * 4. Liest Wert
+     * 5. Sperrt count_mutex zum Dekrementieren
+     * 6. Letzter Leser entsperrt model_mutex und benachrichtigt Writer
+     */
     int read() {
         std::unique_lock<std::mutex> count_lock(count_mutex);
         reader_count++;
         
+        // Erster Leser sperrt für Writer
         if(reader_count == 1) {
             model_mutex.lock();
         }
         count_lock.unlock();
 
+        // Kritischer Abschnitt (Lesen, kann parallel erfolgen)
         int result = value;
 
         count_lock.lock();
         reader_count--;
+        // Letzter Leser gibt für Writer frei
         if(reader_count == 0) {
             model_mutex.unlock();
             no_writer.notify_one();
@@ -32,12 +54,22 @@ public:
         return result;
     }
 
+    /**
+     * Schreibender Zugriff
+     * @param new_value Neuer Wert für das Modell
+     * 
+     * Funktionsweise:
+     * 1. Sperrt model_mutex (exklusiver Zugriff)
+     * 2. Schreibt neuen Wert
+     * 3. Wartet bis alle Leser fertig sind (Starvation Prevention)
+     */
     void write(int new_value) {
         std::unique_lock<std::mutex> lock(model_mutex);
         value = new_value;
         
+        // Verhindert Writer-Starvation
         no_writer.wait(lock, [this]() { 
             return reader_count == 0; 
         });
     }
-};
+};