RustDDS-Gen/test.idl

// 综合测试IDL文件
// 包含各种复杂情况：常量、枚举、结构体、接口、嵌套模块、参数方向、序列等

module ComprehensiveTest {
    // 联合类型（移到前面）
    union MessagePayload switch(long) {
        case 0: string textMessage;
        case 1: ByteBuffer binaryMessage;
        case 2: long numericMessage;
        default: octet rawData;
    };
    
    // 使用联合类型的结构体（移到前面）
    struct Message {
        LimitedString sender;
        LimitedString recipient;
        long timestamp;
        MessagePayload payload;
    };
    
    // 基本类型定义
    typedef sequence<octet> ByteBuffer;
    typedef sequence<string> StringList;
    typedef sequence<long> IntegerArray;
    typedef string<128> LimitedString;
    
    // 基本常量定义
    const long MAX_ITEMS = 1000;
    const double PI_VALUE = 3.14159265359;
    const string VERSION_INFO = "2.0.0";
    const boolean FEATURE_ENABLED = TRUE;
    const octet MAGIC_BYTE = 0xFF;
    
    // 基本枚举
    enum StatusCode {
        OK,
        WARNING,
        ERROR,
        CRITICAL,
        UNKNOWN
    };
    
    // 事件监听接口（移到前面）
    interface EventListener {
        void onStatusChanged(in StatusCode newStatus);
        void onDataReceived(in ByteBuffer data);
        void onError(in string errorMessage, in long errorCode);
    };
    
    // 基本结构体
    struct Point2D {
        double x;
        double y;
    };
    
    struct Point3D {
        double x;
        double y;
        double z;
    };
    
    // 带有序列的结构体
    struct DataPacket {
        LimitedString name;
        ByteBuffer data;
        StatusCode status;
        long timestamp;
    };
    
    // 嵌套结构体
    struct ComplexData {
        Point3D position;
        Point3D velocity;
        ByteBuffer payload;
        StringList tags;
    };
    
    // 基本接口
    interface BasicOperations {
        // 基本方法，不同参数方向
        void noParams();
        long simpleMethod(in long value);
        boolean complexMethod(in string name, in long id, out string result);
        double calculateValue(in double x, in double y, inout double z);
        
        // 使用自定义类型
        StatusCode getStatus();
        void setPosition(in Point3D position);
        Point3D getPosition();
        
        // 使用序列
        ByteBuffer getData();
        void setData(in ByteBuffer data);
        long processData(in ByteBuffer input, out ByteBuffer output);
    };
    
    // 使用联合类型的接口（移到这里）
    interface MessageHandler {
        void sendMessage(in Message msg);
        Message receiveMessage(in long timeout);
        long getMessageCount();
    };
    
    // 嵌套模块 - 数学操作
    module Math {
        // 数学常量
        const double E_VALUE = 2.71828;
        const double GOLDEN_RATIO = 1.61803;
        
        // 向量结构体
        struct Vector {
            sequence<double> elements;
        };
        
        // 矩阵结构体
        struct Matrix {
            long rows;
            long cols;
            sequence<sequence<double>> elements;
        };
        
        // 数学操作接口
        interface VectorOperations {
            double dotProduct(in Vector a, in Vector b);
            Vector crossProduct(in Vector a, in Vector b);
            double magnitude(in Vector v);
            Vector normalize(in Vector v);
        };
        
        interface MatrixOperations {
            Matrix multiply(in Matrix a, in Matrix b);
            Matrix transpose(in Matrix m);
            Matrix inverse(in Matrix m);
            double determinant(in Matrix m);
        };
        
        // 更深层次的嵌套模块
        module Statistics {
            struct Dataset {
                sequence<double> values;
            };
            
            interface StatOperations {
                double mean(in Dataset data);
                double median(in Dataset data);
                double variance(in Dataset data);
                double standardDeviation(in Dataset data);
            };
        };
    };
    
    // 嵌套模块 - 网络操作
    module Network {
        // 网络相关结构体
        struct Address {
            string host;
            unsigned short port;
        };
        
        struct Packet {
            octet packet_type;
            unsigned long size;
            ByteBuffer payload;
        };
        
        // 网络接口
        interface Connection {
            boolean connect(in Address addr);
            void disconnect();
            StatusCode getConnectionStatus();
        };
        
        interface DataTransfer {
            long send(in Packet packet);
            Packet receive(in long timeout);
            long available();
        };
        
        // 单继承接口
        interface SecureConnection : Connection {
            boolean authenticate(in string username, in string password);
            boolean isSecure();
        };
        
        // 带有继承的接口
        interface AdvancedDataTransfer : DataTransfer {
            long sendBatch(in sequence<Packet> packets);
            sequence<Packet> receiveBatch(in long count, in long timeout);
        };
    };
    
    // 复杂接口，使用各种自定义类型
    interface DataProcessor {
        // 处理不同类型的数据
        StatusCode processTextData(in string data, out string result);
        StatusCode processBinaryData(in ByteBuffer data, out ByteBuffer result);
        StatusCode processStructuredData(in ComplexData data, out ComplexData result);
        
        // 批量处理
        long batchProcess(in sequence<ComplexData> inputs, out sequence<ComplexData> results);
        
        // 统计信息
        void getProcessingStats(out long processedCount, out long errorCount, out double averageTime);
    };
    
    // 带有回调的接口
    interface AsyncProcessor {
        long startProcessing(in ComplexData data);
        void cancelProcessing(in long processId);
        boolean registerCallback(in EventListener listener);
        boolean unregisterCallback(in EventListener listener);
    };
};