/**
  * @RDE_HEADER@
  * Template for 'real' structures including insert/update/delete functions for db
  * $Id$
  * $HeadURL$
  * $Author$
  */


// filename: pdm_db.h
#pragma once

#include <QObject>
#include <functional>
#include <QtSql/QSqlError>

#include <ProjectDataManagement/pdm_export.h>
#include <ProjectDataManagement/pdm_db_structs.h>
#include <ProjectDataManagement/pdm_enums.hpp>


#include </workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/build4/Lts/DDS/Core/core.hpp>


namespace NGL
{
class INGLLogger;
}
class QSqlDatabase;

namespace ProjectDataManagement
{

class PDM_COMMON_EXPORT DatabaseInterface : public QObject
{
  Q_OBJECT
public:
  virtual ~DatabaseInterface() = default;

  /**
   * Create a new instance for ProjectDataManagement::DatabaseInterface.
   * @param exerciseId if <= 0 -> global service
   */
  static std::shared_ptr<DatabaseInterface> create(int exerciseId);

  /**
   * @brief initialize the database interface (must be called after the db connection was opened!)
   * @return true on succcess
   */
  virtual bool init(const QSqlDatabase &dbConnection) = 0;
  virtual bool init(const QString &dbUser,
                    const QString &dbPasswd,
                    const QString &dbDriver,
                    const QString &dbHost,
                    const QString &dbName) = 0;

  /**
   * @brief return the current schema name depending if exercise id > 0 or not
   */
  virtual QString schemaName() const = 0;

  /**
    * @brief return the current database user dependening if exercise id > 0 or not
    */
  virtual QString dbUser() const = 0;

  /**
    * @brief return the database connection used in this DatabaseInterface
    */
  virtual const QSqlDatabase &database() const = 0;

  /**
    * emit an error message (ERROR_LOG) when a statement fails to execute (default: on)
    */
  virtual void setEmitMessageOnError(bool bEmit) = 0;

  virtual QSqlError getLastError() const = 0;

  
  //
  // Database::PdmAvmFrequencyPlanTransmissionReason
  //
public:
  virtual bool insert(Database::PdmAvmFrequencyPlanTransmissionReason &data) = 0;
  virtual bool upsert(Database::PdmAvmFrequencyPlanTransmissionReason &data) = 0;
  virtual bool update(const Database::PdmAvmFrequencyPlanTransmissionReason &data) = 0;

  virtual bool insert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) = 0;

  virtual bool select(QVector<Database::PdmAvmFrequencyPlanTransmissionReason> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmAvmFrequencyPlanTransmissionReason &data)> &cb) = 0;
  virtual bool selectPdmAvmFrequencyPlanTransmissionReason(qint32 id, Database::PdmAvmFrequencyPlanTransmissionReason &data) = 0;
  virtual bool removePdmAvmFrequencyPlanTransmissionReason(qint32 id) = 0;
  virtual bool fixUpSequencePdmAvmFrequencyPlanTransmissionReason() = 0;
  virtual bool truncatePdmAvmFrequencyPlanTransmissionReason() = 0;

  //
  // Database::PdmAvmFrequencyPlanTransmissionReason end
  //
  
  //
  // Database::PdmBiteComponentText
  //
public:
  virtual bool insert(Database::PdmBiteComponentText &data) = 0;
  virtual bool upsert(Database::PdmBiteComponentText &data) = 0;
  virtual bool update(const Database::PdmBiteComponentText &data) = 0;

  virtual bool insert(std::vector<Database::PdmBiteComponentText> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmBiteComponentText> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmBiteComponentText> &cont) = 0;

  virtual bool select(QVector<Database::PdmBiteComponentText> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmBiteComponentText &data)> &cb) = 0;
  virtual bool selectPdmBiteComponentText(qint32 id, Database::PdmBiteComponentText &data) = 0;
  virtual bool removePdmBiteComponentText(qint32 id) = 0;
  virtual bool fixUpSequencePdmBiteComponentText() = 0;
  virtual bool truncatePdmBiteComponentText() = 0;

  //
  // Database::PdmBiteComponentText end
  //
  
  //
  // Database::PdmBuildingChargeEffect
  //
