File ManagedTransportLayerStream.h

File List > SpinnakerNET > ManagedTransportLayerStream.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_MANAGEDTRANSPORTLAYERSTREAM_H
#define FLIR_SPINNAKER_NET_MANAGEDTRANSPORTLAYERSTREAM_H

#include "ManagedTransportLayerDefs.h"
using namespace System;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        }

        virtual ~ManagedTransportLayerStream() {};


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    };
}
#endif // FLIR_SPINNAKER_NET_MANAGEDTRANSPORTLAYERSTREAM_H