384 lines
9.1 KiB
C++
Executable File
384 lines
9.1 KiB
C++
Executable File
/* --------------------------------------------------------------------
|
|
// $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-##########################################################################
|