public:
  virtual bool insert(Database::PdmBuildingChargeEffect &data) = 0;
  virtual bool upsert(Database::PdmBuildingChargeEffect &data) = 0;
  virtual bool update(const Database::PdmBuildingChargeEffect &data) = 0;

  virtual bool insert(std::vector<Database::PdmBuildingChargeEffect> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmBuildingChargeEffect> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmBuildingChargeEffect> &cont) = 0;

  virtual bool select(QVector<Database::PdmBuildingChargeEffect> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmBuildingChargeEffect &data)> &cb) = 0;
  virtual bool selectPdmBuildingChargeEffect(qint32 id, Database::PdmBuildingChargeEffect &data) = 0;
  virtual bool removePdmBuildingChargeEffect(qint32 id) = 0;
  virtual bool fixUpSequencePdmBuildingChargeEffect() = 0;
  virtual bool truncatePdmBuildingChargeEffect() = 0;

  //
  // Database::PdmBuildingChargeEffect end
  //
  
  //
  // Database::PdmCanComponentString
  //
public:
  virtual bool insert(Database::PdmCanComponentString &data) = 0;
  virtual bool upsert(Database::PdmCanComponentString &data) = 0;
  virtual bool update(const Database::PdmCanComponentString &data) = 0;

  virtual bool insert(std::vector<Database::PdmCanComponentString> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmCanComponentString> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmCanComponentString> &cont) = 0;

  virtual bool select(QVector<Database::PdmCanComponentString> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmCanComponentString &data)> &cb) = 0;
  virtual bool selectPdmCanComponentString(qint32 id, Database::PdmCanComponentString &data) = 0;
  virtual bool removePdmCanComponentString(qint32 id) = 0;
  virtual bool fixUpSequencePdmCanComponentString() = 0;
  virtual bool truncatePdmCanComponentString() = 0;

  //
  // Database::PdmCanComponentString end
  //
  
  //
  // Database::PdmChargeType
  //
public:
  virtual bool insert(Database::PdmChargeType &data) = 0;
  virtual bool upsert(Database::PdmChargeType &data) = 0;
  virtual bool update(const Database::PdmChargeType &data) = 0;

  virtual bool insert(std::vector<Database::PdmChargeType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmChargeType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmChargeType> &cont) = 0;

  virtual bool select(QVector<Database::PdmChargeType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmChargeType &data)> &cb) = 0;
  virtual bool selectPdmChargeType(qint32 id, Database::PdmChargeType &data) = 0;
  virtual bool removePdmChargeType(qint32 id) = 0;
  virtual bool fixUpSequencePdmChargeType() = 0;
  virtual bool truncatePdmChargeType() = 0;

  //
  // Database::PdmChargeType end
  //
  
  //
  // Database::PdmChargeTypeIgniterTypeIgniterFunction
  //
public:
  virtual bool insert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data) = 0;
  virtual bool upsert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data) = 0;
  virtual bool update(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data) = 0;

  virtual bool insert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) = 0;

  virtual bool select(QVector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)> &cb) = 0;
  virtual bool selectPdmChargeTypeIgniterTypeIgniterFunction(qint32 id, Database::PdmChargeTypeIgniterTypeIgniterFunction &data) = 0;
  virtual bool removePdmChargeTypeIgniterTypeIgniterFunction(qint32 id) = 0;
  virtual bool fixUpSequencePdmChargeTypeIgniterTypeIgniterFunction() = 0;
  virtual bool truncatePdmChargeTypeIgniterTypeIgniterFunction() = 0;

  //
  // Database::PdmChargeTypeIgniterTypeIgniterFunction end
  //
  
  //
  // Database::PdmChargeTypeLoadType
  //
public:
  virtual bool insert(Database::PdmChargeTypeLoadType &data) = 0;
  virtual bool upsert(Database::PdmChargeTypeLoadType &data) = 0;
  virtual bool update(const Database::PdmChargeTypeLoadType &data) = 0;

  virtual bool insert(std::vector<Database::PdmChargeTypeLoadType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmChargeTypeLoadType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmChargeTypeLoadType> &cont) = 0;

  virtual bool select(QVector<Database::PdmChargeTypeLoadType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmChargeTypeLoadType &data)> &cb) = 0;
  virtual bool selectPdmChargeTypeLoadType(qint32 id, Database::PdmChargeTypeLoadType &data) = 0;
  virtual bool removePdmChargeTypeLoadType(qint32 id) = 0;
  virtual bool fixUpSequencePdmChargeTypeLoadType() = 0;
  virtual bool truncatePdmChargeTypeLoadType() = 0;

  //
  // Database::PdmChargeTypeLoadType end
  //
  
  //
  // Database::PdmEquipmentSystemEventFilter
  //
