Initial commit

Lts/Services/AudioVideoManagement/asset_assignment_manager.h

@@ -0,0 +1,148 @@
+/**
+  * @RDE_HEADER@
+  * InfrastructureBuilder
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Fröbel, SLSE, 2017-11-29
+  */
+
+#pragma once
+
+#include "exercise_context.h"
+#include "avm_export.h"
+#include "logger.h"
+#include <QObject>
+#include <boost/optional.hpp>
+#include <map>
+#include <set>
+#include <memory>
+#include <utility>
+
+namespace InfrastructureManagement
+{
+
+class MainStructureElement;
+class StructureElement;
+class MountingPointAsset;
+class InstrumentationAsset;
+
+namespace Interface
+{
+class Dtc;
+}
+
+} // namespace InfrastructureManagement
+
+
+enum class DataModification;
+
+
+namespace AudioVideoManagement
+{
+
+class Exercise;
+class Asset;
+class MountingPoint;
+
+
+/**
+ * The AssetAssignmentManager keeps track of whether an Asset is assigned to an Exercise or not.
+ * In AVM we're usually only interested in Assets that are Cameras or AnnouncementUnits.
+ * But here we keep track of all Assets and MountingPoints as this makes it easier
+ * to keep the data model consistent.
+ *
+ * There are two aspects:
+ * 1. An Asset can be mounted
+ * 2. The MountingPoint the Asset is mounted on can be assigned to an Exercise or not.
+ *
+ * From AVM perspective we're only interested in the fact of whether an Asset is assigned
+ * to an exercise or not.
+ *
+ * The difficulty here is to keep the data model consistent despite the fact that
+ * the data published on DDS has no defined ordering.
+ *
+ * The idea here is to have containers for Assets (and MountingPoints): an Exercise.
+ * There exists a "pool" Exercise where all Assets (and MountingPoints) reside that are
+ * not assigned to an Exercise.
+ * And there are concrete Exercise-containers for all existing Exercises.
+ * An Asset (and MountingPoint) will only be moved from the pool Exercise to the concrete
+ * Exercise if and only if the Asset is mounted and assigned to an Exercise.
+ *
+ * Mounting and Assigning are two distinct steps.
+ * Mounting only affects the mounting relation of Asset and MountingPoint but does not move
+ * the Asset (and MountingPoint). Thus the Mounting (and Unmounting) always happens in the pool Exercise.
+ * Assignment can only take place when the Asset is mounted. Assignment then moves the
+ * Asset (and MountingPoint) to the concrete Exercise.
+ *
+ * An Asset can be reassigned from one Exercise to another Exercise. This happens
+ * when the MountingPoint is reassigned while the Asset is mounted.
+ *
+ * @author Christian Fröbel
+ */
+class AVM_COMMON_EXPORT AssetAssignmentManager : public QObject
+{
+  Q_OBJECT
+
+public:
+  /** Creates *and* connects the relevant signals. */
+  static AssetAssignmentManager *create(InfrastructureManagement::Interface::Dtc *ismDtc);
+
+  /** Don't use! Use create() instead. Only provided to be used in UnitTests. */
+  AssetAssignmentManager();
+  ~AssetAssignmentManager();
+
+  /**
+   * Implicitly creates an Exercise if it does not yet exist.
+   * The AssetAssignmentManager keeps ownership.
+   */
+  Exercise *exercise(int id);
+
+  /** Called by the ExercisesHandler after the corresponding ExerciseHandler was removed.  */
+  void removeExercise(int id);
+
+  /** For UnitTests only. */
+  bool hasPending() const;
+
+public slots: // public only for use in UnitTests
+  void onAssetChanged(const InfrastructureManagement::InstrumentationAsset &asset, DataModification modType);
+  void onMainStructureElementChanged(const InfrastructureManagement::MainStructureElement &data, DataModification modType);
+  void onMountingChanged(const InfrastructureManagement::MountingPointAsset &mount, DataModification modType);
+
+private:
+  void addAsset(const InfrastructureManagement::InstrumentationAsset &asset);
+  void modifyAsset(const InfrastructureManagement::InstrumentationAsset &asset);
+  void removeAsset(const InfrastructureManagement::InstrumentationAsset &asset);
+
+  void tryAssignAsset(Asset *asset, Exercise *currentExercise, Exercise *targetExercise, const boost::optional<InfrastructureManagement::InstrumentationAsset> &modifiedData);
+  void unassignAsset(Asset *asset, Exercise *exercise, const boost::optional<InfrastructureManagement::InstrumentationAsset> &modifiedData);
+
+  void addMount(const InfrastructureManagement::MountingPointAsset &mount);
+  void removeMount(const InfrastructureManagement::MountingPointAsset &mount);
+
+  void tryUnmount(Asset *asset, Exercise *exercise = nullptr);
+
+  void processPendingModifications();
+  void processPendingUnmounts();
+  void processPendingMounts();
+  void processPendingRemoves();
+  template<class Container, class Function>
+  void processPending(Container &pendingSource, Function f);
+  bool hasPendingModifications(int assetId);
+  void logPending();
+
+  Exercise *pool() const;
+
+  std::pair<Exercise *, Asset *>         findAsset(int id);
+  std::pair<Exercise *, MountingPoint *> findMountingPoint(int id);
+
+private:
+  std::map<ExerciseContext, std::unique_ptr<Exercise>>         m_exercises;
+  std::vector<InfrastructureManagement::InstrumentationAsset>  m_pendingModifications;
+  std::vector<Asset *>                                         m_pendingUnmounts;
+  std::vector<InfrastructureManagement::MountingPointAsset>    m_pendingMounts;
+  std::vector<InfrastructureManagement::InstrumentationAsset>  m_pendingRemoves;
+  LOGGER_T                                                     m_logger;
+};
+
+} // namespace AudioVideoManagement