313 lines
9.9 KiB
C++
Executable File
313 lines
9.9 KiB
C++
Executable File
/**
|
|
* MainHandler for AereaEffectSimulation
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
#include "main_handler.h"
|
|
#include "settings.h"
|
|
#include "logger.h"
|
|
#include "handler_air_support_impact.h"
|
|
#include "handler_explosion_single.h"
|
|
#include "handler_explosion_area.h"
|
|
#include "handler_explosion_cluster.h"
|
|
#include "handler_effect_cluster.h"
|
|
#include "handler_functional_area.h"
|
|
#include "handler_technical_area.h"
|
|
#include "handler_ncontamination.h"
|
|
#include "handler_bccontamination.h"
|
|
#include "handler_booby_trap.h"
|
|
#include "handler_off_route_mine.h"
|
|
#include "handler_mine_area.h"
|
|
#include "handler_mine_corridor.h"
|
|
#include "handler_danger_area.h"
|
|
#include "handler_recon_area.h"
|
|
#include "handler_charge_administration.h"
|
|
#include "meteo_data_provider.h"
|
|
#include "handler_borderline.h"
|
|
#include "handler_gas_pipe.h"
|
|
#include "handler_dus_single_mine.h"
|
|
#include "special_area_provider.h"
|
|
#include "handler_charge_effect.h"
|
|
#include "handler_trajectory.h"
|
|
#include "handler_effector.h"
|
|
|
|
// Elevation / Trajectory
|
|
#include <LtsElevation/lts_elevation_manager.h>
|
|
#include <Trajectory/trajectory_generator.h>
|
|
|
|
#include <DDS/DDSConnector/dds_connector.h>
|
|
#include <Core/pacemaker.h>
|
|
#include <ngldb/db_service_handler.h>
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
|
|
#include <QRandomGenerator>
|
|
#endif
|
|
|
|
namespace AreaEffectSimulation
|
|
{
|
|
MainHandler::MainHandler(QObject *parent)
|
|
: QObject(parent)
|
|
, m_logger(getLogger("MainHandler"))
|
|
{
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
|
|
QRandomGenerator(time(nullptr));
|
|
#else
|
|
qsrand(time(nullptr));
|
|
#endif
|
|
}
|
|
|
|
MainHandler::~MainHandler()
|
|
{
|
|
m_handlerAirSupportImpact = nullptr;
|
|
m_handlerExplosionSingle = nullptr;
|
|
m_handlerExplosionArea = nullptr;
|
|
m_handlerExplosionCluster = nullptr;
|
|
m_handlerEffectCluster = nullptr;
|
|
m_handlerFunctionalArea = nullptr;
|
|
m_handlerTechnicalArea = nullptr;
|
|
m_handlerNContamination = nullptr;
|
|
m_handlerBCContamination = nullptr;
|
|
m_handlerBoobyTrap = nullptr;
|
|
m_handlerMineArea = nullptr;
|
|
m_handlerMineCorridor = nullptr;
|
|
m_handlerDangerArea = nullptr;
|
|
m_handlerChargeAdmin = nullptr;
|
|
m_handlerReconArea = nullptr;
|
|
m_handlerBorderline = nullptr;
|
|
m_handlerGasPipe = nullptr;
|
|
m_handlerDusSingleMine = nullptr;
|
|
m_handlerChargeEffect = nullptr;
|
|
m_handlerTrajectory = nullptr;
|
|
m_meteoData = nullptr;
|
|
m_ddsHandler = nullptr;
|
|
m_dbHandler = nullptr;
|
|
m_dbHandlerEx0 = nullptr;
|
|
|
|
// LtsElevationManager and TrajectoryGenerator
|
|
// should do cleanup on their own :-)
|
|
}
|
|
|
|
|
|
bool MainHandler::init(int domainId, int exerciseId)
|
|
{
|
|
NOTICE_LOG(m_logger) << "\n\n*** Start AES ***\n\n";
|
|
// initialize database
|
|
m_dbHandler = std::make_shared<DbHandler>();
|
|
if(!m_dbHandler->init(exerciseId, Settings::settings()))
|
|
{
|
|
ERROR_LOG(m_logger) << "Initialisation DbHandler failed.";
|
|
return false;
|
|
}
|
|
|
|
if (exerciseId > 0)
|
|
{
|
|
m_dbHandlerEx0 = std::make_shared<DbHandler>();
|
|
if (!m_dbHandlerEx0->init(0, Settings::settings())) // need a second db connection due to username/password
|
|
{
|
|
ERROR_LOG(m_logger) << "Could not init DbHandler";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError,
|
|
QStringLiteral("Could not init DbHandler"));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_dbHandlerEx0 = m_dbHandler;
|
|
}
|
|
|
|
|
|
// initialize DDS
|
|
m_ddsHandler = std::make_shared<DdsHandler>(domainId, exerciseId);
|
|
if (!m_ddsHandler->init())
|
|
{
|
|
ERROR_LOG(m_logger) << "Initialisation DdsHandler failed.";
|
|
return false;
|
|
}
|
|
|
|
m_meteoData = std::make_shared<MeteoDataProvider>(this);
|
|
|
|
m_specialAreaProvider = std::make_shared<SpecialAreaProvider>(this);
|
|
|
|
// read project specific data from database
|
|
// publish project specific data
|
|
// initialize the specific AES handler
|
|
|
|
return initAESHandler();
|
|
}
|
|
|
|
bool MainHandler::initAESHandler()
|
|
{
|
|
// init this one first as it's needed by ExplosionArea/Single:
|
|
m_handlerChargeAdmin = std::make_shared<HandlerChargeAdministration>(this);
|
|
if (!m_handlerChargeAdmin->init())
|
|
return false;
|
|
|
|
m_handlerAirSupportImpact = std::make_shared<HandlerAirSupportImpact>(this);
|
|
if (!m_handlerAirSupportImpact->init())
|
|
return false;
|
|
|
|
m_handlerExplosionSingle = std::make_shared<HandlerExplosionSingle>(this);
|
|
if (!m_handlerExplosionSingle->init())
|
|
return false;
|
|
|
|
m_handlerExplosionArea = std::make_shared<HandlerExplosionArea>(this);
|
|
if (!m_handlerExplosionArea->init())
|
|
return false;
|
|
|
|
|
|
// prepare some basics for HandlerExplosionCluster
|
|
// - TrajectoryGenerator
|
|
// - LtsElevationManager
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " ****** std::make_shared<HandlerExplosionCluster...";
|
|
const int exerciseId = dds()->exerciseId();
|
|
LtsElevation::LTS_ELEVATION_MANAGER_TYPE ltsElevationManager = LtsElevation::LtsElevationManager::createInstance(exerciseId,
|
|
dds()->exmDtc(),
|
|
dds()->asmDtc());
|
|
if (ltsElevationManager)
|
|
{
|
|
// waitForInitialization,
|
|
// ElevationFile is read in a workerThread and waitForInitialization is used via QFutureWatcher
|
|
// So the logMsg 'Finished reading elevation map of file' will be shown with a delay.
|
|
// Thuis is no error.
|
|
ltsElevationManager->waitForInitialization();
|
|
}
|
|
|
|
#ifndef LTS_DEBUG
|
|
#ifndef Q_OS_WIN // GUEZE-2195
|
|
if (!ltsElevationManager)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " LtsElevation::createInstance failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
#endif // Q_OS_WIN
|
|
#endif // LTS_DEBUG
|
|
|
|
TrajectoryGenerator *trajectoryGenerator = TrajectoryGenerator::getInstance(this->dds()->exerciseId(),
|
|
this->dds()->exmDtc(),
|
|
this->dds()->asmDtc());
|
|
if (!trajectoryGenerator)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " TrajectoryGenerator::getInstance failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
|
|
m_handlerExplosionCluster = std::make_shared<HandlerExplosionCluster>(this);
|
|
if (!m_handlerExplosionCluster->init())
|
|
return false;
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " ****** std::make_shared<HandlerExplosionCluster... DONE";
|
|
|
|
m_handlerFunctionalArea = std::make_shared<HandlerFunctionalArea>(this);
|
|
if (!m_handlerFunctionalArea->init())
|
|
return false;
|
|
|
|
m_handlerTechnicalArea = std::make_shared<HandlerTechnicalArea>(this);
|
|
if (!m_handlerTechnicalArea->init())
|
|
return false;
|
|
|
|
m_handlerNContamination = std::make_shared<HandlerNContamination>(this);
|
|
if (!m_handlerNContamination->init())
|
|
return false;
|
|
|
|
m_handlerBCContamination = std::make_shared<HandlerBCContamination>(this);
|
|
if (!m_handlerBCContamination->init())
|
|
return false;
|
|
|
|
m_handlerBoobyTrap = std::make_shared<HandlerBoobyTrap>(this);
|
|
if (!m_handlerBoobyTrap->init())
|
|
return false;
|
|
|
|
m_handlerOffRouteMine = std::make_shared<HandlerOffRouteMine>(this);
|
|
if (!m_handlerOffRouteMine->init())
|
|
return false;
|
|
|
|
// Corridor needed for Mine Area, so instatiate first!
|
|
m_handlerMineCorridor = std::make_shared<HandlerMineCorridor>(this);
|
|
if (!m_handlerMineCorridor->init())
|
|
return false;
|
|
|
|
m_handlerMineArea = std::make_shared<HandlerMineArea>(this);
|
|
if (!m_handlerMineArea->init())
|
|
return false;
|
|
|
|
m_handlerDangerArea = std::make_shared<HandlerDangerArea>(this);
|
|
if (!m_handlerDangerArea->init())
|
|
return false;
|
|
|
|
m_handlerReconArea = std::make_shared<HandlerReconArea>(this);
|
|
if (!m_handlerReconArea->init())
|
|
return false;
|
|
|
|
m_handlerDusSingleMine = std::make_shared<HandlerDusSingleMine>(this);
|
|
if (!m_handlerDusSingleMine->init())
|
|
return false;
|
|
|
|
|
|
// create HandlerBorderline
|
|
m_handlerBorderline = std::make_shared<HandlerBorderline>(this);
|
|
if (!m_handlerBorderline->init())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " Initialisation HandlerBorderline failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
|
|
// create HandlerGasPipe
|
|
m_handlerGasPipe = std::make_shared<HandlerGasPipe>(this);
|
|
if (!m_handlerGasPipe->init())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " Initialisation HandlerGasPipe failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
|
|
// create HandlerChargeEffect
|
|
m_handlerChargeEffect = std::make_shared<HandlerChargeEffect>(this);
|
|
if (!m_handlerChargeEffect->init())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " Initialisation HandlerChargeEffect failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
|
|
// create HandlerTrajectory
|
|
m_handlerTrajectory = std::make_shared<HandlerTrajectory>(this);
|
|
// m_handlerTrajectory: no init required
|
|
|
|
// create HandlerEffector
|
|
m_handlerEffector = std::make_shared<HandlerEffector>(this);
|
|
if (!m_handlerEffector->init())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " Initialisation HandlerChargeEffect failed.";
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::inner_enum::StoppedError);
|
|
return false;
|
|
}
|
|
// Effect Cluster last as we need Effector first
|
|
m_handlerEffectCluster = std::make_shared<HandlerEffectCluster>(this);
|
|
if (!m_handlerEffectCluster->init())
|
|
return false;
|
|
|
|
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::Running);
|
|
|
|
return true;
|
|
}
|
|
|
|
std::shared_ptr<DatabaseInterface> MainHandler::db()
|
|
{
|
|
return m_dbHandler->db();
|
|
}
|
|
|
|
std::shared_ptr<DatabaseInterface> MainHandler::dbEx0()
|
|
{
|
|
return m_dbHandlerEx0->db();
|
|
}
|
|
|
|
ProjectDataManagement::GearClass MainHandler::gearClassOfChargeTypeId(int chargeTypeId) const
|
|
{
|
|
return m_ddsHandler->pdmDtc()->gearClassFromChargeTypeId(chargeTypeId);
|
|
}
|
|
|
|
} // namespace AreaEffectSimulation
|