public:
  virtual bool insert(Database::PdmEquipmentSystemEventFilter &data) = 0;
  virtual bool upsert(Database::PdmEquipmentSystemEventFilter &data) = 0;
  virtual bool update(const Database::PdmEquipmentSystemEventFilter &data) = 0;

  virtual bool insert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmEquipmentSystemEventFilter> &cont) = 0;

  virtual bool select(QVector<Database::PdmEquipmentSystemEventFilter> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmEquipmentSystemEventFilter &data)> &cb) = 0;
  virtual bool selectPdmEquipmentSystemEventFilter(qint32 id, Database::PdmEquipmentSystemEventFilter &data) = 0;
  virtual bool removePdmEquipmentSystemEventFilter(qint32 id) = 0;
  virtual bool fixUpSequencePdmEquipmentSystemEventFilter() = 0;
  virtual bool truncatePdmEquipmentSystemEventFilter() = 0;

  //
  // Database::PdmEquipmentSystemEventFilter end
  //
  
  //
  // Database::PdmEventFilterHgrMineSearch
  //
public:
  virtual bool insert(Database::PdmEventFilterHgrMineSearch &data) = 0;
  virtual bool upsert(Database::PdmEventFilterHgrMineSearch &data) = 0;
  virtual bool update(const Database::PdmEventFilterHgrMineSearch &data) = 0;

  virtual bool insert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmEventFilterHgrMineSearch> &cont) = 0;

  virtual bool select(QVector<Database::PdmEventFilterHgrMineSearch> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmEventFilterHgrMineSearch &data)> &cb) = 0;
  virtual bool selectPdmEventFilterHgrMineSearch(qint32 id, Database::PdmEventFilterHgrMineSearch &data) = 0;
  virtual bool removePdmEventFilterHgrMineSearch(qint32 id) = 0;
  virtual bool fixUpSequencePdmEventFilterHgrMineSearch() = 0;
  virtual bool truncatePdmEventFilterHgrMineSearch() = 0;

  //
  // Database::PdmEventFilterHgrMineSearch end
  //
  
  //
  // Database::PdmFirePurpose
  //
public:
  virtual bool insert(Database::PdmFirePurpose &data) = 0;
  virtual bool upsert(Database::PdmFirePurpose &data) = 0;
  virtual bool update(const Database::PdmFirePurpose &data) = 0;

  virtual bool insert(std::vector<Database::PdmFirePurpose> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmFirePurpose> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmFirePurpose> &cont) = 0;

  virtual bool select(QVector<Database::PdmFirePurpose> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmFirePurpose &data)> &cb) = 0;
  virtual bool selectPdmFirePurpose(qint32 id, Database::PdmFirePurpose &data) = 0;
  virtual bool removePdmFirePurpose(qint32 id) = 0;
  virtual bool fixUpSequencePdmFirePurpose() = 0;
  virtual bool truncatePdmFirePurpose() = 0;

  //
  // Database::PdmFirePurpose end
  //
  
  //
  // Database::PdmGearType
  //
public:
  virtual bool insert(Database::PdmGearType &data) = 0;
  virtual bool upsert(Database::PdmGearType &data) = 0;
  virtual bool update(const Database::PdmGearType &data) = 0;

  virtual bool insert(std::vector<Database::PdmGearType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmGearType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmGearType> &cont) = 0;

  virtual bool select(QVector<Database::PdmGearType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmGearType &data)> &cb) = 0;
  virtual bool selectPdmGearType(qint32 id, Database::PdmGearType &data) = 0;
  virtual bool removePdmGearType(qint32 id) = 0;
  virtual bool fixUpSequencePdmGearType() = 0;
  virtual bool truncatePdmGearType() = 0;

  //
  // Database::PdmGearType end
  //
  
  //
  // Database::PdmGearTypeChargeType
  //
