qt-migration-legatus/qt6-after/qt6-migrated-legatus/.forward-declarations/include/InfrastructureManagement/ism.hpp

/**
 * @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