qt-migration-legatus/qt5-before/dlbo/Lts/Services/GuezMinelayerProcessing/GFS_map_cont.h

/* --------------------------------------------------------------------
// $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-##########################################################################