public:
  virtual bool insert(Database::PdmGearTypeChargeType &data) = 0;
  virtual bool upsert(Database::PdmGearTypeChargeType &data) = 0;
  virtual bool update(const Database::PdmGearTypeChargeType &data) = 0;

  virtual bool insert(std::vector<Database::PdmGearTypeChargeType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmGearTypeChargeType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmGearTypeChargeType> &cont) = 0;

  virtual bool select(QVector<Database::PdmGearTypeChargeType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmGearTypeChargeType &data)> &cb) = 0;
  virtual bool selectPdmGearTypeChargeType(qint32 id, Database::PdmGearTypeChargeType &data) = 0;
  virtual bool removePdmGearTypeChargeType(qint32 id) = 0;
  virtual bool fixUpSequencePdmGearTypeChargeType() = 0;
  virtual bool truncatePdmGearTypeChargeType() = 0;

  //
  // Database::PdmGearTypeChargeType end
  //
  
  //
  // Database::PdmIgniterFunction
  //
public:
  virtual bool insert(Database::PdmIgniterFunction &data) = 0;
  virtual bool upsert(Database::PdmIgniterFunction &data) = 0;
  virtual bool update(const Database::PdmIgniterFunction &data) = 0;

  virtual bool insert(std::vector<Database::PdmIgniterFunction> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmIgniterFunction> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmIgniterFunction> &cont) = 0;

  virtual bool select(QVector<Database::PdmIgniterFunction> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmIgniterFunction &data)> &cb) = 0;
  virtual bool selectPdmIgniterFunction(qint32 id, Database::PdmIgniterFunction &data) = 0;
  virtual bool removePdmIgniterFunction(qint32 id) = 0;
  virtual bool fixUpSequencePdmIgniterFunction() = 0;
  virtual bool truncatePdmIgniterFunction() = 0;

  //
  // Database::PdmIgniterFunction end
  //
  
  //
  // Database::PdmIgniterType
  //
public:
  virtual bool insert(Database::PdmIgniterType &data) = 0;
  virtual bool upsert(Database::PdmIgniterType &data) = 0;
  virtual bool update(const Database::PdmIgniterType &data) = 0;

  virtual bool insert(std::vector<Database::PdmIgniterType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmIgniterType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmIgniterType> &cont) = 0;

  virtual bool select(QVector<Database::PdmIgniterType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmIgniterType &data)> &cb) = 0;
  virtual bool selectPdmIgniterType(qint32 id, Database::PdmIgniterType &data) = 0;
  virtual bool removePdmIgniterType(qint32 id) = 0;
  virtual bool fixUpSequencePdmIgniterType() = 0;
  virtual bool truncatePdmIgniterType() = 0;

  //
  // Database::PdmIgniterType end
  //
  
  //
  // Database::PdmLanguage
  //
public:
  virtual bool insert(Database::PdmLanguage &data) = 0;
  virtual bool upsert(Database::PdmLanguage &data) = 0;
  virtual bool update(const Database::PdmLanguage &data) = 0;

  virtual bool insert(std::vector<Database::PdmLanguage> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmLanguage> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmLanguage> &cont) = 0;

  virtual bool select(QVector<Database::PdmLanguage> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmLanguage &data)> &cb) = 0;
  virtual bool selectPdmLanguage(qint32 id, Database::PdmLanguage &data) = 0;
  virtual bool removePdmLanguage(qint32 id) = 0;
  virtual bool fixUpSequencePdmLanguage() = 0;
  virtual bool truncatePdmLanguage() = 0;

  //
  // Database::PdmLanguage end
  //
  
  //
  // Database::PdmLanguageXdu
  //
public:
  virtual bool insert(Database::PdmLanguageXdu &data) = 0;
  virtual bool upsert(Database::PdmLanguageXdu &data) = 0;
  virtual bool update(const Database::PdmLanguageXdu &data) = 0;

  virtual bool insert(std::vector<Database::PdmLanguageXdu> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmLanguageXdu> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmLanguageXdu> &cont) = 0;

  virtual bool select(QVector<Database::PdmLanguageXdu> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmLanguageXdu &data)> &cb) = 0;
  virtual bool selectPdmLanguageXdu(qint32 id, Database::PdmLanguageXdu &data) = 0;
  virtual bool removePdmLanguageXdu(qint32 id) = 0;
  virtual bool fixUpSequencePdmLanguageXdu() = 0;
  virtual bool truncatePdmLanguageXdu() = 0;

  //
  // Database::PdmLanguageXdu end
  //
  
  //
  // Database::PdmLoadType
  //
