WOutputFunction.h

#pragma once
#include "../AgvSensor/OutputFunction.h"
#include "../AgvSensor/Enumerations.h"
 
using namespace WEnumerations;
 
namespace Com {
    namespace AgvSensorWrapper {
        namespace Structs {
            public ref class WOutputFunction
            {
            public:
                WOutputFunction() {
                    _outputFunction = new OutputFunction();
                }
                WOutputFunction(WOutputFunction^ toCopy) {
                    _outputFunction = new OutputFunction();
                    Output1 = toCopy->Output1;
                    Output2 = toCopy->Output2;
                    Output3 = toCopy->Output3;
                    Output4 = toCopy->Output4;
                }
                ~WOutputFunction() {
                    delete(_outputFunction);
                }
 
 
                property FunctionEnum Output1 {
                    FunctionEnum get() {
                        return  static_cast<FunctionEnum>(_outputFunction->GetOutput1());
                    }
                    void set(FunctionEnum x) {
                        _outputFunction->SetOutput1((NativeFunctionEnum)x);
                    }
                }
                property FunctionEnum Output2 {
                    FunctionEnum get() {
                        return  static_cast<FunctionEnum>(_outputFunction->GetOutput2());
                    }
                    void set(FunctionEnum x) {
                        _outputFunction->SetOutput2((NativeFunctionEnum)x);
                    }
                }
                property FunctionEnum Output3 {
                    FunctionEnum get() {
                        return  static_cast<FunctionEnum>(_outputFunction->GetOutput3());
                    }
                    void set(FunctionEnum x) {
                        _outputFunction->SetOutput3((NativeFunctionEnum)x);
                    }
                }
                property FunctionEnum Output4 {
                    FunctionEnum get() {
                        return  static_cast<FunctionEnum>(_outputFunction->GetOutput4());
                    }
                    void set(FunctionEnum x) {
                        _outputFunction->SetOutput4((NativeFunctionEnum)x);
                    }
                }
 
                property OutputFunction* __native {
                    OutputFunction* get() {
                        return _outputFunction;
                    }
                }
 
                static bool operator== (WOutputFunction^ pComp1, WOutputFunction^ pComp2) {
                    if (System::Object::ReferenceEquals(pComp1, pComp2))
                        return true;
 
                    if (System::Object::ReferenceEquals(pComp1, nullptr) ||
                        System::Object::ReferenceEquals(pComp2, nullptr)) {
                        return false;
                    }
                    return pComp1->Output1 == pComp2->Output1
                        && pComp1->Output2 == pComp2->Output2
                        && pComp1->Output3 == pComp2->Output3
                        && pComp1->Output4 == pComp2->Output4;
                }
 
                static bool operator!= (WOutputFunction^ pComp1, WOutputFunction^ pComp2) {
                    return !(pComp1 == pComp2);
                }
 
            private:
                OutputFunction* _outputFunction;
            };
        }
    }
}