Initial commit

Lts/Services/GuezMinelayerProcessing/GFS_map_cont.h

@@ -0,0 +1,383 @@
+/* --------------------------------------------------------------------
+// $HeadURL$
+// --------------------------------------------------------------------
+//!
+// --------------------------------------------------------------------
+// COPYRIGHT (C) 1999: STN ATLAS ELEKTRONIK GMBH, D-28305 BREMEN
+// --------------------------------------------------------------------
+//
+// HIER/ITEM : CSU: RP 5182 R 100 SRC 51103
+// BRIEF DESC: Generische Container-Klasse auf Basis der STL
+// AUTHOR    : Norbert Thoden
+// RELEASE   :
+// MODIF/STAT: 28.06.99
+// ORIGIN REF:
+//
+// Revision INFO:
+// --------------
+//   $Revision$
+//   $Date$
+//   $Id$
+//
+// LANGUAGE: C++ (Compiler: MIPSPro Version: 7.2.1)
+// LANGUAGE: C++ (Compiler: MSVC  Version: 5.0)
+//
+// PURPOSE:
+// --------
+// Verschiedene assoziative Datentypen (Key <--> Date,
+// wie z.B. Positionsmeldungen)
+// werden in einem Container gesammelt.
+//
+// ERROR HANDLING:
+// ---------------
+// (keine / Beschreibung)
+//
+// IMPLEMENTATION DETAILS:
+// -----------------------
+// Benutzt wird eine Container vom Typ map aus der STL.
+// Wegen der Template-Eigenschaft mu? unter MS VC5.0 das entsprechende
+// cpp-File am Ende des Header-Files eingebunden werden.
+//
+//!
+*/
+
+#pragma once
+
+//------------------ includes ------------------------------
+#include <map>
+#include <vector>
+
+//------------------ externals (procs + vars) --------------
+
+//------------------ constants/ defines --------------------
+
+//------------------ types ---------------------------------
+
+typedef int32_t ausstattungs_id_t;
+typedef int32_t wirkfeldkennung_t;
+
+struct header_rt
+{
+  ausstattungs_id_t identitaet = 0;
+};
+
+struct gps_zeit_rt
+{
+  uint32_t gps_zeit = 0;
+};
+
+struct gps_position_rt
+{
+  int32_t utm_nordwert = 0;
+  int32_t utm_ostwert = 0;
+};
+
+enum ausstossart_et
+{
+  mitte = 0,
+  rechts = 1,
+  links = 2,
+  rechts_und_links = 3,
+  reserve = 4,
+  rechts_einzel = 5,
+  links_einzel = 6,
+  rechts_links_einzel = 7,
+};
+
+struct beschr_wmiv_verlegedaten_rt
+{
+  int16_t sperren_id = 0;
+  int16_t verlegedichte = 0;
+  gps_zeit_rt wirkbeginn;
+  uint16_t wirkzeit = 0;
+  uint16_t minentyp = 0;
+  ausstossart_et ausstossart = mitte;
+  int16_t anzahl_verlegter_minen = 0;
+};
+
+struct sondersensorik_wmiv_verlegedaten_rt
+{
+  header_rt header;
+  gps_zeit_rt gps_zeit;
+  gps_position_rt gps_position;
+  beschr_wmiv_verlegedaten_rt verlegedaten;
+};
+
+struct sondersensorik_fahrspur_rt
+{
+  header_rt header;
+  gps_zeit_rt gps_zeit;
+  gps_position_rt gps_position;
+  int16_t  ss_betriebszustand = 0;
+};
+
+
+struct Segment_rt {
+  gps_position_rt startpunkt;
+  int16_t anzahl = 0;
+  uint16_t drehwinkel = 0;
+};
+
+struct bes_wirkfeld_minensperre_rt
+{
+  wirkfeldkennung_t kennung;
+  gps_zeit_rt wirkbeginn;
+  uint32_t wirkdauer = 0;
+  gps_position_rt eckpunkt;
+  uint16_t wirkfeldbreite = 0;
+  uint16_t wirkfeldtiefe = 0;
+  uint32_t verlegetiefe = 0;
+  int32_t verlegedichte = 0;
+  uint16_t minentyp = 0;
+  int16_t minenanzahl = 0;
+  std::vector<Segment_rt> segmente;
+};
+
+struct wirkfeld_minensperre_rt
+{
+  header_rt header;
+  bes_wirkfeld_minensperre_rt beschreibung;
+};
+
+
+struct VERLEGEDATEN_INTERN
+{
+  int32_t status = -1;
+  sondersensorik_wmiv_verlegedaten_rt daten;
+}; //auch mivanh werden dort hinein geschrieben
+
+struct VERLEGEDATEN_KEY
+{
+  ausstattungs_id_t fz_id = -1;
+  gps_zeit_rt zeitpunkt;
+
+  bool operator==(const VERLEGEDATEN_KEY &o) const
+  {
+    return ((fz_id == o.fz_id) &&
+            (zeitpunkt.gps_zeit == o.zeitpunkt.gps_zeit));
+  }
+  bool operator!=(const VERLEGEDATEN_KEY &o) const
+  {
+    return !operator==(o);
+  }
+
+  bool operator<(const VERLEGEDATEN_KEY &o) const
+  {
+    if (fz_id != o.fz_id)
+      return (fz_id < o.fz_id);
+    return (zeitpunkt.gps_zeit < o.zeitpunkt.gps_zeit);
+  }
+};
+
+struct FAHRSPUR_INTERN
+{
+  int32_t intstat = -1;
+  sondersensorik_fahrspur_rt daten;
+};
+
+static inline VERLEGEDATEN_KEY keyFromFahrspur(const FAHRSPUR_INTERN &fs)
+{
+  VERLEGEDATEN_KEY ret;
+  ret.fz_id = fs.daten.header.identitaet;
+  ret.zeitpunkt = fs.daten.gps_zeit;
+  return ret;
+}
+
+//-------------------function prototypes -------------------
+
+//-------------------Class declarations --------------------
+
+
+
+//c+########################################################################*/
+template <class TKEY, class TDATA>
+class GFS_Map_Container
+//----------------------------------------------------------------------------
+//    DESCRIPTION:
+//
+//----------------------------------------------------------------------------
+{
+public:
+  //--------------------------------------------------------------------
+  //  Default constructor:
+
+  GFS_Map_Container()
+  {
+    //Iterator auf Begin legen:
+    it = container.begin();
+  }
+
+  //## EINTRAG HINZUFUEGEN ###################################################
+  bool     eintrag_container(const TKEY &key, const TDATA &data)
+  {
+    // Uwe Gahre von Astrid Mueller
+    std::pair<typename std::map<const TKEY, TDATA>::iterator, bool>
+    P = container.insert(std::make_pair(key, data));
+    return P.second;
+  }
+
+
+  // Ueberpruefen ob Eintrag vorhanden *ohne* iterator zu veraendern
+  bool contains(const TKEY &key) const
+  {
+    return (container.find(key) != container.end());
+  }
+
+  //## EINTRAG FINDEN #########################################################
+  TDATA    *finden_eintrag_container(const TKEY &key)
+  {
+    it = container.find(key);
+    if (it == container.end())
+      return nullptr;
+    TDATA *ptr = &((*it).second);
+    return ptr;
+  }
+
+
+  //## EINTRAG LOESCHEN #########################################################
+  bool    loeschen_eintrag_container(const TKEY &key)
+  {
+    it = container.find(key);
+    if (it == container.end())
+      return false;
+    container.erase(it++);
+    return true;
+  }
+
+  //## ALLE EINTRAEGE ABSCANNEN ################################################
+  void    scan_container(void (*fkt_ptr)(const TKEY *, TDATA *))
+  {
+    typedef typename std::map<const TKEY, TDATA>::iterator ITERATOR;
+    for (ITERATOR it = container.begin(); it != container.end(); ++it)
+    {
+      const TKEY *key_p = &(*it).first;        //Mu? const sein,
+      TDATA *data_p = &(*it).second;     //wg, map<const TKEY...
+      (fkt_ptr)(key_p, data_p);      //Zeiger auf Funktion
+    }
+  }
+
+  //## iter_reset #################################################
+  void iter_reset(void)    { it = container.begin(); }
+
+  //## iter_modify #################################################
+  bool iter_modify(int relativ)
+  {
+    // Wenn ueberhaupt Eintraege vorhanden sind...
+    if (!container.empty())
+    {
+      bool ret = true;
+      // bei positive Werten:
+      if (relativ >= 0)
+      {
+
+        for (int i = 0; i < relativ; i++)
+        {
+          // Wenn moeglich, it incrementieren:
+          if (it != container.end()) ++it;
+          // Ende nun erreicht?
+          if (it == container.end())
+          {
+            --it;   // Weil end() nicht gueltig ist, dekrementieren
+            ret = false;
+          }
+        }
+
+      }
+      else
+      {
+
+        relativ = -1 * relativ;
+        for (int i = 0; i < relativ; i++)
+        {
+          // Anfang erreicht? Hier v o r dem dekrementieren,
+          // um auch alle Eintraege z.B. per do while bearbeiten zu k?nnen.
+          // Damit ist das Verhalten wie beim Incrementieren.
+          if (it == container.begin())
+            ret = false;
+
+          if (it != container.begin()) --it;
+        }
+
+      }
+      return ret;
+
+    }
+    else
+    {
+      // keine Eintraege vorhanden:
+      return false;
+    }
+
+  }
+
+
+  //## iter_erase #############################################
+  bool iter_erase(void)
+  {
+    if (container.empty())
+      return false;
+
+    size_t size = container.size();
+
+    // aktuelles Element l?schen:
+    container.erase(it++);
+
+    // Wenn letztes Element geloescht wurde, diesen decrementieren,
+    // damit it auf ein gueltiges Paar zeigt. Jedoch nur wenn noch Daten
+    // enthalten sind. (Decrementieren von .end auf .begin => Core-Dump
+    if (!container.empty())
+    {
+      if (it == container.end())  --it;
+    }
+    else
+      it = container.begin();
+
+    // Wenn nun kleiner als vorher:
+    if (container.size() < size)
+      return true;
+    else
+      return false;
+  }
+
+
+
+  //## getKey #################################################
+  const TKEY &getKey() const
+  {
+    return ((*it).first);
+  }
+
+  //## getData #################################################
+  TDATA *getData()
+  {
+    return &((*it).second);
+  }
+
+
+  //## LOESCHEN DES CONTAINERS ##################################################
+  void clear()
+  {
+    container.clear();
+    // Iterator auf Beginn setzen:
+    it = container.begin();
+  }
+
+  bool empty() const { return container.empty(); }
+  //## AKTUELLE CONTAINERGROESSE ################################################
+  size_t size() const { return container.size(); }
+
+  std::map<const TKEY, TDATA> &c() { return  container; }
+  const std::map<const TKEY, TDATA> &c() const { return  container; }
+
+  //----------------------------------------------------------------------------
+protected:
+  //
+
+  //-----------------------------------------------------------------------------
+
+  // der Container vom Typ map:
+  std::map<const TKEY, TDATA> container;
+  // ein Iterator dazu:
+  typename std::map<const TKEY, TDATA>::iterator it;
+};
+//c-##########################################################################