Removes migration stub headers superseded by codegen outputs

Drops 184 stub headers and obsolete stub tests now generated in the build tree.
This commit is contained in:
berrux-dev committed 2026-09-21 02:38:33 +02:00
1 parent 4e29022c06
commit 220ca64679
184 files changed
-8951

No files matched your search

@@ -1,233 +0,0 @@
/**
* @file ism.hpp
* @brief DDS-Stub-Header für InfrastructureManagement
*
* Dieser Header ersetzt die von RTI DDS Generator erzeugten Typen.
*/
#ifndef ISM_HPP
#define ISM_HPP
#include <cstdint>
#include <string>
#include <vector>
#include <QtCore/QString>
#include <QtCore/QByteArray>
#include <QtGui/QImage>
#include <QtCore/QMap>
#include "InfrastructureManagement/ism_enums.hpp"
#include "ParticipantManagement/ppm.hpp"
#include "ParticipantManagement/ppm_enums.hpp"
namespace InfrastructureManagement {
// Using-declaration for DataModification in InfrastructureManagement namespace
using ParticipantManagement::DataModification;
// Core namespace mit GeoPosition und RelativePosition
namespace Core {
class GeoPosition {
public:
GeoPosition() : latitude_(0.0), longitude_(0.0), altitude_(0.0) {}
double latitude() const { return latitude_; }
double longitude() const { return longitude_; }
double altitude() const { return altitude_; }
void latitude(double v) { latitude_ = v; }
void longitude(double v) { longitude_ = v; }
void altitude(double v) { altitude_ = v; }
private:
double latitude_;
double longitude_;
double altitude_;
};
class RelativePosition {
public:
RelativePosition() : x_(0.0), y_(0.0), z_(0.0) {}
double x() const { return x_; }
double y() const { return y_; }
double z() const { return z_; }
void x(double v) { x_ = v; }
void y(double v) { y_ = v; }
void z(double v) { z_ = v; }
private:
double x_;
double y_;
double z_;
};
} // namespace Core
// StructureElement Stub-Klasse
class StructureElement {
public:
StructureElement() : id_(0), mainStructureElementId_(0), mountingPointTypeId_(MountingPointType::Undefined), mountingPointId_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
int32_t mainStructureElementId() const { return mainStructureElementId_; }
void mainStructureElementId(int32_t v) { mainStructureElementId_ = v; }
MountingPointType mountingPointTypeId() const { return mountingPointTypeId_; }
void mountingPointTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
// Für Kompatibilität: structureElementTypeId() als Alias
MountingPointType structureElementTypeId() const { return mountingPointTypeId_; }
void structureElementTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
// mountingPointId() für Sub-ID
int32_t mountingPointId() const { return mountingPointId_; }
void mountingPointId(int32_t v) { mountingPointId_ = v; }
Core::GeoPosition geoPosition() const { return geoPosition_; }
void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
Core::RelativePosition relPosition() const { return relPosition_; }
void relPosition(const Core::RelativePosition& v) { relPosition_ = v; }
std::string properties() const { return properties_; }
void properties(const std::string& v) { properties_ = v; }
std::string name() const { return name_; }
void name(const std::string& v) { name_ = v; }
std::string displayName() const { return displayName_; }
void displayName(const std::string& v) { displayName_ = v; }
// path() returns vector of IDs im Hierarchie-Pfad
const std::vector<int32_t>& path() const { return path_; }
void path(const std::vector<int32_t>& v) { path_ = v; }
private:
int32_t id_;
int32_t mainStructureElementId_;
MountingPointType mountingPointTypeId_;
int32_t mountingPointId_;
Core::GeoPosition geoPosition_;
Core::RelativePosition relPosition_;
std::string properties_;
std::string name_;
std::string displayName_;
std::vector<int32_t> path_;
};
// MainStructureElement - Stub für DDS-generierten Typ
class MainStructureElement {
public:
MainStructureElement() : id_(0), groupId_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
int32_t groupId() const { return groupId_; }
void groupId(int32_t v) { groupId_ = v; }
std::string name() const { return name_; }
void name(const std::string& v) { name_ = v; }
std::string displayName() const { return displayName_; }
void displayName(const std::string& v) { displayName_ = v; }
Core::GeoPosition geoPosition() const { return geoPosition_; }
void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
// For compatibility: elements() returns empty vector by default
const std::vector<StructureElement>& elements() const { return elements_; }
void elements(const std::vector<StructureElement>& v) { elements_ = v; }
private:
int32_t id_;
int32_t groupId_;
std::string name_;
std::string displayName_;
Core::GeoPosition geoPosition_;
std::vector<StructureElement> elements_;
};
// MountingPointAsset - Stub für DDS-generierten Typ
class MountingPointAsset {
public:
MountingPointAsset() : id_(0), mountingPointId_(0), assetId_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
int32_t mountingPointId() const { return mountingPointId_; }
void mountingPointId(int32_t v) { mountingPointId_ = v; }
int32_t assetId() const { return assetId_; }
void assetId(int32_t v) { assetId_ = v; }
std::string name() const { return name_; }
void name(const std::string& v) { name_ = v; }
// For compatibility: structureElementId() alias for mountingPointId()
int32_t structureElementId() const { return mountingPointId_; }
void structureElementId(int32_t v) { mountingPointId_ = v; }
private:
int32_t id_;
int32_t mountingPointId_;
int32_t assetId_;
std::string name_;
};
// Forward declaration - full definition in ism_mounting_point.h
class MountingPoint;
// FootprintElement - für Footprint-Daten
class FootprintElement {
public:
FootprintElement() : isGroundLevel_(false) {}
bool isGroundLevel() const { return isGroundLevel_; }
void isGroundLevel(bool v) { isGroundLevel_ = v; }
Core::RelativePosition relPosition() const { return relPosition_; }
void relPosition(const Core::RelativePosition& v) { relPosition_ = v; }
private:
bool isGroundLevel_;
Core::RelativePosition relPosition_;
};
// MainFootprint - Footprint-Daten für MainStructureElement
class MainFootprint {
public:
MainFootprint() : id_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
const std::vector<FootprintElement>& elements() const { return elements_; }
void elements(const std::vector<FootprintElement>& v) { elements_ = v; }
private:
int32_t id_;
std::vector<FootprintElement> elements_;
};
// InstrumentationAsset - Stub für DDS-generierten Typ
class InstrumentationAsset {
public:
InstrumentationAsset() : id_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
std::string name() const { return name_; }
void name(const std::string& v) { name_ = v; }
private:
int32_t id_;
std::string name_;
};
// StructureElementType Enum (Alias für MountingPointType für Kompatibilität)
using StructureElementType = MountingPointType;
} // namespace InfrastructureManagement
#endif // ISM_HPP
@@ -1,46 +0,0 @@
/**
* @RDE_HEADER@
* Stub header for CODEGEN_DATABASE generated code (BUILD_RTI=OFF)
* This file is generated by CODEGEN_DATABASE macro when BUILD_RTI=ON
* For BUILD_RTI=OFF builds, this stub provides the minimal interface
*/
#pragma once
#include <QObject>
#include <InfrastructureManagement/ism_enums.hpp>
namespace Database
{
// Stub struct for IsmMountingPointPlan
struct IsmMountingPointPlan
{
int scheduleId = 0;
int mountingPointId = 0;
MountingPointState mountingPointState = MountingPointState::Unknown;
};
} // namespace Database
namespace InfrastructureManagement
{
/**
* @brief Base class for database interface implementation
*
* This class is normally generated by CODEGEN_DATABASE macro.
* This stub provides minimal interface for BUILD_RTI=OFF builds.
*/
class DatabaseInterfaceImpl : public QObject
{
Q_OBJECT
public:
explicit DatabaseInterfaceImpl(QObject *parent = nullptr) : QObject(parent) {}
virtual ~DatabaseInterfaceImpl() = default;
// Virtual methods that can be overridden by custom implementations
virtual int copySchedule(int scheduleId) = 0;
virtual bool updateMountingPointPlan(int scheduleId, int mountingPointId, MountingPointState mountingPointState) = 0;
virtual bool deleteMountingPointPlan(int scheduleId, int mountingPointId) = 0;
virtual bool insertMountingPointPlans(const std::vector<Database::IsmMountingPointPlan> &mpps) = 0;
};
} // namespace InfrastructureManagement
@@ -1,129 +0,0 @@
#pragma once
// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
// Für die Migration erstellen wir minimale Implementierungen
#include <QtCore/QObject>
#include <QtCore/QMap>
#include <QtCore/QHash>
#include <functional>
#include "ism.hpp"
#include "ism_mounting_point.h"
namespace InfrastructureManagement
{
namespace Interface
{
// Forward declarations
class Dtc;
class Ftc;
// DataModification Enum
enum class DataModification
{
eAdded,
eModified,
eRemoved
};
// MountingPointPlan - Planungsdaten für MountingPoints (MUST come before MainSchedule)
class MountingPointPlan {
public:
MountingPointPlan() : structureElementId_(0) {}
int32_t structureElementId() const { return structureElementId_; }
void structureElementId(int32_t v) { structureElementId_ = v; }
MountingPointState mountingPointState() const { return mountingPointState_; }
void mountingPointState(const MountingPointState& v) { mountingPointState_ = v; }
private:
int32_t structureElementId_;
MountingPointState mountingPointState_;
};
// MainSchedule - benötigt für Schedule-Daten
class MainSchedule {
public:
MainSchedule() : id_(0) {}
int32_t id() const { return id_; }
void id(int32_t v) { id_ = v; }
// elements() returns vector of MountingPointPlan
const std::vector<MountingPointPlan>& elements() const { return elements_; }
void elements(const std::vector<MountingPointPlan>& v) { elements_ = v; }
private:
int32_t id_;
std::vector<MountingPointPlan> elements_;
};
// InstrumentationAssetState Enum
enum class InstrumentationAssetState
{
Undefined = 0,
Ok = 1,
Defect = 2
};
// InstrumentationAsset - Asset-Daten
class InstrumentationAsset {
public:
InstrumentationAsset() : assetId_(0), assetStateId_(InstrumentationAssetState::Undefined) {}
int32_t assetId() const { return assetId_; }
void assetId(int32_t v) { assetId_ = v; }
InstrumentationAssetState assetStateId() const { return assetStateId_; }
void assetStateId(InstrumentationAssetState v) { assetStateId_ = v; }
private:
int32_t assetId_;
InstrumentationAssetState assetStateId_;
};
// Dtc - Data Transfer Component (Hauptklasse für ISM-Daten)
class Dtc : public QObject
{
Q_OBJECT
public:
Dtc(QObject* parent = nullptr) : QObject(parent) {}
~Dtc() override = default;
// MainStructureElement Zugriff
virtual const QMap<qint32, MainStructureElement>& mainStructureElements() const = 0;
virtual MainStructureElement mainStructureElement(int32_t id) const = 0;
virtual bool getStructureElementById(int32_t id, StructureElement& out) const = 0;
virtual void waitForHistoricalDataMainStructureElement(int timeoutMs) = 0;
// MainSchedule Zugriff
virtual const QMap<qint32, MainSchedule>& mainSchedules() const = 0;
virtual MainSchedule mainSchedule(int32_t id) const = 0;
virtual void waitForHistoricalDataMainSchedule(int timeoutMs) = 0;
// MountingPointAsset Zugriff
virtual void mountingPointAssets(const std::function<void(const MountingPointAsset&)>& cb) = 0;
virtual void waitForHistoricalDataMountingPointAsset(int timeoutMs) = 0;
virtual InstrumentationAsset instrumentationAsset(int32_t assetId) const = 0;
// MainFootprint Zugriff (wird in ism_dtc_impl_custom_p.h verwendet)
virtual MainFootprint mainFootprint(int mseId) const = 0;
signals:
void mainStructureElementChanged(const MainStructureElement& data, DataModification modType);
void mainScheduleChanged(const MainSchedule& data, DataModification modType);
void mountingPointAssetChanged(const MountingPointAsset& data, DataModification modType);
};
// Ftc - Forward Declaration (wird später implementiert)
class Ftc : public QObject
{
Q_OBJECT
public:
Ftc(QObject* parent = nullptr) : QObject(parent) {}
~Ftc() override = default;
};
} // namespace Interface
} // namespace InfrastructureManagement
@@ -1,11 +0,0 @@
#pragma once
// STUB-HEADER: Diese Datei wird normalerweise von ddsftc generiert
// Für die Migration erstellen wir minimale Forward-Declarations
namespace InfrastructureManagement
{
namespace Interface
{
class Ftc;
}
}