public:
  virtual bool insert(Database::PdmLoadType &data) = 0;
  virtual bool upsert(Database::PdmLoadType &data) = 0;
  virtual bool update(const Database::PdmLoadType &data) = 0;

  virtual bool insert(std::vector<Database::PdmLoadType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmLoadType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmLoadType> &cont) = 0;

  virtual bool select(QVector<Database::PdmLoadType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmLoadType &data)> &cb) = 0;
  virtual bool selectPdmLoadType(qint32 id, Database::PdmLoadType &data) = 0;
  virtual bool removePdmLoadType(qint32 id) = 0;
  virtual bool fixUpSequencePdmLoadType() = 0;
  virtual bool truncatePdmLoadType() = 0;

  //
  // Database::PdmLoadType end
  //
  
  //
  // Database::PdmNuclearPreset
  //
public:
  virtual bool insert(Database::PdmNuclearPreset &data) = 0;
  virtual bool upsert(Database::PdmNuclearPreset &data) = 0;
  virtual bool update(const Database::PdmNuclearPreset &data) = 0;

  virtual bool insert(std::vector<Database::PdmNuclearPreset> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmNuclearPreset> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmNuclearPreset> &cont) = 0;

  virtual bool select(QVector<Database::PdmNuclearPreset> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmNuclearPreset &data)> &cb) = 0;
  virtual bool selectPdmNuclearPreset(qint32 id, Database::PdmNuclearPreset &data) = 0;
  virtual bool removePdmNuclearPreset(qint32 id) = 0;
  virtual bool fixUpSequencePdmNuclearPreset() = 0;
  virtual bool truncatePdmNuclearPreset() = 0;

  //
  // Database::PdmNuclearPreset end
  //
  
  //
  // Database::PdmRadioGroup
  //
public:
  virtual bool insert(Database::PdmRadioGroup &data) = 0;
  virtual bool upsert(Database::PdmRadioGroup &data) = 0;
  virtual bool update(const Database::PdmRadioGroup &data) = 0;

  virtual bool insert(std::vector<Database::PdmRadioGroup> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmRadioGroup> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmRadioGroup> &cont) = 0;

  virtual bool select(QVector<Database::PdmRadioGroup> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmRadioGroup &data)> &cb) = 0;
  virtual bool selectPdmRadioGroup(qint32 id, Database::PdmRadioGroup &data) = 0;
  virtual bool removePdmRadioGroup(qint32 id) = 0;
  virtual bool fixUpSequencePdmRadioGroup() = 0;
  virtual bool truncatePdmRadioGroup() = 0;

  //
  // Database::PdmRadioGroup end
  //
  
  //
  // Database::PdmSanitationInjury
  //
