File ManagedTransportLayerInterface.h

File List > SpinnakerNET > ManagedTransportLayerInterface.h

Go to the documentation of this file

//=============================================================================
// Copyright (c) 2026 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================

/* Auto-generated file. Do not modify. */

#ifndef FLIR_SPINNAKER_NET_MANAGEDTRANSPORTLAYERINTERFACE_H
#define FLIR_SPINNAKER_NET_MANAGEDTRANSPORTLAYERINTERFACE_H

#include "ManagedTransportLayerDefs.h"
using namespace System;

namespace SpinnakerNET
{
    public ref class ManagedTransportLayerInterface
    {
    public:
        ManagedTransportLayerInterface(SpinnakerNET::GenApi::NodeMap^ pNodeMapTLDevice)
        {
            SpinnakerNET::GenApi::Node^ aNode;

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("InterfaceID");
                InterfaceID = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                InterfaceID = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("InterfaceDisplayName");
                InterfaceDisplayName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                InterfaceDisplayName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("InterfaceType");
                InterfaceType = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                InterfaceType = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceGatewaySelector");
                GevInterfaceGatewaySelector = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceGatewaySelector = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceGateway");
                GevInterfaceGateway = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceGateway = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceMACAddress");
                GevInterfaceMACAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceMACAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceSubnetSelector");
                GevInterfaceSubnetSelector = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceSubnetSelector = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceSubnetIPAddress");
                GevInterfaceSubnetIPAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceSubnetIPAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceSubnetMask");
                GevInterfaceSubnetMask = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceSubnetMask = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceTransmitLinkSpeed");
                GevInterfaceTransmitLinkSpeed = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceTransmitLinkSpeed = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceReceiveLinkSpeed");
                GevInterfaceReceiveLinkSpeed = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceReceiveLinkSpeed = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceMTU");
                GevInterfaceMTU = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceMTU = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevInterfaceIsIPConflict");
                GevInterfaceIsIPConflict = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::BoolNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevInterfaceIsIPConflict = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("POEStatus");
                POEStatus = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                POEStatus = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("FLIRFilterDriverStatus");
                FLIRFilterDriverStatus = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                FLIRFilterDriverStatus = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("TeledyneGigeVisionFilterDriverStatus");
                TeledyneGigeVisionFilterDriverStatus = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                TeledyneGigeVisionFilterDriverStatus = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevActionDeviceKey");
                GevActionDeviceKey = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevActionDeviceKey = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevActionGroupKey");
                GevActionGroupKey = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevActionGroupKey = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevActionGroupMask");
                GevActionGroupMask = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevActionGroupMask = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevActionTime");
                GevActionTime = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevActionTime = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevActionAckRequired");
                GevActionAckRequired = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::BoolNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevActionAckRequired = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("ActionCommand");
                ActionCommand = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                ActionCommand = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceUnlock");
                DeviceUnlock = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceUnlock = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceUpdateList");
                DeviceUpdateList = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceUpdateList = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceCount");
                DeviceCount = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceCount = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceSelector");
                DeviceSelector = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceSelector = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceID");
                DeviceID = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceID = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceVendorName");
                DeviceVendorName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceVendorName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceModelName");
                DeviceModelName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceModelName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceSerialNumber");
                DeviceSerialNumber = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceSerialNumber = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("DeviceAccessStatus");
                DeviceAccessStatus = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                DeviceAccessStatus = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceIPAddress");
                GevDeviceIPAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceIPAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceSubnetMask");
                GevDeviceSubnetMask = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceSubnetMask = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceGateway");
                GevDeviceGateway = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceGateway = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceMACAddress");
                GevDeviceMACAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceMACAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleDeviceCount");
                IncompatibleDeviceCount = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleDeviceCount = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleDeviceSelector");
                IncompatibleDeviceSelector = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleDeviceSelector = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleDeviceID");
                IncompatibleDeviceID = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleDeviceID = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleDeviceVendorName");
                IncompatibleDeviceVendorName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleDeviceVendorName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleDeviceModelName");
                IncompatibleDeviceModelName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleDeviceModelName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleGevDeviceIPAddress");
                IncompatibleGevDeviceIPAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleGevDeviceIPAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleGevDeviceSubnetMask");
                IncompatibleGevDeviceSubnetMask = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleGevDeviceSubnetMask = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("IncompatibleGevDeviceMACAddress");
                IncompatibleGevDeviceMACAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                IncompatibleGevDeviceMACAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceForceIP");
                GevDeviceForceIP = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceForceIP = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceForceIPAddress");
                GevDeviceForceIPAddress = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceForceIPAddress = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceForceSubnetMask");
                GevDeviceForceSubnetMask = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceForceSubnetMask = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceForceGateway");
                GevDeviceForceGateway = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceForceGateway = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceAutoForceIP");
                GevDeviceAutoForceIP = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceAutoForceIP = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceDiscoveryEnabled");
                GevDeviceDiscoveryEnabled = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::BoolNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceDiscoveryEnabled = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceEnableDiscovery");
                GevDeviceEnableDiscovery = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceEnableDiscovery = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("GevDeviceDisableDiscovery");
                GevDeviceDisableDiscovery = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Command(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                GevDeviceDisableDiscovery = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("CpuAffinityPrivilege");
                CpuAffinityPrivilege = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Enumeration(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                CpuAffinityPrivilege = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("ReceiveSideScalingReservedCores");
                ReceiveSideScalingReservedCores = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                ReceiveSideScalingReservedCores = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("ReceiveSideScalingReservedCoresCount");
                ReceiveSideScalingReservedCoresCount = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::Integer(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                ReceiveSideScalingReservedCoresCount = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("CPUAffinityEnable");
                CPUAffinityEnable = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::BoolNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                CPUAffinityEnable = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("HostAdapterName");
                HostAdapterName = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                HostAdapterName = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("HostAdapterVendor");
                HostAdapterVendor = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                HostAdapterVendor = nullptr;
            }

            try
            {
                aNode = pNodeMapTLDevice->GetNode<SpinnakerNET::GenApi::Node^>("HostAdapterDriverVersion");
                HostAdapterDriverVersion = (aNode == nullptr) ? nullptr : gcnew SpinnakerNET::GenApi::StringNode(pNodeMapTLDevice, aNode->Handle);
            }
            catch (::System::Exception^)
            {
                HostAdapterDriverVersion = nullptr;
            }

        }

        virtual ~ManagedTransportLayerInterface() {};


    public:
        virtual property SpinnakerNET::GenApi::StringNode^ InterfaceID;

        virtual property SpinnakerNET::GenApi::StringNode^ InterfaceDisplayName;

        virtual property SpinnakerNET::GenApi::Enumeration^ InterfaceType;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceGatewaySelector;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceGateway;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceMACAddress;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceSubnetSelector;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceSubnetIPAddress;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceSubnetMask;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceTransmitLinkSpeed;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceReceiveLinkSpeed;

        virtual property SpinnakerNET::GenApi::Integer^ GevInterfaceMTU;

        virtual property SpinnakerNET::GenApi::BoolNode ^ GevInterfaceIsIPConflict;

        virtual property SpinnakerNET::GenApi::Enumeration^ POEStatus;

        virtual property SpinnakerNET::GenApi::Enumeration^ FLIRFilterDriverStatus;

        virtual property SpinnakerNET::GenApi::Enumeration^ TeledyneGigeVisionFilterDriverStatus;

        virtual property SpinnakerNET::GenApi::Integer^ GevActionDeviceKey;

        virtual property SpinnakerNET::GenApi::Integer^ GevActionGroupKey;

        virtual property SpinnakerNET::GenApi::Integer^ GevActionGroupMask;

        virtual property SpinnakerNET::GenApi::Integer^ GevActionTime;

        virtual property SpinnakerNET::GenApi::BoolNode ^ GevActionAckRequired;

        virtual property SpinnakerNET::GenApi::Command^ ActionCommand;

        virtual property SpinnakerNET::GenApi::StringNode^ DeviceUnlock;

        virtual property SpinnakerNET::GenApi::Command^ DeviceUpdateList;

        virtual property SpinnakerNET::GenApi::Integer^ DeviceCount;

        virtual property SpinnakerNET::GenApi::Integer^ DeviceSelector;

        virtual property SpinnakerNET::GenApi::StringNode^ DeviceID;

        virtual property SpinnakerNET::GenApi::StringNode^ DeviceVendorName;

        virtual property SpinnakerNET::GenApi::StringNode^ DeviceModelName;

        virtual property SpinnakerNET::GenApi::StringNode^ DeviceSerialNumber;

        virtual property SpinnakerNET::GenApi::Enumeration^ DeviceAccessStatus;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceIPAddress;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceSubnetMask;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceGateway;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceMACAddress;

        virtual property SpinnakerNET::GenApi::Integer^ IncompatibleDeviceCount;

        virtual property SpinnakerNET::GenApi::Integer^ IncompatibleDeviceSelector;

        virtual property SpinnakerNET::GenApi::StringNode^ IncompatibleDeviceID;

        virtual property SpinnakerNET::GenApi::StringNode^ IncompatibleDeviceVendorName;

        virtual property SpinnakerNET::GenApi::StringNode^ IncompatibleDeviceModelName;

        virtual property SpinnakerNET::GenApi::Integer^ IncompatibleGevDeviceIPAddress;

        virtual property SpinnakerNET::GenApi::Integer^ IncompatibleGevDeviceSubnetMask;

        virtual property SpinnakerNET::GenApi::Integer^ IncompatibleGevDeviceMACAddress;

        virtual property SpinnakerNET::GenApi::Command^ GevDeviceForceIP;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceForceIPAddress;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceForceSubnetMask;

        virtual property SpinnakerNET::GenApi::Integer^ GevDeviceForceGateway;

        virtual property SpinnakerNET::GenApi::Command^ GevDeviceAutoForceIP;

        virtual property SpinnakerNET::GenApi::BoolNode ^ GevDeviceDiscoveryEnabled;

        virtual property SpinnakerNET::GenApi::Command^ GevDeviceEnableDiscovery;

        virtual property SpinnakerNET::GenApi::Command^ GevDeviceDisableDiscovery;

        virtual property SpinnakerNET::GenApi::Enumeration^ CpuAffinityPrivilege;

        virtual property SpinnakerNET::GenApi::StringNode^ ReceiveSideScalingReservedCores;

        virtual property SpinnakerNET::GenApi::Integer^ ReceiveSideScalingReservedCoresCount;

        virtual property SpinnakerNET::GenApi::BoolNode ^ CPUAffinityEnable;

        virtual property SpinnakerNET::GenApi::StringNode^ HostAdapterName;

        virtual property SpinnakerNET::GenApi::StringNode^ HostAdapterVendor;

        virtual property SpinnakerNET::GenApi::StringNode^ HostAdapterDriverVersion;

    };
}
#endif // FLIR_SPINNAKER_NET_MANAGEDTRANSPORTLAYERINTERFACE_H