WAgvSensor.h

#pragma once
#include "../AgvSensor/AgvSensor.h"
#include "WFieldName.h"
#include "WObjectSize.h"
#include "WWarningSpot.h"
#include "WUncoverZone.h"
#include "WDefaultValues.h"
#include "WFieldData.h"
#include "WMultipleSampling.h"
#include "WHoldTime.h"
#include "WOnOffDelay.h"
#include "WActiveLevel.h"
#include "WOutputFunction.h"
#include "WAgvSensorLeds.h"
#include <ThreadCreationException.h>
#include <SensorErrorException.h>
#include <BadAcknowledgmentException.h>
#include <CommunicationException.h>
 
using namespace WUtils;
using namespace WBase;
using namespace WCommunication;
using namespace WToolboxException;
using namespace WEnumerations;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace Com::AgvSensorWrapper::Structs;
using namespace WSensorData;
 
namespace Com {
    namespace AgvSensorWrapper {
        namespace Sensor {
            public ref class WAgvSensor :
                public WBaseSensor
            {
            public:
                WAgvSensor() {                  
                    _sensor = (BaseSensor*)new AgvSensor();
                    _wRawData = gcnew WRawDataSensor();
                }
 
                WAgvSensor(WBaseCommunication^ pcomm) {                 
                    Communication = pcomm;
                }
 
                ~WAgvSensor() {
                    delete(_sensor);
                }
 
                WCommunicationStatus^ Initialize() override {
                    if (_sensor != nullptr) {
                        delete(_sensor);
                    }
                    _sensor = (BaseSensor*)new AgvSensor(Communication->__nativeCommunication);
                    _wRawData = gcnew WRawDataSensor(Communication);
 
                    //_wRawData->Communication = this->Communication;
                    //_sensor->SetCommunication(this->Communication->__nativeCommunication);
                    WCommunicationStatus^ toReturn = _wRawData->Initialize();
 
                    if (toReturn->Status == ConnectionStatusEnum::Connected) {
                        _sensor->GetVersion(); 
                    }
 
                    return toReturn;
                }
 
                WRawData^ RetrieveRawData() {
                    return _wRawData->RetrieveRawData();
                }
                void SendMdi() {
                    _wRawData->SendMdi();               
                }
 
                void StopMdi() {
                    _wRawData->StopMdi();
                }
 
                Protocol GetRawDataExchangeMode() {
                    return _wRawData->GetRawDataExchangeMode();
                }
 
                WAngleRange^ GetAngleRange() {
                    return _wRawData->GetAngleRange();
                }
 
                ScanPacketType GetDataPacketType() {
                    return _wRawData->GetDataPacketType();
                }
 
                unsigned int GetImmunityLevel() {
                    return _wRawData->GetImmunityLevel();
                }
 
                WContaminationThreshold^ GetContaminationThreshold() {
                    return _wRawData->GetContaminationThreshold();
                }
 
                WSoftwareVersion^ GetVersion() override {
                    return _wRawData->GetVersion();
                }
 
                int GetTemperature() override {
                    return _wRawData->GetTemperature();
                }
 
                WContaminationStatus^ GetContaminationStatus() override {
                    throw gcnew NotImplementedException("Not implemented in this sensor version");
                }
 
                long GetRuntimeHours() override {
                    return _wRawData->GetRuntimeHours();
                }
 
                List<WRawDataError^>^ GetErrorLog() {
                    return _wRawData->GetErrorLog();
                }
 
                // Command settings management
                // Data retrieve
                WNetworkInformation^ GetNetworkInformation() {
                    return _wRawData->GetNetworkInformation();
                }
 
                String^ GetDeviceName() override {
                    return _wRawData->GetDeviceName();
                }
 
                WConfigurationResult^ SetRawDataExchangeMode(Protocol pProtocol) {
                    return _wRawData->SetRawDataExchangeMode(pProtocol);
                }
 
                WConfigurationResult^ SetDataPacketType(ScanPacketType pPacketType) {
                    return _wRawData->SetDataPacketType(pPacketType);
                }
 
                WConfigurationResult^ SetAngleRange(WAngleRange^ pAngleRange) {
                    return _wRawData->SetAngleRange(pAngleRange);
                }
 
                WConfigurationResult^ SetImmunityLevel(int pImmunityLevel) {
                    return _wRawData->SetImmunityLevel(pImmunityLevel);
                }
 
                WConfigurationResult^ SetContaminationThreshold(WContaminationThreshold^ pContaminationThreshold) {
                    return _wRawData->SetContaminationThreshold(pContaminationThreshold);
                }
 
 
                WConfigurationResult^ SetNetworkInformation(WNetworkInformation^ pNetwork) {
                    return _wRawData->SetNetworkInformation(pNetwork);
                }
 
                WConfigurationResult^ SetDeviceName(String^ pName) override {
                    return _wRawData->SetDeviceName(pName);
                }
 
                void ResetDevice() {
                    _wRawData->ResetDevice();
                }
 
                void ResetAllFields() {
                    try {
                        ((AgvSensor*)_sensor)->ResetAllFields();
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                void RebootDevice() {
                    _wRawData->RebootDevice();
                }
 
                List<unsigned int>^ GetWms() {
                    try {
                        vector<unsigned int> actual = ((AgvSensor*)_sensor)->GetWms();
                        List<unsigned int>^ toReturn = gcnew List<unsigned int>();
 
                        for (int i = 0; i < actual.size(); i++) {
 
                            toReturn->Add(actual[i]);
                        }
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }               
 
                String^ RequestChallenge() {
                    try {
                        string actual = ((AgvSensor*)_sensor)->RequestChallenge();
 
                        return gcnew String(actual.c_str());
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SendCypher(String^ challenge) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SendCypher(WConverter::ConvertToNativeString(challenge)));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
                WSensorLamps^ GetSensorLamps() {
                    try {
                        WSensorLamps^ toReturn = gcnew WSensorLamps();
                        SensorLamps actual = ((AgvSensor*)_sensor)->GetSensorLamps();
                        toReturn->Led1 = (LedColor)actual.GetLed1();
                        toReturn->Led2 = (LedColor)actual.GetLed2();
                        toReturn->Led3 = (LedColor)actual.GetLed3();
                        toReturn->Led4 = (LedColor)actual.GetLed4();
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WFieldName^ GetFieldName(int fieldSetNumber) {
                    try {
                        WFieldName^ toReturn = gcnew WFieldName();
 
                        FieldName actual = ((AgvSensor*)_sensor)->GetFieldName(fieldSetNumber);
 
                        toReturn->FieldNumber = actual.GetFieldNumber();
                        toReturn->MainName = gcnew String(actual.GetMainName().c_str());
                        toReturn->NearZoneName = gcnew String(actual.GetNearZoneName().c_str());
                        toReturn->MiddleZoneName = gcnew String(actual.GetMiddleZoneName().c_str());
                        toReturn->FarZoneName = gcnew String(actual.GetFarZoneName().c_str());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
                WObjectSize^ GetObjectSize() {
                    try {
                        WObjectSize^ toReturn = gcnew WObjectSize();
 
                        ObjectSize actual = ((AgvSensor*)_sensor)->GetObjectSize();
 
                        toReturn->Near = static_cast<ObjSizeEnum>(actual.GetNear());
                        toReturn->Middle = static_cast<ObjSizeEnum>(actual.GetMiddle());
                        toReturn->Far = static_cast<ObjSizeEnum>(actual.GetFar());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WWarningSpot^ GetWarningSpot() {
                    try {
                        WWarningSpot^ toReturn = gcnew WWarningSpot();
 
                        WarningSpot actual = ((AgvSensor*)_sensor)->GetWarningSpot();
 
                        toReturn->Near = actual.GetNear();
                        toReturn->Middle = actual.GetMiddle();
                        toReturn->Far = actual.GetFar();
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WUncoverZone^ GetUncoverZoneSize() {
                    try {
                        WUncoverZone^ toReturn = gcnew WUncoverZone();
 
                        UncoverZone actual = ((AgvSensor*)_sensor)->GetUncoverZoneSize();
 
                        toReturn->Near = static_cast<UncoveredZoneSizeEnum>(actual.GetNear());
                        toReturn->Middle = static_cast<UncoveredZoneSizeEnum>(actual.GetMiddle());
                        toReturn->Far = static_cast<UncoveredZoneSizeEnum>(actual.GetFar());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
                WFieldData^ GetField(int fieldNumber, ZoneTypeEnum zone) {
                    try {
                        WFieldData^ toReturn = gcnew WFieldData();
 
                        FieldData actual = ((AgvSensor*)_sensor)->GetField(fieldNumber, static_cast<NativeZoneTypeEnum>(zone));
                        toReturn->FieldNumber = actual.GetFieldNumber();
                        toReturn->ZoneType = static_cast<ZoneTypeEnum>(actual.GetZoneType());
                        toReturn->Parameter1 = actual.GetParameter1();
                        toReturn->Parameter2 = actual.GetParameter2();
                        toReturn->Crc = actual.GetCrc();
                        toReturn->GUID = gcnew String(actual.GetGUID().c_str());
                        toReturn->__fetchNativeData(actual.GetData());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
                unsigned int GetSelectedField() {
                    try {
                        return ((AgvSensor*)_sensor)->GetSelectedField();
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
            
            
                WOnOffDelay^ GetOnDelay() {
                    try {
                        WOnOffDelay^ toReturn = gcnew WOnOffDelay();
 
                        OnOffDelay actual = ((AgvSensor*)_sensor)->GetOnDelay();
                        toReturn->Near = actual.GetNear();
                        toReturn->Middle = actual.GetMiddle();
                        toReturn->Far = actual.GetFar();
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WOnOffDelay^ GetOffDelay() {
                    try {
                        WOnOffDelay^ toReturn = gcnew WOnOffDelay();
 
                        OnOffDelay actual = ((AgvSensor*)_sensor)->GetOffDelay();
                        toReturn->Near = actual.GetNear();
                        toReturn->Middle = actual.GetMiddle();
                        toReturn->Far = actual.GetFar();
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WActiveLevel^ GetOutputActiveLevel() {
                    try {
                        WActiveLevel^ toReturn = gcnew WActiveLevel();
 
                        ActiveLevel actual = ((AgvSensor*)_sensor)->GetOutputActiveLevel();
                        toReturn->Level1 = static_cast<ActiveLevelEnum>(actual.GetLevel1());
                        toReturn->Level2 = static_cast<ActiveLevelEnum>(actual.GetLevel2());
                        toReturn->Level3 = static_cast<ActiveLevelEnum>(actual.GetLevel3());
                        toReturn->Level4 = static_cast<ActiveLevelEnum>(actual.GetLevel4());
                        toReturn->ErrorLevel = static_cast<ActiveLevelEnum>(actual.GetErrorLevel());
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WActiveLevel^ GetOutputStatus() {
                    try {
                        WActiveLevel^ toReturn = gcnew WActiveLevel();
 
                        ActiveLevel actual = ((AgvSensor*)_sensor)->GetOutputStatus();
                        toReturn->Level1 = static_cast<ActiveLevelEnum>(actual.GetLevel1());
                        toReturn->Level2 = static_cast<ActiveLevelEnum>(actual.GetLevel2());
                        toReturn->Level3 = static_cast<ActiveLevelEnum>(actual.GetLevel3());
                        toReturn->Level4 = static_cast<ActiveLevelEnum>(actual.GetLevel4());
                        toReturn->ErrorLevel = static_cast<ActiveLevelEnum>(actual.GetErrorLevel());
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WActiveLevel^ GetInputStatus() {
                    try {
                        WActiveLevel^ toReturn = gcnew WActiveLevel();
 
                        ActiveLevel actual = ((AgvSensor*)_sensor)->GetInputStatus();
                        toReturn->Level1 = static_cast<ActiveLevelEnum>(actual.GetLevel1());
                        toReturn->Level2 = static_cast<ActiveLevelEnum>(actual.GetLevel2());
                        toReturn->Level3 = static_cast<ActiveLevelEnum>(actual.GetLevel3());
                        toReturn->Level4 = static_cast<ActiveLevelEnum>(actual.GetLevel4());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WOutputFunction^ GetOutputFunction() {
                    try {
                        WOutputFunction^ toReturn = gcnew WOutputFunction();
 
                        OutputFunction actual = ((AgvSensor*)_sensor)->GetOutputFunction();
                        toReturn->Output1 = static_cast<FunctionEnum>(actual.GetOutput1());
                        toReturn->Output2 = static_cast<FunctionEnum>(actual.GetOutput2());
                        toReturn->Output3 = static_cast<FunctionEnum>(actual.GetOutput3());
                        toReturn->Output4 = static_cast<FunctionEnum>(actual.GetOutput4());
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WDefaultValues^ GetDefaultValues() {
                    WDefaultValues^ toReturn = gcnew WDefaultValues();
                    DefaultValues actual = ((AgvSensor*)_sensor)->GetDefaultValues();
 
 
                    String^ deviceName = gcnew String(actual.GetDeviceName().c_str());
                    WAngleRange^ angleRange = gcnew WAngleRange();
                    WContaminationThreshold^ contaminationThreshold = gcnew WContaminationThreshold();
                    WObjectSize^ objectSize = gcnew WObjectSize();
                    WWarningSpot^ warningSpot = gcnew WWarningSpot();
                    WOnOffDelay^ onDelays = gcnew WOnOffDelay();
                    WOnOffDelay^ offDelays = gcnew WOnOffDelay();
                    WOutputFunction^ outputFunction = gcnew WOutputFunction();
                    WActiveLevel^ activeLevel = gcnew WActiveLevel();
                    WAgvSensorLeds^ sensorLeds = gcnew WAgvSensorLeds();
 
                    angleRange->Start = actual.GetAngleRange().GetStart();
                    angleRange->Stop = actual.GetAngleRange().GetStop();
                    
                    contaminationThreshold->Warning = actual.GetContaminationThreshold().GetWarning();
                    contaminationThreshold->Error = actual.GetContaminationThreshold().GetError();
                    
                    objectSize->Near = static_cast<ObjSizeEnum>(actual.GetObjectSize().GetNear());
                    objectSize->Middle = static_cast<ObjSizeEnum>(actual.GetObjectSize().GetMiddle());
                    objectSize->Far = static_cast<ObjSizeEnum>(actual.GetObjectSize().GetFar());
 
                    warningSpot->Near = actual.GetWarningSpot().GetNear();
                    warningSpot->Middle = actual.GetWarningSpot().GetMiddle();
                    warningSpot->Far = actual.GetWarningSpot().GetFar();
 
                    onDelays->Near = actual.GetOnDelays().GetNear();
                    onDelays->Middle = actual.GetOnDelays().GetMiddle();
                    onDelays->Far = actual.GetOnDelays().GetFar();
 
                    offDelays->Near = actual.GetOffDelays().GetNear();
                    offDelays->Middle = actual.GetOffDelays().GetMiddle();
                    offDelays->Far = actual.GetOffDelays().GetFar();
 
 
                    outputFunction->Output1 = static_cast<FunctionEnum>(actual.GetOutputFunction().GetOutput1());
                    outputFunction->Output2 = static_cast<FunctionEnum>(actual.GetOutputFunction().GetOutput2());
                    outputFunction->Output3 = static_cast<FunctionEnum>(actual.GetOutputFunction().GetOutput3());
                    outputFunction->Output4 = static_cast<FunctionEnum>(actual.GetOutputFunction().GetOutput4());
 
                    activeLevel->Level1 = static_cast<ActiveLevelEnum>(actual.GetOutputActiveLevel().GetLevel1());
                    activeLevel->Level2 = static_cast<ActiveLevelEnum>(actual.GetOutputActiveLevel().GetLevel2());
                    activeLevel->Level3 = static_cast<ActiveLevelEnum>(actual.GetOutputActiveLevel().GetLevel3());
                    activeLevel->Level4 = static_cast<ActiveLevelEnum>(actual.GetOutputActiveLevel().GetLevel4());
 
                    sensorLeds->ContaminationLed = actual.GetSensorLeds().GetContaminationLed();
                    sensorLeds->StatusLed = actual.GetSensorLeds().GetStatusLed();
                    sensorLeds->LogoLed = actual.GetSensorLeds().GetLogoLed();
 
                    toReturn->DeviceName = deviceName;
                    toReturn->AngleRange = angleRange;
                    toReturn->ContaminationThreshold = contaminationThreshold;
                    toReturn->ObjectSize = objectSize;
                    toReturn->WarningSpot = warningSpot;
                    toReturn->OnDelays = onDelays;
                    toReturn->OffDelays = offDelays;
                    toReturn->OutputFunction = outputFunction;
                    toReturn->OutputActiveLevel = activeLevel;
                    toReturn->SensorLeds = sensorLeds;
 
 
                    return toReturn;
                }
                WAgvSensorLeds^ GetSensorLeds() {
                    try {
                        WAgvSensorLeds^ toReturn = gcnew WAgvSensorLeds();
 
                        AgvSensorLeds actual = ((AgvSensor*)_sensor)->GetSensorLeds();
                        toReturn->ContaminationLed = actual.GetContaminationLed();
                        toReturn->StatusLed = actual.GetStatusLed();
                        toReturn->LogoLed = actual.GetLogoLed();                        
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetFieldName(WFieldName^ fieldName) {
                    try {                                       
                        return toManagedInstance(((AgvSensor*)_sensor)->SetFieldName(*fieldName->__native));                        
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetObjectSize(WObjectSize^ sizeToSet) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetObjectSize(*sizeToSet->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetWarningSpot(WWarningSpot^ spotToSet) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetWarningSpot(*spotToSet->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
 
                // <summary>
                WConfigurationResult^ SetUncoverZoneSize(WUncoverZone^ sizeToSet) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetUncoverZoneSize(*sizeToSet->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetField(WFieldData^ data) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetField(*data->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
            
                WConfigurationResult^ SetMultipleSampling(WMultipleSampling^ sampling) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetMultipleSampling(*sampling->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetHoldTime(WHoldTime^ holdTime) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetHoldTime(*holdTime->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetOnDelay(WOnOffDelay^ onDelay) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetOnDelay(*onDelay->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetOffDelay(WOnOffDelay^ offDelay) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetOffDelay(*offDelay->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
 
 
 
                WConfigurationResult^ SetOutputActiveLevel(WActiveLevel^ activeLevel) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetOutputActiveLevel(*activeLevel->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ SetOutputFunction(WOutputFunction^ function) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetOutputFunction(*function->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                void SetInputControlModeStatus(InputControleModeStatus controlMode) {
                    try {
                        ((AgvSensor*)_sensor)->SetInputControlModeStatus(static_cast<NativeInputControleModeStatus>(controlMode));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                };
 
 
                void SetZone1Mode(ZoneModeEnum mode) {
                    try {
                        ((AgvSensor*)_sensor)->SetZone1Mode(static_cast<NativeZoneModeEnum>(mode));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                };
 
 
                void SetInputsValue(ActiveLevelEnum input1, ActiveLevelEnum input2, ActiveLevelEnum input3, ActiveLevelEnum input4) {
                    try {
                        ((AgvSensor*)_sensor)->SetInputsValue(static_cast<NativeActiveLevelEnum>(input1), static_cast<NativeActiveLevelEnum>(input2), static_cast<NativeActiveLevelEnum>(input3), static_cast<NativeActiveLevelEnum>(input4));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                };
 
                WConfigurationResult^ SetSensorLeds(WAgvSensorLeds^ leds) {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->SetSensorLeds(*leds->__native));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                WConfigurationResult^ StoreInFlash() {
                    try {
                        return toManagedInstance(((AgvSensor*)_sensor)->StoreInFlash());
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                unsigned int GetPlatformVersion() override {
                    try {
                        unsigned int platformVersion = _wRawData->GetPlatformVersion();
 
                        return platformVersion;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
                void StartLearning(int fieldNumber, ZoneTypeEnum zone, unsigned int uncover, ObjSizeEnum objectSize) {
                    try {
                        ((AgvSensor*)_sensor)->StartLearning(fieldNumber, static_cast<NativeZoneTypeEnum>(zone), uncover, static_cast<NativeObjSizeEnum>(objectSize));
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                };
 
                void StopLearning() {
                    try {
                        ((AgvSensor*)_sensor)->StopLearning();
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                void AbortLearning() {
                    try {
                        ((AgvSensor*)_sensor)->AbortLearning();
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                FieldLearningStatusEnum GetLearningStatus() {
                    try {
                        FieldLearningStatusEnum toReturn;
 
                        NativeFieldLearningStatus status = ((AgvSensor*)_sensor)->GetLearningStatus();
                        toReturn = static_cast<FieldLearningStatusEnum>(status);
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
 
                unsigned int GetLearningErrorCode() override {
                    try {
                        unsigned int learningErrorCode = ((AgvSensor*)_sensor)->GetLearningErrorCode();
 
                        return learningErrorCode;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                AbortStatus GetAbortStatus() {
                    try {
                        AbortStatus toReturn;
 
                        NativeAbortStatus status = ((AgvSensor*)_sensor)->GetAbortStatus();
                        toReturn = static_cast<AbortStatus>(status);
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
 
 
                InputControleModeStatus GetInputControlModeStatus() {
                    try {
                        InputControleModeStatus toReturn;
 
                        NativeInputControleModeStatus status = ((AgvSensor*)_sensor)->GetInputControlModeStatus();
                        toReturn = static_cast<InputControleModeStatus>(status);
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
                ZoneModeEnum GetZone1Mode() {
                    try {
                        ZoneModeEnum toReturn;
 
                        NativeZoneModeEnum status = ((AgvSensor*)_sensor)->GetZone1Mode();
                        toReturn = static_cast<ZoneModeEnum>(status);
 
                        return toReturn;
                    }
                    catch (BadAcknowledgmentException e) {
                        WBadAcknowledgmentException^ toThrow = gcnew WBadAcknowledgmentException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                    catch (CommunicationException e) {
                        WCommunicationException^ toThrow = gcnew WCommunicationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = e.GetErrorCode();
                        throw toThrow;
                    }
                    catch (SensorErrorException e) {
                        WSensorException^ toThrow = gcnew WSensorException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        toThrow->ErrorCode = gcnew String(e.GetErrorCode().c_str());
                        throw toThrow;
 
                    }
                    catch (ThreadCreationException e) {
                        WThreadCreationException^ toThrow = gcnew WThreadCreationException(gcnew String(e.what()), gcnew String(e.GetTranslateCode().c_str()));
                        throw toThrow;
                    }
                }
 
 
                protected:
                    WConfigurationResult^ toManagedInstance(ConfigurationResult pResult) {
                        WConfigurationResult^ toReturn = gcnew WConfigurationResult();
                        toReturn->Result = pResult.GetResult();
                        for (int i = 0; i < pResult.GetReasons().size(); i++) {
                            toReturn->PushReason(gcnew String(pResult.GetReasons()[i].c_str()));
                        }
                        return toReturn;
                    }
                private:
                    WRawDataSensor^ _wRawData;
            };              
        }
    }
}