public:
  virtual bool insert(Database::PdmSanitationInjury &data) = 0;
  virtual bool upsert(Database::PdmSanitationInjury &data) = 0;
  virtual bool update(const Database::PdmSanitationInjury &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationInjury> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationInjury> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationInjury> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationInjury> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationInjury &data)> &cb) = 0;
  virtual bool selectPdmSanitationInjury(qint32 id, Database::PdmSanitationInjury &data) = 0;
  virtual bool removePdmSanitationInjury(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationInjury() = 0;
  virtual bool truncatePdmSanitationInjury() = 0;

  //
  // Database::PdmSanitationInjury end
  //
  
  //
  // Database::PdmSanitationInjuryKind
  //
public:
  virtual bool insert(Database::PdmSanitationInjuryKind &data) = 0;
  virtual bool upsert(Database::PdmSanitationInjuryKind &data) = 0;
  virtual bool update(const Database::PdmSanitationInjuryKind &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationInjuryKind> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationInjuryKind> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationInjuryKind> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationInjuryKind> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationInjuryKind &data)> &cb) = 0;
  virtual bool selectPdmSanitationInjuryKind(qint32 id, Database::PdmSanitationInjuryKind &data) = 0;
  virtual bool removePdmSanitationInjuryKind(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationInjuryKind() = 0;
  virtual bool truncatePdmSanitationInjuryKind() = 0;

  //
  // Database::PdmSanitationInjuryKind end
  //
  
  //
  // Database::PdmSanitationInjuryPlace1
  //
public:
  virtual bool insert(Database::PdmSanitationInjuryPlace1 &data) = 0;
  virtual bool upsert(Database::PdmSanitationInjuryPlace1 &data) = 0;
  virtual bool update(const Database::PdmSanitationInjuryPlace1 &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationInjuryPlace1> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationInjuryPlace1> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationInjuryPlace1> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationInjuryPlace1> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationInjuryPlace1 &data)> &cb) = 0;
  virtual bool selectPdmSanitationInjuryPlace1(qint32 id, Database::PdmSanitationInjuryPlace1 &data) = 0;
  virtual bool removePdmSanitationInjuryPlace1(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationInjuryPlace1() = 0;
  virtual bool truncatePdmSanitationInjuryPlace1() = 0;

  //
  // Database::PdmSanitationInjuryPlace1 end
  //
  
  //
  // Database::PdmSanitationInjuryPlace2
  //
public:
  virtual bool insert(Database::PdmSanitationInjuryPlace2 &data) = 0;
  virtual bool upsert(Database::PdmSanitationInjuryPlace2 &data) = 0;
  virtual bool update(const Database::PdmSanitationInjuryPlace2 &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationInjuryPlace2> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationInjuryPlace2> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationInjuryPlace2> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationInjuryPlace2> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationInjuryPlace2 &data)> &cb) = 0;
  virtual bool selectPdmSanitationInjuryPlace2(qint32 id, Database::PdmSanitationInjuryPlace2 &data) = 0;
  virtual bool removePdmSanitationInjuryPlace2(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationInjuryPlace2() = 0;
  virtual bool truncatePdmSanitationInjuryPlace2() = 0;

  //
  // Database::PdmSanitationInjuryPlace2 end
  //
  
  //
  // Database::PdmSanitationMaterial
  //
public:
  virtual bool insert(Database::PdmSanitationMaterial &data) = 0;
  virtual bool upsert(Database::PdmSanitationMaterial &data) = 0;
  virtual bool update(const Database::PdmSanitationMaterial &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationMaterial> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationMaterial> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationMaterial> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationMaterial> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationMaterial &data)> &cb) = 0;
  virtual bool selectPdmSanitationMaterial(qint32 id, Database::PdmSanitationMaterial &data) = 0;
  virtual bool removePdmSanitationMaterial(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationMaterial() = 0;
  virtual bool truncatePdmSanitationMaterial() = 0;

  //
  // Database::PdmSanitationMaterial end
  //
  
  //
  // Database::PdmSanitationProcedures
  //
public:
  virtual bool insert(Database::PdmSanitationProcedures &data) = 0;
  virtual bool upsert(Database::PdmSanitationProcedures &data) = 0;
  virtual bool update(const Database::PdmSanitationProcedures &data) = 0;

  virtual bool insert(std::vector<Database::PdmSanitationProcedures> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmSanitationProcedures> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmSanitationProcedures> &cont) = 0;

  virtual bool select(QVector<Database::PdmSanitationProcedures> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmSanitationProcedures &data)> &cb) = 0;
  virtual bool selectPdmSanitationProcedures(qint32 id, Database::PdmSanitationProcedures &data) = 0;
  virtual bool removePdmSanitationProcedures(qint32 id) = 0;
  virtual bool fixUpSequencePdmSanitationProcedures() = 0;
  virtual bool truncatePdmSanitationProcedures() = 0;

  //
  // Database::PdmSanitationProcedures end
  //
  
  //
  // Database::PdmTargetSubType
  //
public:
  virtual bool insert(Database::PdmTargetSubType &data) = 0;
  virtual bool upsert(Database::PdmTargetSubType &data) = 0;
  virtual bool update(const Database::PdmTargetSubType &data) = 0;

  virtual bool insert(std::vector<Database::PdmTargetSubType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmTargetSubType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmTargetSubType> &cont) = 0;

  virtual bool select(QVector<Database::PdmTargetSubType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmTargetSubType &data)> &cb) = 0;
  virtual bool selectPdmTargetSubType(qint32 id, Database::PdmTargetSubType &data) = 0;
  virtual bool removePdmTargetSubType(qint32 id) = 0;
  virtual bool fixUpSequencePdmTargetSubType() = 0;
  virtual bool truncatePdmTargetSubType() = 0;

  //
  // Database::PdmTargetSubType end
  //
  
  //
  // Database::PdmTargetType
  //
