torstenandCopilot
7173785915
Major Changes:
- Merged latest Qt5 devel content from dlbo (292 files changed, 7 new dirs)
- Consolidated forward-declarations and include folders
- Removed unneeded modules per Niklas' repo check list
Build System Fixes:
- Fixed CMake VERSION_GREATER syntax in ParticipantManagement/CMakeLists.txt
- Added VLC packages (libvlc-dev, vlc-plugin-base) to docker_build.sh
- Added PostgreSQL dev packages (libpq-dev, postgresql-server-dev-all) to Dockerfile
- Fixed locale warnings (ANSI_X3.4-1968 → C.UTF-8)
- Fixed ArcGIS SDK path warnings when BUILD_ARCGIS=OFF
Code Generation Fixes:
- Fixed IDL enum collisions (PortType→CorePortType/DdsutPortType, PdmEventType)
- Fixed Grantlee template svc_translation.cpp.grantlee:
- Changed {{ idl_enum.name }}_def:: to {{ idl_enum.name }}::
- Fixed .underlying() calls for C++11 scoped enums (enum class)
- Removed generated files from repo (moc_*, *_dtc.h, *_ftc.h)
Validation:
- BUILD_RTI=ON: SUCCESS
- BUILD_RTI=OFF: SUCCESS
- C++17 standard maintained for RTI 7.7 compatibility
- Ubuntu 26.04 Docker environment verified
Remaining Warnings (expected):
- BgViewer, KDChart, KDReports, Poppler-Qt6 not found (optional features)
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
737 lines
40 KiB
C++
737 lines
40 KiB
C++
/**
|
|
* PDM Data Topic Client Interface
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Hanna E. Rathje, SLSE, 2016-01-04
|
|
*/
|
|
|
|
|
|
// filename: pdm_dtc.h
|
|
#pragma once
|
|
|
|
#include <QMap>
|
|
#include <QObject>
|
|
#include <functional>
|
|
#include <LtsUtilsCore/data_modification_enum.h>
|
|
|
|
#include <ProjectDataManagement/pdm_export.h>
|
|
#include <ProjectDataManagement/pdm.hpp>
|
|
|
|
// Bring Core namespace types into scope for Interface namespace
|
|
using namespace ProjectDataManagement;
|
|
|
|
namespace DDSConnector
|
|
{
|
|
class DdsConnector;
|
|
}
|
|
|
|
namespace ProjectDataManagement
|
|
{
|
|
namespace Interface
|
|
{
|
|
class PDM_COMMON_EXPORT Dtc : public QObject
|
|
{
|
|
Q_OBJECT
|
|
protected:
|
|
Dtc() = default;
|
|
public:
|
|
virtual ~Dtc() = default;
|
|
|
|
/**
|
|
* Create a new instance for ProjectDataManagement::Interface::Dtc.
|
|
*/
|
|
static std::shared_ptr<Dtc> create(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector);
|
|
|
|
/**
|
|
* A unique identifier for this DTC
|
|
*/
|
|
static inline const char *identifier() { return "ProjectDataManagement.Interface.Dtc"; }
|
|
|
|
/**
|
|
* initialize this Dts instance with all data topic readers
|
|
*/
|
|
virtual bool enableAll(bool enable = true) = 0;
|
|
/**
|
|
* only initialize the specific reader (can be called instead enableAll())
|
|
*/
|
|
|
|
virtual bool enableBiteComponentText(bool enable = true) = 0;
|
|
virtual bool isBiteComponentTextEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataBiteComponentText(int timeoutMSec = -1) = 0;
|
|
virtual bool enableBuildingChargeEffect(bool enable = true) = 0;
|
|
virtual bool isBuildingChargeEffectEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataBuildingChargeEffect(int timeoutMSec = -1) = 0;
|
|
virtual bool enableCanComponentString(bool enable = true) = 0;
|
|
virtual bool isCanComponentStringEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataCanComponentString(int timeoutMSec = -1) = 0;
|
|
virtual bool enableChargeType(bool enable = true) = 0;
|
|
virtual bool isChargeTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataChargeType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableChargeTypeIgniterTypeIgniterFunction(bool enable = true) = 0;
|
|
virtual bool isChargeTypeIgniterTypeIgniterFunctionEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataChargeTypeIgniterTypeIgniterFunction(int timeoutMSec = -1) = 0;
|
|
virtual bool enableChargeTypeLoadType(bool enable = true) = 0;
|
|
virtual bool isChargeTypeLoadTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataChargeTypeLoadType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableEquipmentSystemEventFilter(bool enable = true) = 0;
|
|
virtual bool isEquipmentSystemEventFilterEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataEquipmentSystemEventFilter(int timeoutMSec = -1) = 0;
|
|
virtual bool enableEventFilterHgrMineSearch(bool enable = true) = 0;
|
|
virtual bool isEventFilterHgrMineSearchEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataEventFilterHgrMineSearch(int timeoutMSec = -1) = 0;
|
|
virtual bool enableFirePurpose(bool enable = true) = 0;
|
|
virtual bool isFirePurposeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataFirePurpose(int timeoutMSec = -1) = 0;
|
|
virtual bool enableGearType(bool enable = true) = 0;
|
|
virtual bool isGearTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataGearType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableGearTypeChargeType(bool enable = true) = 0;
|
|
virtual bool isGearTypeChargeTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataGearTypeChargeType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableIgniterFunction(bool enable = true) = 0;
|
|
virtual bool isIgniterFunctionEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataIgniterFunction(int timeoutMSec = -1) = 0;
|
|
virtual bool enableIgniterType(bool enable = true) = 0;
|
|
virtual bool isIgniterTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataIgniterType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableLanguageHmi(bool enable = true) = 0;
|
|
virtual bool isLanguageHmiEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataLanguageHmi(int timeoutMSec = -1) = 0;
|
|
virtual bool enableLanguageXdu(bool enable = true) = 0;
|
|
virtual bool isLanguageXduEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataLanguageXdu(int timeoutMSec = -1) = 0;
|
|
virtual bool enableLoadType(bool enable = true) = 0;
|
|
virtual bool isLoadTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataLoadType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableNuclearPreset(bool enable = true) = 0;
|
|
virtual bool isNuclearPresetEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataNuclearPreset(int timeoutMSec = -1) = 0;
|
|
virtual bool enableRadioGroup(bool enable = true) = 0;
|
|
virtual bool isRadioGroupEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataRadioGroup(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationInjury(bool enable = true) = 0;
|
|
virtual bool isSanitationInjuryEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationInjury(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationInjuryKind(bool enable = true) = 0;
|
|
virtual bool isSanitationInjuryKindEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationInjuryKind(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationInjuryPlace1(bool enable = true) = 0;
|
|
virtual bool isSanitationInjuryPlace1Enabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationInjuryPlace1(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationInjuryPlace2(bool enable = true) = 0;
|
|
virtual bool isSanitationInjuryPlace2Enabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationInjuryPlace2(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationMaterial(bool enable = true) = 0;
|
|
virtual bool isSanitationMaterialEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationMaterial(int timeoutMSec = -1) = 0;
|
|
virtual bool enableSanitationProcedure(bool enable = true) = 0;
|
|
virtual bool isSanitationProcedureEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataSanitationProcedure(int timeoutMSec = -1) = 0;
|
|
virtual bool enableTargetSubType(bool enable = true) = 0;
|
|
virtual bool isTargetSubTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataTargetSubType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableTargetType(bool enable = true) = 0;
|
|
virtual bool isTargetTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataTargetType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableTargetTypeTargetSubType(bool enable = true) = 0;
|
|
virtual bool isTargetTypeTargetSubTypeEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataTargetTypeTargetSubType(int timeoutMSec = -1) = 0;
|
|
virtual bool enableTranslationBlob(bool enable = true) = 0;
|
|
virtual bool isTranslationBlobEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataTranslationBlob(int timeoutMSec = -1) = 0;
|
|
virtual bool enableVulnerabilityKind(bool enable = true) = 0;
|
|
virtual bool isVulnerabilityKindEnabled() const = 0;
|
|
virtual bool waitForHistoricalDataVulnerabilityKind(int timeoutMSec = -1) = 0;
|
|
|
|
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<ProjectDataManagement::ChargeType> chargesForGearClass(GearClass gearClass) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<ProjectDataManagement::IgniterType> ignitersForChargeType(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction> igniterFunctionsForChargeTypeIgniterType(int chargeTypeId, int igniterTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<ProjectDataManagement::LoadType> loadsForChargeType(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getTargetTypeIdFromAdlerTargetType(const QString &typ) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getTargetSubTypeIdFromAdlerTargetSubType(const QString &subTyp) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerTargetTypeName(int targetTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerTargetSubTypeName(int targetSubTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getChargeTypeIdFromAdlerCharges(const QString &geschosssorte) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getIgniterTypeIdFromAdlerIgniter(const QString &zuender) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getIgniterFunctionIdFromAdlerIgniterFunction(const QString &zuenderFunction) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getLoadTypeIdFromAdlerLoad(const QString &ladung) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerChargeTypeName(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerIgniterTypeName(int igniterTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerIgniterFunctionName(int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString adlerLoadTypeName(int loadTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double expansionFactor(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double impactEdgeLength(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double impactRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isDryFire(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool canBeThrown(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool canBeCreated(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int mineClass(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isIed(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isReactivatable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isSmart(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isSmoke(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int maxEffectShows(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isVisible(int chargeTypeId, int igniterTypeId = 0, int igniterFunctionId = 0) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isIndirect(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isLaserGuidable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isUasDroppable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isJamming(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int searchRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool showHitline(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int remainingTasCode(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int secondaryRemainingTasCode(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int segments(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isLine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isFromMineLayer(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isMineLaying(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QJsonObject mineLayingPattern(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<int> spacing(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual VolatilityType volatilityTypeId(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int hazardDistance(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int height(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<CasEffect> casEffects(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isAdlerChargeType(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual GearClass gearClassFromChargeTypeId(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<int> gearTypeIdFromChargeTypeId(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<TargetSubType> targetSubTypesForTargetType(int targetTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QVector<SanitationProcedure> getSanitationProcedures(long long procedures) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QStringList sanitationProceduresList(long long procedures) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int chargeTypeIdFromLegacyId(GearClass gearClass, int legacyId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual ChargeTypeIgniterTypeIgniterFunction getChargeTypeIgniterTypeIgniterFunction(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual ChargeTypeLoadType getChargeTypeLoadType(int chargeTypeId, int loadTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool canRestock(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool canSetDefaults(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getAdlerWeaponSystemId(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int cadence(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int maxCharges(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int maxCharge(int gearTypeId, int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int factoryDefault(int gearTypeId, int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trBiteComponentTextName(int biteComponentId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trCanComponentStringName(int cancComponentId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trChargeTypeShortName(int chargeTypeId, bool omitBaseSuffix = false) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trChargeTypeName(int chargeTypeId, bool omitBaseSuffix = false) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trFirePurposeName(int firePurposeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trGearTypeName(int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trIgniterTypeName(int igniterTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trIgniterTypeShortName(int igniterTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trIgniterFunctionName(int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trIgniterFunctionShortName(int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trLoadTypeName(int loadTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trLoadTypeShortName(int loadTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trTargetTypeName(int targetTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trTargetSubTypeName(int targetSubTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trLanguageHmiName(int languageHmiId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trLanguageXduName(int languageXduId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trNuclearPresetName(int nuclearPresetId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trRadioGroupName(int radioGroupId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trVulnerabilityKindName(int vulnerabilityKindId, VulnerabilityClass vulnerabilityClassId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trSanitationMaterialName(int sanitationMaterialId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trSanitationProcedureName(int sanitationProcedureId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trSanitationInjuryKindName(int sanitationInjuryKindId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trSanitationInjuryPlace1Name(int sanitationInjuryPlace1Id) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QString trSanitationInjuryPlace2Name(int sanitationInjuryPlace2Id) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual QStringList chargeNames(std::vector<int> &chargeIds) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getAvailableChargeTypeId(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual ChargeTypeProperty getChargeTypeSpecialProperty(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isAtMine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isApMine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double getLethalRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double getNonLethalRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual double getMaxRange(int chargeTypeId, int gearTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual ProjectDataManagement::BuildingChargeEffect getBuildingChargeEffectByChargeTypeId(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isVirtuallyFireable(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual int getAmountFireMarkers(int firePurposeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool getWithDurationFirePurpose(int firePurposeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isGmlrs(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isDm72(int chargeTypeId) = 0;
|
|
// custom procs, body must be implemented by user
|
|
virtual bool isRocket(int chargeTypeId) = 0;
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'BiteComponentText'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::BiteComponentText> biteComponentTexts() = 0;
|
|
virtual bool biteComponentTexts(const std::function<void(const ::ProjectDataManagement::BiteComponentText &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool biteComponentTexts(const std::function<bool(const ::ProjectDataManagement::BiteComponentText &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::BiteComponentText biteComponentText(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void biteComponentTextChanged(const ::ProjectDataManagement::BiteComponentText &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'BuildingChargeEffect'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::BuildingChargeEffect> buildingChargeEffects() = 0;
|
|
virtual bool buildingChargeEffects(const std::function<void(const ::ProjectDataManagement::BuildingChargeEffect &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool buildingChargeEffects(const std::function<bool(const ::ProjectDataManagement::BuildingChargeEffect &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::BuildingChargeEffect buildingChargeEffect(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void buildingChargeEffectChanged(const ::ProjectDataManagement::BuildingChargeEffect &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'CanComponentString'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::CanComponentString> canComponentStrings() = 0;
|
|
virtual bool canComponentStrings(const std::function<void(const ::ProjectDataManagement::CanComponentString &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool canComponentStrings(const std::function<bool(const ::ProjectDataManagement::CanComponentString &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::CanComponentString canComponentString(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void canComponentStringChanged(const ::ProjectDataManagement::CanComponentString &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'ChargeType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::ChargeType> chargeTypes() = 0;
|
|
virtual bool chargeTypes(const std::function<void(const ::ProjectDataManagement::ChargeType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool chargeTypes(const std::function<bool(const ::ProjectDataManagement::ChargeType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::ChargeType chargeType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void chargeTypeChanged(const ::ProjectDataManagement::ChargeType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'ChargeTypeIgniterTypeIgniterFunction'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction> chargeTypeIgniterTypeIgniterFunctions() = 0;
|
|
virtual bool chargeTypeIgniterTypeIgniterFunctions(const std::function<void(const ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool chargeTypeIgniterTypeIgniterFunctions(const std::function<bool(const ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction chargeTypeIgniterTypeIgniterFunction(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void chargeTypeIgniterTypeIgniterFunctionChanged(const ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'ChargeTypeLoadType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::ChargeTypeLoadType> chargeTypeLoadTypes() = 0;
|
|
virtual bool chargeTypeLoadTypes(const std::function<void(const ::ProjectDataManagement::ChargeTypeLoadType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool chargeTypeLoadTypes(const std::function<bool(const ::ProjectDataManagement::ChargeTypeLoadType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::ChargeTypeLoadType chargeTypeLoadType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void chargeTypeLoadTypeChanged(const ::ProjectDataManagement::ChargeTypeLoadType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'EquipmentSystemEventFilter'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::EquipmentSystemEventFilter> equipmentSystemEventFilters() = 0;
|
|
virtual bool equipmentSystemEventFilters(const std::function<void(const ::ProjectDataManagement::EquipmentSystemEventFilter &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool equipmentSystemEventFilters(const std::function<bool(const ::ProjectDataManagement::EquipmentSystemEventFilter &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::EquipmentSystemEventFilter equipmentSystemEventFilter(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void equipmentSystemEventFilterChanged(const ::ProjectDataManagement::EquipmentSystemEventFilter &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'EventFilterHgrMineSearch'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::EventFilterHgrMineSearch> eventFilterHgrMineSearchs() = 0;
|
|
virtual bool eventFilterHgrMineSearchs(const std::function<void(const ::ProjectDataManagement::EventFilterHgrMineSearch &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool eventFilterHgrMineSearchs(const std::function<bool(const ::ProjectDataManagement::EventFilterHgrMineSearch &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::EventFilterHgrMineSearch eventFilterHgrMineSearch(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void eventFilterHgrMineSearchChanged(const ::ProjectDataManagement::EventFilterHgrMineSearch &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'FirePurpose'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::FirePurpose> firePurposes() = 0;
|
|
virtual bool firePurposes(const std::function<void(const ::ProjectDataManagement::FirePurpose &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool firePurposes(const std::function<bool(const ::ProjectDataManagement::FirePurpose &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::FirePurpose firePurpose(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void firePurposeChanged(const ::ProjectDataManagement::FirePurpose &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'GearType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::GearType> gearTypes() = 0;
|
|
virtual bool gearTypes(const std::function<void(const ::ProjectDataManagement::GearType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool gearTypes(const std::function<bool(const ::ProjectDataManagement::GearType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::GearType gearType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void gearTypeChanged(const ::ProjectDataManagement::GearType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'GearTypeChargeType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::GearTypeChargeType> gearTypeChargeTypes() = 0;
|
|
virtual bool gearTypeChargeTypes(const std::function<void(const ::ProjectDataManagement::GearTypeChargeType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool gearTypeChargeTypes(const std::function<bool(const ::ProjectDataManagement::GearTypeChargeType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::GearTypeChargeType gearTypeChargeType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void gearTypeChargeTypeChanged(const ::ProjectDataManagement::GearTypeChargeType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'IgniterFunction'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::IgniterFunction> igniterFunctions() = 0;
|
|
virtual bool igniterFunctions(const std::function<void(const ::ProjectDataManagement::IgniterFunction &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool igniterFunctions(const std::function<bool(const ::ProjectDataManagement::IgniterFunction &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::IgniterFunction igniterFunction(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void igniterFunctionChanged(const ::ProjectDataManagement::IgniterFunction &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'IgniterType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::IgniterType> igniterTypes() = 0;
|
|
virtual bool igniterTypes(const std::function<void(const ::ProjectDataManagement::IgniterType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool igniterTypes(const std::function<bool(const ::ProjectDataManagement::IgniterType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::IgniterType igniterType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void igniterTypeChanged(const ::ProjectDataManagement::IgniterType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'LanguageHmi'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::LanguageHmi> languageHmis() = 0;
|
|
virtual bool languageHmis(const std::function<void(const ::ProjectDataManagement::LanguageHmi &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool languageHmis(const std::function<bool(const ::ProjectDataManagement::LanguageHmi &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::LanguageHmi languageHmi(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void languageHmiChanged(const ::ProjectDataManagement::LanguageHmi &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'LanguageXdu'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::LanguageXdu> languageXdus() = 0;
|
|
virtual bool languageXdus(const std::function<void(const ::ProjectDataManagement::LanguageXdu &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool languageXdus(const std::function<bool(const ::ProjectDataManagement::LanguageXdu &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::LanguageXdu languageXdu(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void languageXduChanged(const ::ProjectDataManagement::LanguageXdu &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'LoadType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::LoadType> loadTypes() = 0;
|
|
virtual bool loadTypes(const std::function<void(const ::ProjectDataManagement::LoadType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool loadTypes(const std::function<bool(const ::ProjectDataManagement::LoadType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::LoadType loadType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void loadTypeChanged(const ::ProjectDataManagement::LoadType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'NuclearPreset'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::NuclearPreset> nuclearPresets() = 0;
|
|
virtual bool nuclearPresets(const std::function<void(const ::ProjectDataManagement::NuclearPreset &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool nuclearPresets(const std::function<bool(const ::ProjectDataManagement::NuclearPreset &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::NuclearPreset nuclearPreset(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void nuclearPresetChanged(const ::ProjectDataManagement::NuclearPreset &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'RadioGroup'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::RadioGroup> radioGroups() = 0;
|
|
virtual bool radioGroups(const std::function<void(const ::ProjectDataManagement::RadioGroup &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool radioGroups(const std::function<bool(const ::ProjectDataManagement::RadioGroup &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::RadioGroup radioGroup(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void radioGroupChanged(const ::ProjectDataManagement::RadioGroup &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationInjury'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationInjury> sanitationInjurys() = 0;
|
|
virtual bool sanitationInjurys(const std::function<void(const ::ProjectDataManagement::SanitationInjury &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationInjurys(const std::function<bool(const ::ProjectDataManagement::SanitationInjury &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationInjury sanitationInjury(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationInjuryChanged(const ::ProjectDataManagement::SanitationInjury &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationInjuryKind'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationInjuryKind> sanitationInjuryKinds() = 0;
|
|
virtual bool sanitationInjuryKinds(const std::function<void(const ::ProjectDataManagement::SanitationInjuryKind &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationInjuryKinds(const std::function<bool(const ::ProjectDataManagement::SanitationInjuryKind &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationInjuryKind sanitationInjuryKind(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationInjuryKindChanged(const ::ProjectDataManagement::SanitationInjuryKind &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationInjuryPlace1'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationInjuryPlace1> sanitationInjuryPlace1s() = 0;
|
|
virtual bool sanitationInjuryPlace1s(const std::function<void(const ::ProjectDataManagement::SanitationInjuryPlace1 &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationInjuryPlace1s(const std::function<bool(const ::ProjectDataManagement::SanitationInjuryPlace1 &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationInjuryPlace1 sanitationInjuryPlace1(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationInjuryPlace1Changed(const ::ProjectDataManagement::SanitationInjuryPlace1 &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationInjuryPlace2'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationInjuryPlace2> sanitationInjuryPlace2s() = 0;
|
|
virtual bool sanitationInjuryPlace2s(const std::function<void(const ::ProjectDataManagement::SanitationInjuryPlace2 &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationInjuryPlace2s(const std::function<bool(const ::ProjectDataManagement::SanitationInjuryPlace2 &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationInjuryPlace2 sanitationInjuryPlace2(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationInjuryPlace2Changed(const ::ProjectDataManagement::SanitationInjuryPlace2 &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationMaterial'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationMaterial> sanitationMaterials() = 0;
|
|
virtual bool sanitationMaterials(const std::function<void(const ::ProjectDataManagement::SanitationMaterial &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationMaterials(const std::function<bool(const ::ProjectDataManagement::SanitationMaterial &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationMaterial sanitationMaterial(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationMaterialChanged(const ::ProjectDataManagement::SanitationMaterial &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'SanitationProcedure'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::SanitationProcedure> sanitationProcedures() = 0;
|
|
virtual bool sanitationProcedures(const std::function<void(const ::ProjectDataManagement::SanitationProcedure &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool sanitationProcedures(const std::function<bool(const ::ProjectDataManagement::SanitationProcedure &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::SanitationProcedure sanitationProcedure(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void sanitationProcedureChanged(const ::ProjectDataManagement::SanitationProcedure &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'TargetSubType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::TargetSubType> targetSubTypes() = 0;
|
|
virtual bool targetSubTypes(const std::function<void(const ::ProjectDataManagement::TargetSubType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool targetSubTypes(const std::function<bool(const ::ProjectDataManagement::TargetSubType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::TargetSubType targetSubType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void targetSubTypeChanged(const ::ProjectDataManagement::TargetSubType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'TargetType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::TargetType> targetTypes() = 0;
|
|
virtual bool targetTypes(const std::function<void(const ::ProjectDataManagement::TargetType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool targetTypes(const std::function<bool(const ::ProjectDataManagement::TargetType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::TargetType targetType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void targetTypeChanged(const ::ProjectDataManagement::TargetType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'TargetTypeTargetSubType'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::TargetTypeTargetSubType> targetTypeTargetSubTypes() = 0;
|
|
virtual bool targetTypeTargetSubTypes(const std::function<void(const ::ProjectDataManagement::TargetTypeTargetSubType &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool targetTypeTargetSubTypes(const std::function<bool(const ::ProjectDataManagement::TargetTypeTargetSubType &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::TargetTypeTargetSubType targetTypeTargetSubType(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void targetTypeTargetSubTypeChanged(const ::ProjectDataManagement::TargetTypeTargetSubType &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'TranslationBlob'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::TranslationBlob> translationBlobs() = 0;
|
|
virtual bool translationBlobs(const std::function<void(const ::ProjectDataManagement::TranslationBlob &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool translationBlobs(const std::function<bool(const ::ProjectDataManagement::TranslationBlob &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::TranslationBlob translationBlob(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void translationBlobChanged(const ::ProjectDataManagement::TranslationBlob &data, DataModification modType);
|
|
|
|
|
|
public:
|
|
//
|
|
// Data Topic 'VulnerabilityKind'
|
|
//
|
|
virtual QMap<qint32, ::ProjectDataManagement::VulnerabilityKind> vulnerabilityKinds() = 0;
|
|
virtual bool vulnerabilityKinds(const std::function<void(const ::ProjectDataManagement::VulnerabilityKind &data)> &cb) = 0;
|
|
// when the cb returns true, the loop is stopped (useful when searching for a specific topic)
|
|
virtual bool vulnerabilityKinds(const std::function<bool(const ::ProjectDataManagement::VulnerabilityKind &data)> &cb) = 0;
|
|
virtual ::ProjectDataManagement::VulnerabilityKind vulnerabilityKind(qint32 id) = 0;
|
|
Q_SIGNALS:
|
|
void vulnerabilityKindChanged(const ::ProjectDataManagement::VulnerabilityKind &data, DataModification modType);
|
|
|
|
|
|
|
|
};
|
|
|
|
} // namespace Interface
|
|
} // namespace ProjectDataManagement
|
|
|