WActiveLevel.h

#pragma once
#include "../AgvSensor/ActiveLevel.h"
#include "../AgvSensor/Enumerations.h"
 
using namespace WEnumerations;
 
namespace Com {
    namespace AgvSensorWrapper {
        namespace Structs {
            public ref class WActiveLevel
            {
            public:
                WActiveLevel() {
                    _outputActiveLevel = new ActiveLevel();
                }
                WActiveLevel(WActiveLevel^ toCopy) {
                    _outputActiveLevel = new ActiveLevel();
                    Level1 = toCopy->Level1;
                    Level2 = toCopy->Level2;
                    Level3 = toCopy->Level3;
                    Level4 = toCopy->Level4;
                    ErrorLevel = toCopy->ErrorLevel;
                }
                ~WActiveLevel() {
                    delete(_outputActiveLevel);
                }
 
 
                property ActiveLevelEnum Level1 {
                    ActiveLevelEnum get() {
                        return  static_cast<ActiveLevelEnum>(_outputActiveLevel->GetLevel1());
                    }
                    void set(ActiveLevelEnum x) {
                        _outputActiveLevel->SetLevel1((NativeActiveLevelEnum)x);
                    }
                }
                property ActiveLevelEnum Level2 {
                    ActiveLevelEnum get() {
                        return  static_cast<ActiveLevelEnum>(_outputActiveLevel->GetLevel2());
                    }
                    void set(ActiveLevelEnum x) {
                        _outputActiveLevel->SetLevel2((NativeActiveLevelEnum)x);
                    }
                }
                property ActiveLevelEnum Level3 {
                    ActiveLevelEnum get() {
                        return  static_cast<ActiveLevelEnum>(_outputActiveLevel->GetLevel3());
                    }
                    void set(ActiveLevelEnum x) {
                        _outputActiveLevel->SetLevel3((NativeActiveLevelEnum)x);
                    }
                }
                property ActiveLevelEnum Level4 {
                    ActiveLevelEnum get() {
                        return  static_cast<ActiveLevelEnum>(_outputActiveLevel->GetLevel4());
                    }
                    void set(ActiveLevelEnum x) {
                        _outputActiveLevel->SetLevel4((NativeActiveLevelEnum)x);
                    }
                }
                property ActiveLevelEnum ErrorLevel{
                ActiveLevelEnum get() {
                    return  static_cast<ActiveLevelEnum>(_outputActiveLevel->GetErrorLevel());
                }
                void set(ActiveLevelEnum x) {
                    _outputActiveLevel->SetErrorLevel((NativeActiveLevelEnum)x);
                }
                }
 
                property ActiveLevel* __native {
                    ActiveLevel* get() {
                        return _outputActiveLevel;
                    }
                }
 
                static bool operator== (WActiveLevel^ pComp1, WActiveLevel^ pComp2) {
                    if (System::Object::ReferenceEquals(pComp1, pComp2))
                        return true;
 
                    if (System::Object::ReferenceEquals(pComp1, nullptr) ||
                        System::Object::ReferenceEquals(pComp2, nullptr)) {
                        return false;
                    }
                    return pComp1->Level1 == pComp2->Level1
                        && pComp1->Level2 == pComp2->Level2
                        && pComp1->Level3 == pComp2->Level3
                        && pComp1->Level4 == pComp2->Level4
                        && pComp1->ErrorLevel == pComp2->ErrorLevel;
                }
 
                static bool operator!= (WActiveLevel^ pComp1, WActiveLevel^ pComp2) {
                    return !(pComp1 == pComp2);
                }
 
            private:
                ActiveLevel* _outputActiveLevel;
            };
        }
    }
}