public:
  virtual bool insert(Database::PdmTargetType &data) = 0;
  virtual bool upsert(Database::PdmTargetType &data) = 0;
  virtual bool update(const Database::PdmTargetType &data) = 0;

  virtual bool insert(std::vector<Database::PdmTargetType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmTargetType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmTargetType> &cont) = 0;

  virtual bool select(QVector<Database::PdmTargetType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmTargetType &data)> &cb) = 0;
  virtual bool selectPdmTargetType(qint32 id, Database::PdmTargetType &data) = 0;
  virtual bool removePdmTargetType(qint32 id) = 0;
  virtual bool fixUpSequencePdmTargetType() = 0;
  virtual bool truncatePdmTargetType() = 0;

  //
  // Database::PdmTargetType end
  //
  
  //
  // Database::PdmTargetTypeTargetSubType
  //
public:
  virtual bool insert(Database::PdmTargetTypeTargetSubType &data) = 0;
  virtual bool upsert(Database::PdmTargetTypeTargetSubType &data) = 0;
  virtual bool update(const Database::PdmTargetTypeTargetSubType &data) = 0;

  virtual bool insert(std::vector<Database::PdmTargetTypeTargetSubType> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmTargetTypeTargetSubType> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmTargetTypeTargetSubType> &cont) = 0;

  virtual bool select(QVector<Database::PdmTargetTypeTargetSubType> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmTargetTypeTargetSubType &data)> &cb) = 0;
  virtual bool selectPdmTargetTypeTargetSubType(qint32 id, Database::PdmTargetTypeTargetSubType &data) = 0;
  virtual bool removePdmTargetTypeTargetSubType(qint32 id) = 0;
  virtual bool fixUpSequencePdmTargetTypeTargetSubType() = 0;
  virtual bool truncatePdmTargetTypeTargetSubType() = 0;

  //
  // Database::PdmTargetTypeTargetSubType end
  //
  
  //
  // Database::PdmTranslation
  //
public:
  virtual bool insert(Database::PdmTranslation &data) = 0;
  virtual bool upsert(Database::PdmTranslation &data) = 0;
  virtual bool update(const Database::PdmTranslation &data) = 0;

  virtual bool insert(std::vector<Database::PdmTranslation> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmTranslation> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmTranslation> &cont) = 0;

  virtual bool select(QVector<Database::PdmTranslation> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmTranslation &data)> &cb) = 0;
  virtual bool selectPdmTranslation(qint32 id, Database::PdmTranslation &data) = 0;
  virtual bool removePdmTranslation(qint32 id) = 0;
  virtual bool fixUpSequencePdmTranslation() = 0;
  virtual bool truncatePdmTranslation() = 0;

  //
  // Database::PdmTranslation end
  //
  
  //
  // Database::PdmVulnerabilityKind
  //
public:
  virtual bool insert(Database::PdmVulnerabilityKind &data) = 0;
  virtual bool upsert(Database::PdmVulnerabilityKind &data) = 0;
  virtual bool update(const Database::PdmVulnerabilityKind &data) = 0;

  virtual bool insert(std::vector<Database::PdmVulnerabilityKind> &cont) = 0;
  virtual bool upsert(std::vector<Database::PdmVulnerabilityKind> &cont) = 0;
  virtual bool update(const std::vector<Database::PdmVulnerabilityKind> &cont) = 0;

  virtual bool select(QVector<Database::PdmVulnerabilityKind> &dataVec) = 0;
  virtual bool select(const std::function<void(const Database::PdmVulnerabilityKind &data)> &cb) = 0;
  virtual bool selectPdmVulnerabilityKind(qint32 taVulnerabilityKind, Database::PdmVulnerabilityKind &data) = 0;
  virtual bool removePdmVulnerabilityKind(qint32 taVulnerabilityKind) = 0;
  virtual bool fixUpSequencePdmVulnerabilityKind() = 0;
  virtual bool truncatePdmVulnerabilityKind() = 0;

  //
  // Database::PdmVulnerabilityKind end
  //
  



public:

  // vector of database struct to/from JSON-array
  // helper for BaseDownloader
  template<typename T>
  static QJsonArray toJson(const QVector<T> &dataVec)
  {
    return Database::toJson<T>(dataVec);
  }

  template<typename T>
  static std::vector<T> fromJson(const QJsonArray &arr)
  {
    return Database::fromJson<T>(arr);
  }
};// class DatabaseInterface

} // namespace ProjectDataManagement