NvInfer.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 1993-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
#ifndef NV_INFER_H
#define NV_INFER_H
 
#include "NvInferLegacyDims.h"
#include "NvInferRuntime.h"
 
//
 
 
namespace nvinfer1
{
 
enum class LayerType : int32_t
{
    kCONVOLUTION = 0,           
    kFULLY_CONNECTED = 1,       
    kACTIVATION = 2,            
    kPOOLING = 3,               
    kLRN = 4,                   
    kSCALE = 5,                 
    kSOFTMAX = 6,               
    kDECONVOLUTION = 7,         
    kCONCATENATION = 8,         
    kELEMENTWISE = 9,           
    kPLUGIN = 10,               
    kUNARY = 11,                
    kPADDING = 12,              
    kSHUFFLE = 13,              
    kREDUCE = 14,               
    kTOPK = 15,                 
    kGATHER = 16,               
    kMATRIX_MULTIPLY = 17,      
    kRAGGED_SOFTMAX = 18,       
    kCONSTANT = 19,             
    kRNN_V2 = 20,               
    kIDENTITY = 21,             
    kPLUGIN_V2 = 22,            
    kSLICE = 23,                
    kSHAPE = 24,                
    kPARAMETRIC_RELU = 25,      
    kRESIZE = 26,               
    kTRIP_LIMIT = 27,           
    kRECURRENCE = 28,           
    kITERATOR = 29,             
    kLOOP_OUTPUT = 30,          
    kSELECT = 31,               
    kFILL = 32,                 
    kQUANTIZE = 33,             
    kDEQUANTIZE = 34,           
    kCONDITION = 35,            
    kCONDITIONAL_INPUT = 36,    
    kCONDITIONAL_OUTPUT = 37,   
    kSCATTER = 38,              
    kEINSUM = 39,               
    kASSERTION = 40,            
};
 
template <>
constexpr inline int32_t EnumMax<LayerType>() noexcept
{
    return 41;
}
 
using TensorFormats = uint32_t;
 
enum class ActivationType : int32_t
{
    kRELU = 0,             
    kSIGMOID = 1,          
    kTANH = 2,             
    kLEAKY_RELU = 3,       
    kELU = 4,              
    kSELU = 5,             
    kSOFTSIGN = 6,         
    kSOFTPLUS = 7,         
    kCLIP = 8,             
    kHARD_SIGMOID = 9,     
    kSCALED_TANH = 10,     
    kTHRESHOLDED_RELU = 11 
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ActivationType>
{
    static constexpr int32_t kVALUE = 12;
};
} // namespace impl
 
class ITensor : public INoCopy
{
public:
    void setName(char const* name) noexcept
    {
        mImpl->setName(name);
    }
 
    char const* getName() const noexcept
    {
        return mImpl->getName();
    }
 
    void setDimensions(Dims dimensions) noexcept
    {
        mImpl->setDimensions(dimensions);
    }
 
    Dims getDimensions() const noexcept
    {
        return mImpl->getDimensions();
    }
 
    void setType(DataType type) noexcept
    {
        mImpl->setType(type);
    }
 
    DataType getType() const noexcept
    {
        return mImpl->getType();
    }
 
    bool setDynamicRange(float min, float max) noexcept
    {
        return mImpl->setDynamicRange(min, max);
    }
 
    bool isNetworkInput() const noexcept
    {
        return mImpl->isNetworkInput();
    }
 
    bool isNetworkOutput() const noexcept
    {
        return mImpl->isNetworkOutput();
    }
 
    void setBroadcastAcrossBatch(bool broadcastAcrossBatch) noexcept
    {
        mImpl->setBroadcastAcrossBatch(broadcastAcrossBatch);
    }
 
    bool getBroadcastAcrossBatch() const noexcept
    {
        return mImpl->getBroadcastAcrossBatch();
    }
 
    TensorLocation getLocation() const noexcept
    {
        return mImpl->getLocation();
    }
 
    void setLocation(TensorLocation location) noexcept
    {
        mImpl->setLocation(location);
    }
 
    bool dynamicRangeIsSet() const noexcept
    {
        return mImpl->dynamicRangeIsSet();
    }
 
    void resetDynamicRange() noexcept
    {
        mImpl->resetDynamicRange();
    }
 
    float getDynamicRangeMin() const noexcept
    {
        return mImpl->getDynamicRangeMin();
    }
 
    float getDynamicRangeMax() const noexcept
    {
        return mImpl->getDynamicRangeMax();
    }
 
    void setAllowedFormats(TensorFormats formats) noexcept
    {
        mImpl->setAllowedFormats(formats);
    }
 
    TensorFormats getAllowedFormats() const noexcept
    {
        return mImpl->getAllowedFormats();
    }
 
    bool isShapeTensor() const noexcept
    {
        return mImpl->isShapeTensor();
    }
 
    bool isExecutionTensor() const noexcept
    {
        return mImpl->isExecutionTensor();
    }
 
protected:
    apiv::VTensor* mImpl;
    virtual ~ITensor() noexcept = default;
};
 
class ILayer : public INoCopy
{
public:
    LayerType getType() const noexcept
    {
        return mLayer->getType();
    }
 
    void setName(char const* name) noexcept
    {
        mLayer->setName(name);
    }
 
 
    char const* getName() const noexcept
    {
        return mLayer->getName();
    }
 
    int32_t getNbInputs() const noexcept
    {
        return mLayer->getNbInputs();
    }
 
    ITensor* getInput(int32_t index) const noexcept
    {
        return mLayer->getInput(index);
    }
 
    int32_t getNbOutputs() const noexcept
    {
        return mLayer->getNbOutputs();
    }
 
    ITensor* getOutput(int32_t index) const noexcept
    {
        return mLayer->getOutput(index);
    }
 
    void setInput(int32_t index, ITensor& tensor) noexcept
    {
        return mLayer->setInput(index, tensor);
    }
 
    void setPrecision(DataType dataType) noexcept
    {
        mLayer->setPrecision(dataType);
    }
 
    DataType getPrecision() const noexcept
    {
        return mLayer->getPrecision();
    }
 
    bool precisionIsSet() const noexcept
    {
        return mLayer->precisionIsSet();
    }
 
    void resetPrecision() noexcept
    {
        mLayer->resetPrecision();
    }
 
    void setOutputType(int32_t index, DataType dataType) noexcept
    {
        mLayer->setOutputType(index, dataType);
    }
 
    DataType getOutputType(int32_t index) const noexcept
    {
        return mLayer->getOutputType(index);
    }
 
    bool outputTypeIsSet(int32_t index) const noexcept
    {
        return mLayer->outputTypeIsSet(index);
    }
 
    void resetOutputType(int32_t index) noexcept
    {
        return mLayer->resetOutputType(index);
    }
 
protected:
    virtual ~ILayer() noexcept = default;
    apiv::VLayer* mLayer;
};
 
enum class PaddingMode : int32_t
{
    kEXPLICIT_ROUND_DOWN = 0, 
    kEXPLICIT_ROUND_UP = 1,   
    kSAME_UPPER = 2,          
    kSAME_LOWER = 3,          
    kCAFFE_ROUND_DOWN = 4,    
    kCAFFE_ROUND_UP = 5       
};
 
namespace impl
{
template <>
struct EnumMaxImpl<PaddingMode>
{
    static constexpr int32_t kVALUE = 6;
};
} // namespace impl
 
class IConvolutionLayer : public ILayer
{
public:
    TRT_DEPRECATED void setKernelSize(DimsHW kernelSize) noexcept
    {
        mImpl->setKernelSize(kernelSize);
    }
 
    TRT_DEPRECATED DimsHW getKernelSize() const noexcept
    {
        return mImpl->getKernelSize();
    }
 
    void setNbOutputMaps(int32_t nbOutputMaps) noexcept
    {
        mImpl->setNbOutputMaps(nbOutputMaps);
    }
 
    int32_t getNbOutputMaps() const noexcept
    {
        return mImpl->getNbOutputMaps();
    }
 
    TRT_DEPRECATED void setStride(DimsHW stride) noexcept
    {
        mImpl->setStride(stride);
    }
 
    TRT_DEPRECATED DimsHW getStride() const noexcept
    {
        return mImpl->getStride();
    }
 
    TRT_DEPRECATED void setPadding(DimsHW padding) noexcept
    {
        return mImpl->setPadding(padding);
    }
 
    TRT_DEPRECATED DimsHW getPadding() const noexcept
    {
        return mImpl->getPadding();
    }
 
    void setNbGroups(int32_t nbGroups) noexcept
    {
        mImpl->setNbGroups(nbGroups);
    }
 
    int32_t getNbGroups() const noexcept
    {
        return mImpl->getNbGroups();
    }
 
    void setKernelWeights(Weights weights) noexcept
    {
        mImpl->setKernelWeights(weights);
    }
 
    Weights getKernelWeights() const noexcept
    {
        return mImpl->getKernelWeights();
    }
 
    void setBiasWeights(Weights weights) noexcept
    {
        mImpl->setBiasWeights(weights);
    }
 
    Weights getBiasWeights() const noexcept
    {
        return mImpl->getBiasWeights();
    }
 
    TRT_DEPRECATED void setDilation(DimsHW dilation) noexcept
    {
        return mImpl->setDilation(dilation);
    }
 
    TRT_DEPRECATED DimsHW getDilation() const noexcept
    {
        return mImpl->getDilation();
    }
 
    void setPrePadding(Dims padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims padding) noexcept
    {
        mImpl->setPostPadding(padding);
    }
 
    Dims getPostPadding() const noexcept
    {
        return mImpl->getPostPadding();
    }
 
    void setPaddingMode(PaddingMode paddingMode) noexcept
    {
        mImpl->setPaddingMode(paddingMode);
    }
 
    PaddingMode getPaddingMode() const noexcept
    {
        return mImpl->getPaddingMode();
    }
 
    void setKernelSizeNd(Dims kernelSize) noexcept
    {
        mImpl->setKernelSizeNd(kernelSize);
    }
 
    Dims getKernelSizeNd() const noexcept
    {
        return mImpl->getKernelSizeNd();
    }
 
    void setStrideNd(Dims stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims padding) noexcept
    {
        mImpl->setPaddingNd(padding);
    }
 
    Dims getPaddingNd() const noexcept
    {
        return mImpl->getPaddingNd();
    }
 
    void setDilationNd(Dims dilation) noexcept
    {
        mImpl->setDilationNd(dilation);
    }
 
    Dims getDilationNd() const noexcept
    {
        return mImpl->getDilationNd();
    }
 
    using ILayer::setInput;
 
protected:
    virtual ~IConvolutionLayer() noexcept = default;
    apiv::VConvolutionLayer* mImpl;
};
 
class TRT_DEPRECATED IFullyConnectedLayer : public ILayer
{
public:
    void setNbOutputChannels(int32_t nbOutputs) noexcept
    {
        mImpl->setNbOutputChannels(nbOutputs);
    }
 
    int32_t getNbOutputChannels() const noexcept
    {
        return mImpl->getNbOutputChannels();
    }
 
    void setKernelWeights(Weights weights) noexcept
    {
        mImpl->setKernelWeights(weights);
    }
 
    Weights getKernelWeights() const noexcept
    {
        return mImpl->getKernelWeights();
    }
 
    void setBiasWeights(Weights weights) noexcept
    {
        mImpl->setBiasWeights(weights);
    }
 
    Weights getBiasWeights() const noexcept
    {
        return mImpl->getBiasWeights();
    }
 
    using ILayer::setInput;
 
protected:
    virtual ~IFullyConnectedLayer() noexcept = default;
    apiv::VFullyConnectedLayer* mImpl;
};
 
class IActivationLayer : public ILayer
{
public:
    void setActivationType(ActivationType type) noexcept
    {
        mImpl->setActivationType(type);
    }
 
    ActivationType getActivationType() const noexcept
    {
        return mImpl->getActivationType();
    }
 
    void setAlpha(float alpha) noexcept
    {
        mImpl->setAlpha(alpha);
    }
 
    void setBeta(float beta) noexcept
    {
        mImpl->setBeta(beta);
    }
 
    float getAlpha() const noexcept
    {
        return mImpl->getAlpha();
    }
 
    float getBeta() const noexcept
    {
        return mImpl->getBeta();
    }
 
protected:
    virtual ~IActivationLayer() noexcept = default;
    apiv::VActivationLayer* mImpl;
};
 
enum class PoolingType : int32_t
{
    kMAX = 0,              // Maximum over elements
    kAVERAGE = 1,          // Average over elements. If the tensor is padded, the count includes the padding
    kMAX_AVERAGE_BLEND = 2 // Blending between max and average pooling: (1-blendFactor)*maxPool + blendFactor*avgPool
};
 
namespace impl
{
template <>
struct EnumMaxImpl<PoolingType>
{
    static constexpr int32_t kVALUE = 3;
};
} // namespace impl
 
class IPoolingLayer : public ILayer
{
public:
    void setPoolingType(PoolingType type) noexcept
    {
        mImpl->setPoolingType(type);
    }
 
    PoolingType getPoolingType() const noexcept
    {
        return mImpl->getPoolingType();
    }
 
    TRT_DEPRECATED void setWindowSize(DimsHW windowSize) noexcept
    {
        mImpl->setWindowSize(windowSize);
    }
 
    TRT_DEPRECATED DimsHW getWindowSize() const noexcept
    {
        return mImpl->getWindowSize();
    }
 
    TRT_DEPRECATED void setStride(DimsHW stride) noexcept
    {
        mImpl->setStride(stride);
    }
 
    TRT_DEPRECATED DimsHW getStride() const noexcept
    {
        return mImpl->getStride();
    }
 
    TRT_DEPRECATED void setPadding(DimsHW padding) noexcept
    {
        mImpl->setPadding(padding);
    }
 
    TRT_DEPRECATED DimsHW getPadding() const noexcept
    {
        return mImpl->getPadding();
    }
 
    void setBlendFactor(float blendFactor) noexcept
    {
        mImpl->setBlendFactor(blendFactor);
    }
 
    float getBlendFactor() const noexcept
    {
        return mImpl->getBlendFactor();
    }
 
    void setAverageCountExcludesPadding(bool exclusive) noexcept
    {
        mImpl->setAverageCountExcludesPadding(exclusive);
    }
 
    bool getAverageCountExcludesPadding() const noexcept
    {
        return mImpl->getAverageCountExcludesPadding();
    }
 
    void setPrePadding(Dims padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims padding) noexcept
    {
        mImpl->setPostPadding(padding);
    }
 
    Dims getPostPadding() const noexcept
    {
        return mImpl->getPostPadding();
    }
 
    void setPaddingMode(PaddingMode paddingMode) noexcept
    {
        mImpl->setPaddingMode(paddingMode);
    }
 
    PaddingMode getPaddingMode() const noexcept
    {
        return mImpl->getPaddingMode();
    }
 
    void setWindowSizeNd(Dims windowSize) noexcept
    {
        mImpl->setWindowSizeNd(windowSize);
    }
 
    Dims getWindowSizeNd() const noexcept
    {
        return mImpl->getWindowSizeNd();
    }
 
    void setStrideNd(Dims stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims padding) noexcept
    {
        mImpl->setPaddingNd(padding);
    }
 
    Dims getPaddingNd() const noexcept
    {
        return mImpl->getPaddingNd();
    }
 
protected:
    virtual ~IPoolingLayer() noexcept = default;
    apiv::VPoolingLayer* mImpl;
};
 
class ILRNLayer : public ILayer
{
public:
    void setWindowSize(int32_t windowSize) noexcept
    {
        mImpl->setWindowSize(windowSize);
    }
 
    int32_t getWindowSize() const noexcept
    {
        return mImpl->getWindowSize();
    }
 
    void setAlpha(float alpha) noexcept
    {
        mImpl->setAlpha(alpha);
    }
 
    float getAlpha() const noexcept
    {
        return mImpl->getAlpha();
    }
 
    void setBeta(float beta) noexcept
    {
        mImpl->setBeta(beta);
    }
 
    float getBeta() const noexcept
    {
        return mImpl->getBeta();
    }
 
    void setK(float k) noexcept
    {
        mImpl->setK(k);
    }
 
    float getK() const noexcept
    {
        return mImpl->getK();
    }
 
protected:
    virtual ~ILRNLayer() noexcept = default;
    apiv::VLRNLayer* mImpl;
};
 
enum class ScaleMode : int32_t
{
    kUNIFORM = 0,    
    kCHANNEL = 1,    
    kELEMENTWISE = 2 
};
 
template <>
constexpr inline int32_t EnumMax<ScaleMode>() noexcept
{
    return 3;
}
 
class IScaleLayer : public ILayer
{
public:
    void setMode(ScaleMode mode) noexcept
    {
        mImpl->setMode(mode);
    }
 
    ScaleMode getMode() const noexcept
    {
        return mImpl->getMode();
    }
 
    void setShift(Weights shift) noexcept
    {
        mImpl->setShift(shift);
    }
 
    Weights getShift() const noexcept
    {
        return mImpl->getShift();
    }
 
    void setScale(Weights scale) noexcept
    {
        mImpl->setScale(scale);
    }
 
    Weights getScale() const noexcept
    {
        return mImpl->getScale();
    }
 
    void setPower(Weights power) noexcept
    {
        mImpl->setPower(power);
    }
 
    Weights getPower() const noexcept
    {
        return mImpl->getPower();
    }
 
    int32_t getChannelAxis() const noexcept
    {
        return mImpl->getChannelAxis();
    }
 
    void setChannelAxis(int32_t channelAxis) noexcept
    {
        mImpl->setChannelAxis(channelAxis);
    }
 
protected:
    virtual ~IScaleLayer() noexcept = default;
    apiv::VScaleLayer* mImpl;
};
 
class ISoftMaxLayer : public ILayer
{
public:
    void setAxes(uint32_t axes) noexcept
    {
        mImpl->setAxes(axes);
    }
 
    uint32_t getAxes() const noexcept
    {
        return mImpl->getAxes();
    }
 
protected:
    virtual ~ISoftMaxLayer() noexcept = default;
    apiv::VSoftMaxLayer* mImpl;
};
 
class IConcatenationLayer : public ILayer
{
public:
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
 
protected:
    virtual ~IConcatenationLayer() noexcept = default;
    apiv::VConcatenationLayer* mImpl;
};
 
class IDeconvolutionLayer : public ILayer
{
public:
    TRT_DEPRECATED void setKernelSize(DimsHW kernelSize) noexcept
    {
        mImpl->setKernelSize(kernelSize);
    }
 
    TRT_DEPRECATED DimsHW getKernelSize() const noexcept
    {
        return mImpl->getKernelSize();
    }
 
    void setNbOutputMaps(int32_t nbOutputMaps) noexcept
    {
        mImpl->setNbOutputMaps(nbOutputMaps);
    }
 
    int32_t getNbOutputMaps() const noexcept
    {
        return mImpl->getNbOutputMaps();
    }
 
    TRT_DEPRECATED void setStride(DimsHW stride) noexcept
    {
        mImpl->setStride(stride);
    }
 
    TRT_DEPRECATED DimsHW getStride() const noexcept
    {
        return mImpl->getStride();
    }
 
    TRT_DEPRECATED void setPadding(DimsHW padding) noexcept
    {
        mImpl->setPadding(padding);
    }
 
    TRT_DEPRECATED DimsHW getPadding() const noexcept
    {
        return mImpl->getPadding();
    }
 
    void setNbGroups(int32_t nbGroups) noexcept
    {
        mImpl->setNbGroups(nbGroups);
    }
 
    int32_t getNbGroups() const noexcept
    {
        return mImpl->getNbGroups();
    }
 
    void setKernelWeights(Weights weights) noexcept
    {
        mImpl->setKernelWeights(weights);
    }
 
    Weights getKernelWeights() const noexcept
    {
        return mImpl->getKernelWeights();
    }
 
    void setBiasWeights(Weights weights) noexcept
    {
        mImpl->setBiasWeights(weights);
    }
 
    Weights getBiasWeights() const noexcept
    {
        return mImpl->getBiasWeights();
    }
 
    void setPrePadding(Dims padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims padding) noexcept
    {
        mImpl->setPostPadding(padding);
    }
 
    Dims getPostPadding() const noexcept
    {
        return mImpl->getPostPadding();
    }
 
    void setPaddingMode(PaddingMode paddingMode) noexcept
    {
        mImpl->setPaddingMode(paddingMode);
    }
 
    PaddingMode getPaddingMode() const noexcept
    {
        return mImpl->getPaddingMode();
    }
 
    void setKernelSizeNd(Dims kernelSize) noexcept
    {
        mImpl->setKernelSizeNd(kernelSize);
    }
 
    Dims getKernelSizeNd() const noexcept
    {
        return mImpl->getKernelSizeNd();
    }
 
    void setStrideNd(Dims stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims padding) noexcept
    {
        mImpl->setPaddingNd(padding);
    }
 
    Dims getPaddingNd() const noexcept
    {
        return mImpl->getPaddingNd();
    }
 
    using ILayer::setInput;
 
    void setDilationNd(Dims dilation) noexcept
    {
        mImpl->setDilationNd(dilation);
    }
 
    Dims getDilationNd() const noexcept
    {
        return mImpl->getDilationNd();
    }
 
protected:
    virtual ~IDeconvolutionLayer() noexcept = default;
    apiv::VDeconvolutionLayer* mImpl;
};
 
enum class ElementWiseOperation : int32_t
{
    kSUM = 0,       
    kPROD = 1,      
    kMAX = 2,       
    kMIN = 3,       
    kSUB = 4,       
    kDIV = 5,       
    kPOW = 6,       
    kFLOOR_DIV = 7, 
    kAND = 8,       
    kOR = 9,        
    kXOR = 10,      
    kEQUAL = 11,    
    kGREATER = 12,  
    kLESS = 13      
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ElementWiseOperation>
{
    static constexpr int32_t kVALUE = 14;
};
} // namespace impl
 
class IElementWiseLayer : public ILayer
{
public:
    void setOperation(ElementWiseOperation op) noexcept
    {
        return mImpl->setOperation(op);
    }
 
    ElementWiseOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
protected:
    apiv::VElementWiseLayer* mImpl;
    virtual ~IElementWiseLayer() noexcept = default;
};
 
enum class GatherMode : int32_t
{
    kDEFAULT = 0, 
    kELEMENT = 1, 
    kND = 2       
};
 
template <>
constexpr inline int32_t EnumMax<GatherMode>() noexcept
{
    return 3;
}
 
class IGatherLayer : public ILayer
{
public:
    void setGatherAxis(int32_t axis) noexcept
    {
        mImpl->setGatherAxis(axis);
    }
 
    int32_t getGatherAxis() const noexcept
    {
        return mImpl->getGatherAxis();
    }
 
    void setNbElementWiseDims(int32_t elementWiseDims) noexcept
    {
        mImpl->setNbElementWiseDims(elementWiseDims);
    }
 
    int32_t getNbElementWiseDims() const noexcept
    {
        return mImpl->getNbElementWiseDims();
    }
 
    void setMode(GatherMode mode) noexcept
    {
        mImpl->setMode(mode);
    }
 
    GatherMode getMode() const noexcept
    {
        return mImpl->getMode();
    }
 
protected:
    apiv::VGatherLayer* mImpl;
    virtual ~IGatherLayer() noexcept = default;
};
 
enum class RNNOperation : int32_t
{
    kRELU = 0, 
    kTANH = 1, 
    kLSTM = 2, 
    kGRU = 3   
};
 
template <>
constexpr inline int32_t EnumMax<RNNOperation>() noexcept
{
    return 4;
}
 
enum class RNNDirection : int32_t
{
    kUNIDIRECTION = 0, 
    kBIDIRECTION = 1   
};
 
template <>
constexpr inline int32_t EnumMax<RNNDirection>() noexcept
{
    return 2;
}
 
enum class RNNInputMode : int32_t
{
    kLINEAR = 0, 
    kSKIP = 1    
};
 
template <>
constexpr inline int32_t EnumMax<RNNInputMode>() noexcept
{
    return 2;
}
 
enum class RNNGateType : int32_t
{
    kINPUT = 0,  
    kOUTPUT = 1, 
    kFORGET = 2, 
    kUPDATE = 3, 
    kRESET = 4,  
    kCELL = 5,   
    kHIDDEN = 6  
};
 
template <>
constexpr inline int32_t EnumMax<RNNGateType>() noexcept
{
    return 7;
}
 
class TRT_DEPRECATED IRNNv2Layer : public ILayer
{
public:
    int32_t getLayerCount() const noexcept
    {
        return mImpl->getLayerCount();
    } 
    int32_t getHiddenSize() const noexcept
    {
        return mImpl->getHiddenSize();
    } 
    int32_t getMaxSeqLength() const noexcept
    {
        return mImpl->getMaxSeqLength();
    } 
    int32_t getDataLength() const noexcept
    {
        return mImpl->getDataLength();
    } 
 
    void setSequenceLengths(ITensor& seqLengths) noexcept
    {
        return mImpl->setSequenceLengths(seqLengths);
    }
 
    ITensor* getSequenceLengths() const noexcept
    {
        return mImpl->getSequenceLengths();
    }
 
    void setOperation(RNNOperation op) noexcept
    {
        mImpl->setOperation(op);
    }
 
    RNNOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
    void setInputMode(RNNInputMode op) noexcept
    {
        mImpl->setInputMode(op);
    }
 
    RNNInputMode getInputMode() const noexcept
    {
        return mImpl->getInputMode();
    }
 
    void setDirection(RNNDirection op) noexcept
    {
        mImpl->setDirection(op);
    }
 
    RNNDirection getDirection() const noexcept
    {
        return mImpl->getDirection();
    }
 
    void setWeightsForGate(int32_t layerIndex, RNNGateType gate, bool isW, Weights weights) noexcept
    {
        mImpl->setWeightsForGate(layerIndex, gate, isW, weights);
    }
 
    Weights getWeightsForGate(int32_t layerIndex, RNNGateType gate, bool isW) const noexcept
    {
        return mImpl->getWeightsForGate(layerIndex, gate, isW);
    }
 
    void setBiasForGate(int32_t layerIndex, RNNGateType gate, bool isW, Weights bias) noexcept
    {
        mImpl->setBiasForGate(layerIndex, gate, isW, bias);
    }
 
    Weights getBiasForGate(int32_t layerIndex, RNNGateType gate, bool isW) const noexcept
    {
        return mImpl->getBiasForGate(layerIndex, gate, isW);
    }
 
    void setHiddenState(ITensor& hidden) noexcept
    {
        mImpl->setHiddenState(hidden);
    }
 
    ITensor* getHiddenState() const noexcept
    {
        return mImpl->getHiddenState();
    }
 
    void setCellState(ITensor& cell) noexcept
    {
        mImpl->setCellState(cell);
    }
 
    ITensor* getCellState() const noexcept
    {
        return mImpl->getCellState();
    }
 
protected:
    apiv::VRNNv2Layer* mImpl;
    virtual ~IRNNv2Layer() noexcept = default;
};
 
class IPluginV2Layer : public ILayer
{
public:
    IPluginV2& getPlugin() noexcept
    {
        return mImpl->getPlugin();
    }
 
protected:
    apiv::VPluginV2Layer* mImpl;
    virtual ~IPluginV2Layer() noexcept = default;
};
 
enum class UnaryOperation : int32_t
{
    kEXP = 0,    
    kLOG = 1,    
    kSQRT = 2,   
    kRECIP = 3,  
    kABS = 4,    
    kNEG = 5,    
    kSIN = 6,    
    kCOS = 7,    
    kTAN = 8,    
    kSINH = 9,   
    kCOSH = 10,  
    kASIN = 11,  
    kACOS = 12,  
    kATAN = 13,  
    kASINH = 14, 
    kACOSH = 15, 
    kATANH = 16, 
    kCEIL = 17,  
    kFLOOR = 18, 
    kERF = 19,   
    kNOT = 20,   
    kSIGN = 21,  
    kROUND = 22  
};
 
template <>
constexpr inline int32_t EnumMax<UnaryOperation>() noexcept
{
    return 23;
}
 
class IUnaryLayer : public ILayer
{
public:
    void setOperation(UnaryOperation op) noexcept
    {
        mImpl->setOperation(op);
    }
 
    UnaryOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
protected:
    apiv::VUnaryLayer* mImpl;
    virtual ~IUnaryLayer() noexcept = default;
};
 
enum class ReduceOperation : int32_t
{
    kSUM = 0,
    kPROD = 1,
    kMAX = 2,
    kMIN = 3,
    kAVG = 4
};
 
template <>
constexpr inline int32_t EnumMax<ReduceOperation>() noexcept
{
    return 5;
}
 
class IReduceLayer : public ILayer
{
public:
    void setOperation(ReduceOperation op) noexcept
    {
        mImpl->setOperation(op);
    }
 
    ReduceOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
    void setReduceAxes(uint32_t reduceAxes) noexcept
    {
        mImpl->setReduceAxes(reduceAxes);
    }
 
    uint32_t getReduceAxes() const noexcept
    {
        return mImpl->getReduceAxes();
    }
 
    void setKeepDimensions(bool keepDimensions) noexcept
    {
        mImpl->setKeepDimensions(keepDimensions);
    }
 
    bool getKeepDimensions() const noexcept
    {
        return mImpl->getKeepDimensions();
    }
 
protected:
    apiv::VReduceLayer* mImpl;
    virtual ~IReduceLayer() noexcept = default;
};
 
class IPaddingLayer : public ILayer
{
public:
    TRT_DEPRECATED void setPrePadding(DimsHW padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    TRT_DEPRECATED DimsHW getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    TRT_DEPRECATED void setPostPadding(DimsHW padding) noexcept
    {
        mImpl->setPostPadding(padding);
    }
 
    TRT_DEPRECATED DimsHW getPostPadding() const noexcept
    {
        return mImpl->getPostPadding();
    }
 
    void setPrePaddingNd(Dims padding) noexcept
    {
        mImpl->setPrePaddingNd(padding);
    }
 
    Dims getPrePaddingNd() const noexcept
    {
        return mImpl->getPrePaddingNd();
    }
 
    void setPostPaddingNd(Dims padding) noexcept
    {
        mImpl->setPostPaddingNd(padding);
    }
 
    Dims getPostPaddingNd() const noexcept
    {
        return mImpl->getPostPaddingNd();
    }
 
protected:
    apiv::VPaddingLayer* mImpl;
    virtual ~IPaddingLayer() noexcept = default;
};
 
struct Permutation
{
    int32_t order[Dims::MAX_DIMS];
};
 
class IShuffleLayer : public ILayer
{
public:
    void setFirstTranspose(Permutation permutation) noexcept
    {
        mImpl->setFirstTranspose(permutation);
    }
 
    Permutation getFirstTranspose() const noexcept
    {
        return mImpl->getFirstTranspose();
    }
 
    void setReshapeDimensions(Dims dimensions) noexcept
    {
        mImpl->setReshapeDimensions(dimensions);
    }
 
    Dims getReshapeDimensions() const noexcept
    {
        return mImpl->getReshapeDimensions();
    }
 
    //
    using ILayer::setInput;
 
    void setSecondTranspose(Permutation permutation) noexcept
    {
        mImpl->setSecondTranspose(permutation);
    }
 
    Permutation getSecondTranspose() const noexcept
    {
        return mImpl->getSecondTranspose();
    }
 
    void setZeroIsPlaceholder(bool zeroIsPlaceholder) noexcept
    {
        return mImpl->setZeroIsPlaceholder(zeroIsPlaceholder);
    }
 
    bool getZeroIsPlaceholder() const noexcept
    {
        return mImpl->getZeroIsPlaceholder();
    }
 
protected:
    apiv::VShuffleLayer* mImpl;
    virtual ~IShuffleLayer() noexcept = default;
};
 
enum class SliceMode : int32_t
{
    kDEFAULT = 0, 
    kWRAP = 1,    
    kCLAMP = 2,   
    kFILL = 3,    
    kREFLECT = 4, 
};
 
template <>
constexpr inline int32_t EnumMax<SliceMode>() noexcept
{
    return 5;
}
 
class ISliceLayer : public ILayer
{
public:
    void setStart(Dims start) noexcept
    {
        mImpl->setStart(start);
    }
 
    Dims getStart() const noexcept
    {
        return mImpl->getStart();
    }
 
    void setSize(Dims size) noexcept
    {
        return mImpl->setSize(size);
    }
 
    Dims getSize() const noexcept
    {
        return mImpl->getSize();
    }
 
    void setStride(Dims stride) noexcept
    {
        mImpl->setStride(stride);
    }
 
    Dims getStride() const noexcept
    {
        return mImpl->getStride();
    }
 
    void setMode(SliceMode mode) noexcept
    {
        mImpl->setMode(mode);
    }
 
    SliceMode getMode() const noexcept
    {
        return mImpl->getMode();
    }
 
    using ILayer::setInput;
 
protected:
    apiv::VSliceLayer* mImpl;
    virtual ~ISliceLayer() noexcept = default;
};
 
class IShapeLayer : public ILayer
{
protected:
    apiv::VShapeLayer* mImpl;
    virtual ~IShapeLayer() noexcept = default;
};
 
enum class TopKOperation : int32_t
{
    kMAX = 0, 
    kMIN = 1, 
};
 
template <>
constexpr inline int32_t EnumMax<TopKOperation>() noexcept
{
    return 2;
}
 
class ITopKLayer : public ILayer
{
public:
    void setOperation(TopKOperation op) noexcept
    {
        mImpl->setOperation(op);
    }
 
    TopKOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
    void setK(int32_t k) noexcept
    {
        mImpl->setK(k);
    }
 
    int32_t getK() const noexcept
    {
        return mImpl->getK();
    }
 
    void setReduceAxes(uint32_t reduceAxes) noexcept
    {
        mImpl->setReduceAxes(reduceAxes);
    }
 
    uint32_t getReduceAxes() const noexcept
    {
        return mImpl->getReduceAxes();
    }
 
protected:
    apiv::VTopKLayer* mImpl;
    virtual ~ITopKLayer() noexcept = default;
};
 
enum class MatrixOperation : int32_t
{
    kNONE,
 
    kTRANSPOSE,
 
    kVECTOR
};
 
template <>
constexpr inline int32_t EnumMax<MatrixOperation>() noexcept
{
    return 3;
}
 
class IMatrixMultiplyLayer : public ILayer
{
public:
    void setOperation(int32_t index, MatrixOperation op) noexcept
    {
        mImpl->setOperation(index, op);
    }
 
    MatrixOperation getOperation(int32_t index) const noexcept
    {
        return mImpl->getOperation(index);
    }
 
protected:
    apiv::VMatrixMultiplyLayer* mImpl;
    virtual ~IMatrixMultiplyLayer() noexcept = default;
};
 
class IRaggedSoftMaxLayer : public ILayer
{
protected:
    apiv::VRaggedSoftMaxLayer* mImpl;
    virtual ~IRaggedSoftMaxLayer() noexcept = default;
};
 
class IIdentityLayer : public ILayer
{
protected:
    apiv::VIdentityLayer* mImpl;
    virtual ~IIdentityLayer() noexcept = default;
};
 
class IConstantLayer : public ILayer
{
public:
    void setWeights(Weights weights) noexcept
    {
        mImpl->setWeights(weights);
    }
 
    Weights getWeights() const noexcept
    {
        return mImpl->getWeights();
    }
 
    void setDimensions(Dims dimensions) noexcept
    {
        mImpl->setDimensions(dimensions);
    }
 
    Dims getDimensions() const noexcept
    {
        return mImpl->getDimensions();
    }
 
protected:
    apiv::VConstantLayer* mImpl;
    virtual ~IConstantLayer() noexcept = default;
};
 
class IParametricReLULayer : public ILayer
{
protected:
    apiv::VParametricReLULayer* mImpl;
    virtual ~IParametricReLULayer() noexcept = default;
};
 
enum class ResizeMode : int32_t
{
    kNEAREST = 0, 
    kLINEAR = 1   
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ResizeMode>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
enum class ResizeCoordinateTransformation : int32_t
{
    kALIGN_CORNERS = 0,
 
    kASYMMETRIC = 1,
 
    kHALF_PIXEL = 2,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ResizeCoordinateTransformation>
{
    static constexpr int32_t kVALUE = 3;
};
} // namespace impl
 
enum class ResizeSelector : int32_t
{
    kFORMULA = 0,
 
    kUPPER = 1,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ResizeSelector>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
enum class ResizeRoundMode : int32_t
{
    kHALF_UP = 0,
 
    kHALF_DOWN = 1,
 
    kFLOOR = 2,
 
    kCEIL = 3,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ResizeRoundMode>
{
    static constexpr int32_t kVALUE = 4;
};
} // namespace impl
 
class IResizeLayer : public ILayer
{
public:
    void setOutputDimensions(Dims dimensions) noexcept
    {
        return mImpl->setOutputDimensions(dimensions);
    }
 
    Dims getOutputDimensions() const noexcept
    {
        return mImpl->getOutputDimensions();
    }
 
    void setScales(float const* scales, int32_t nbScales) noexcept
    {
        mImpl->setScales(scales, nbScales);
    }
 
    int32_t getScales(int32_t size, float* scales) const noexcept
    {
        return mImpl->getScales(size, scales);
    }
 
    void setResizeMode(ResizeMode resizeMode) noexcept
    {
        mImpl->setResizeMode(resizeMode);
    }
 
    ResizeMode getResizeMode() const noexcept
    {
        return mImpl->getResizeMode();
    }
 
    TRT_DEPRECATED void setAlignCorners(bool alignCorners) noexcept
    {
        mImpl->setAlignCorners(alignCorners);
    }
 
    TRT_DEPRECATED bool getAlignCorners() const noexcept
    {
        return mImpl->getAlignCorners();
    }
 
    using ILayer::setInput;
 
    void setCoordinateTransformation(ResizeCoordinateTransformation coordTransform) noexcept
    {
        mImpl->setCoordinateTransformation(coordTransform);
    }
 
    ResizeCoordinateTransformation getCoordinateTransformation() const noexcept
    {
        return mImpl->getCoordinateTransformation();
    }
 
    void setSelectorForSinglePixel(ResizeSelector selector) noexcept
    {
        mImpl->setSelectorForSinglePixel(selector);
    }
 
    ResizeSelector getSelectorForSinglePixel() const noexcept
    {
        return mImpl->getSelectorForSinglePixel();
    }
 
    void setNearestRounding(ResizeRoundMode value) noexcept
    {
        mImpl->setNearestRounding(value);
    }
 
    ResizeRoundMode getNearestRounding() const noexcept
    {
        return mImpl->getNearestRounding();
    }
 
protected:
    virtual ~IResizeLayer() noexcept = default;
    apiv::VResizeLayer* mImpl;
};
 
enum class LoopOutput : int32_t
{
    kLAST_VALUE = 0,
 
    kCONCATENATE = 1,
 
    kREVERSE = 2
};
 
template <>
constexpr inline int32_t EnumMax<LoopOutput>() noexcept
{
    return 3;
}
 
enum class TripLimit : int32_t
{
 
    kCOUNT = 0, 
    kWHILE = 1  
};
 
template <>
constexpr inline int32_t EnumMax<TripLimit>() noexcept
{
    return 2;
}
 
class ILoop;
 
class ILoopBoundaryLayer : public ILayer
{
public:
    ILoop* getLoop() const noexcept
    {
        return mBoundary->getLoop();
    }
 
protected:
    virtual ~ILoopBoundaryLayer() noexcept = default;
    apiv::VLoopBoundaryLayer* mBoundary;
};
 
class IIfConditionalBoundaryLayer : public ILayer
{
public:
    IIfConditional* getConditional() const noexcept
    {
        return mBoundary->getConditional();
    }
 
protected:
    virtual ~IIfConditionalBoundaryLayer() noexcept = default;
    apiv::VConditionalBoundaryLayer* mBoundary;
};
 
class IConditionLayer : public IIfConditionalBoundaryLayer
{
public:
protected:
    virtual ~IConditionLayer() noexcept = default;
    apiv::VConditionLayer* mImpl;
};
 
class IIfConditionalOutputLayer : public IIfConditionalBoundaryLayer
{
public:
protected:
    virtual ~IIfConditionalOutputLayer() noexcept = default;
    apiv::VConditionalOutputLayer* mImpl;
};
 
class IIfConditionalInputLayer : public IIfConditionalBoundaryLayer
{
public:
protected:
    virtual ~IIfConditionalInputLayer() noexcept = default;
    apiv::VConditionalInputLayer* mImpl;
};
 
class IIfConditional : public INoCopy
{
public:
    IConditionLayer* setCondition(ITensor& condition) noexcept
    {
        return mImpl->setCondition(condition);
    }
 
    IIfConditionalOutputLayer* addOutput(ITensor& trueSubgraphOutput, ITensor& falseSubgraphOutput) noexcept
    {
        return mImpl->addOutput(trueSubgraphOutput, falseSubgraphOutput);
    }
 
    IIfConditionalInputLayer* addInput(ITensor& input) noexcept
    {
        return mImpl->addInput(input);
    }
 
    void setName(char const* name) noexcept
    {
        mImpl->setName(name);
    }
 
    char const* getName() const noexcept
    {
        return mImpl->getName();
    }
 
protected:
    virtual ~IIfConditional() noexcept = default;
    apiv::VIfConditional* mImpl;
};
 
 
class IRecurrenceLayer : public ILoopBoundaryLayer
{
public:
    //
    using ILayer::setInput;
 
protected:
    virtual ~IRecurrenceLayer() noexcept = default;
    apiv::VRecurrenceLayer* mImpl;
};
 
class ILoopOutputLayer : public ILoopBoundaryLayer
{
public:
    LoopOutput getLoopOutput() const noexcept
    {
        return mImpl->getLoopOutput();
    }
 
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
 
    //
    using ILayer::setInput;
 
protected:
    virtual ~ILoopOutputLayer() noexcept = default;
    apiv::VLoopOutputLayer* mImpl;
};
 
class ITripLimitLayer : public ILoopBoundaryLayer
{
public:
    TripLimit getTripLimit() const noexcept
    {
        return mImpl->getTripLimit();
    }
 
protected:
    virtual ~ITripLimitLayer() noexcept = default;
    apiv::VTripLimitLayer* mImpl;
};
 
class IIteratorLayer : public ILoopBoundaryLayer
{
public:
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
 
    void setReverse(bool reverse) noexcept
    {
        mImpl->setReverse(reverse);
    }
 
    bool getReverse() const noexcept
    {
        return mImpl->getReverse();
    }
 
protected:
    virtual ~IIteratorLayer() noexcept = default;
    apiv::VIteratorLayer* mImpl;
};
 
class ILoop : public INoCopy
{
public:
    IRecurrenceLayer* addRecurrence(ITensor& initialValue) noexcept
    {
        return mImpl->addRecurrence(initialValue);
    }
 
    ITripLimitLayer* addTripLimit(ITensor& tensor, TripLimit limit) noexcept
    {
        return mImpl->addTripLimit(tensor, limit);
    }
 
    IIteratorLayer* addIterator(ITensor& tensor, int32_t axis = 0, bool reverse = false) noexcept
    {
        return mImpl->addIterator(tensor, axis, reverse);
    }
 
    ILoopOutputLayer* addLoopOutput(ITensor& tensor, LoopOutput outputKind, int32_t axis = 0) noexcept
    {
        return mImpl->addLoopOutput(tensor, outputKind, axis);
    }
 
    void setName(char const* name) noexcept
    {
        mImpl->setName(name);
    }
 
    char const* getName() const noexcept
    {
        return mImpl->getName();
    }
 
protected:
    virtual ~ILoop() noexcept = default;
    apiv::VLoop* mImpl;
};
 
class ISelectLayer : public ILayer
{
protected:
    virtual ~ISelectLayer() noexcept = default;
    apiv::VSelectLayer* mImpl;
};
 
class IAssertionLayer : public ILayer
{
public:
    void setMessage(char const* message) noexcept
    {
        mImpl->setMessage(message);
    }
 
    char const* getMessage() const noexcept
    {
        return mImpl->getMessage();
    }
 
protected:
    virtual ~IAssertionLayer() noexcept = default;
 
    apiv::VAssertionLayer* mImpl;
};
 
enum class FillOperation : int32_t
{
    kLINSPACE = 0,      
    kRANDOM_UNIFORM = 1 
};
 
template <>
constexpr inline int32_t EnumMax<FillOperation>() noexcept
{
    return 2;
}
 
class IFillLayer : public ILayer
{
public:
    //
    void setDimensions(Dims dimensions) noexcept
    {
        mImpl->setDimensions(dimensions);
    }
 
    Dims getDimensions() const noexcept
    {
        return mImpl->getDimensions();
    }
 
    void setOperation(FillOperation op) noexcept
    {
        mImpl->setOperation(op);
    }
 
    FillOperation getOperation() const noexcept
    {
        return mImpl->getOperation();
    }
 
    //
    void setAlpha(double alpha) noexcept
    {
        mImpl->setAlpha(alpha);
    }
 
    double getAlpha() const noexcept
    {
        return mImpl->getAlpha();
    }
 
    void setBeta(double beta) noexcept
    {
        mImpl->setBeta(beta);
    }
 
    double getBeta() const noexcept
    {
        return mImpl->getBeta();
    }
 
    using ILayer::setInput;
 
protected:
    virtual ~IFillLayer() noexcept = default;
    apiv::VFillLayer* mImpl;
};
 
class IQuantizeLayer : public ILayer
{
public:
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
protected:
    virtual ~IQuantizeLayer() noexcept = default;
    apiv::VQuantizeLayer* mImpl;
};
 
class IDequantizeLayer : public ILayer
{
public:
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
protected:
    virtual ~IDequantizeLayer() noexcept = default;
    apiv::VDequantizeLayer* mImpl;
};
 
class IEinsumLayer : public ILayer
{
public:
    bool setEquation(char const* equation) noexcept
    {
        return mImpl->setEquation(equation);
    }
 
    char const* getEquation() const noexcept
    {
        return mImpl->getEquation();
    }
 
protected:
    virtual ~IEinsumLayer() noexcept = default;
    apiv::VEinsumLayer* mImpl;
};
 
enum class ScatterMode : int32_t
{
    kELEMENT = 0, 
    kND = 1,      
};
 
template <>
constexpr inline int32_t EnumMax<ScatterMode>() noexcept
{
    return 2;
}
 
class IScatterLayer : public ILayer
{
public:
    void setMode(ScatterMode mode) noexcept
    {
        mImpl->setMode(mode);
    }
 
    ScatterMode getMode() const noexcept
    {
        return mImpl->getMode();
    }
 
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
 
protected:
    apiv::VScatterLayer* mImpl;
    virtual ~IScatterLayer() noexcept = default;
}; // class IScatterLayer
 
class INetworkDefinition : public INoCopy
{
public:
    virtual ~INetworkDefinition() noexcept = default;
 
    ITensor* addInput(char const* name, DataType type, Dims dimensions) noexcept
    {
        return mImpl->addInput(name, type, dimensions);
    }
 
    void markOutput(ITensor& tensor) noexcept
    {
        mImpl->markOutput(tensor);
    }
 
    TRT_DEPRECATED IConvolutionLayer* addConvolution(
        ITensor& input, int32_t nbOutputMaps, DimsHW kernelSize, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addConvolution(input, nbOutputMaps, kernelSize, kernelWeights, biasWeights);
    }
 
    TRT_DEPRECATED IFullyConnectedLayer* addFullyConnected(
        ITensor& input, int32_t nbOutputs, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addFullyConnected(input, nbOutputs, kernelWeights, biasWeights);
    }
 
    IActivationLayer* addActivation(ITensor& input, ActivationType type) noexcept
    {
        return mImpl->addActivation(input, type);
    }
 
    TRT_DEPRECATED IPoolingLayer* addPooling(ITensor& input, PoolingType type, DimsHW windowSize) noexcept
    {
        return mImpl->addPooling(input, type, windowSize);
    }
 
    ILRNLayer* addLRN(ITensor& input, int32_t window, float alpha, float beta, float k) noexcept
    {
        return mImpl->addLRN(input, window, alpha, beta, k);
    }
 
    IScaleLayer* addScale(ITensor& input, ScaleMode mode, Weights shift, Weights scale, Weights power) noexcept
    {
        return mImpl->addScale(input, mode, shift, scale, power);
    }
 
    ISoftMaxLayer* addSoftMax(ITensor& input) noexcept
    {
        return mImpl->addSoftMax(input);
    }
 
    IConcatenationLayer* addConcatenation(ITensor* const* inputs, int32_t nbInputs) noexcept
    {
        return mImpl->addConcatenation(inputs, nbInputs);
    }
 
    TRT_DEPRECATED IDeconvolutionLayer* addDeconvolution(
        ITensor& input, int32_t nbOutputMaps, DimsHW kernelSize, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addDeconvolution(input, nbOutputMaps, kernelSize, kernelWeights, biasWeights);
    }
 
    IElementWiseLayer* addElementWise(ITensor& input1, ITensor& input2, ElementWiseOperation op) noexcept
    {
        return mImpl->addElementWise(input1, input2, op);
    }
 
    IUnaryLayer* addUnary(ITensor& input, UnaryOperation operation) noexcept
    {
        return mImpl->addUnary(input, operation);
    }
 
    TRT_DEPRECATED IPaddingLayer* addPadding(ITensor& input, DimsHW prePadding, DimsHW postPadding) noexcept
    {
        return mImpl->addPadding(input, prePadding, postPadding);
    }
 
    IShuffleLayer* addShuffle(ITensor& input) noexcept
    {
        return mImpl->addShuffle(input);
    }
 
    int32_t getNbLayers() const noexcept
    {
        return mImpl->getNbLayers();
    }
 
    ILayer* getLayer(int32_t index) const noexcept
    {
        return mImpl->getLayer(index);
    }
 
    int32_t getNbInputs() const noexcept
    {
        return mImpl->getNbInputs();
    }
 
    ITensor* getInput(int32_t index) const noexcept
    {
        return mImpl->getInput(index);
    }
 
    int32_t getNbOutputs() const noexcept
    {
        return mImpl->getNbOutputs();
    }
 
    ITensor* getOutput(int32_t index) const noexcept
    {
        return mImpl->getOutput(index);
    }
 
    TRT_DEPRECATED void destroy() noexcept
    {
        delete this;
    }
 
    IReduceLayer* addReduce(
        ITensor& input, ReduceOperation operation, uint32_t reduceAxes, bool keepDimensions) noexcept
    {
        return mImpl->addReduce(input, operation, reduceAxes, keepDimensions);
    }
 
    ITopKLayer* addTopK(ITensor& input, TopKOperation op, int32_t k, uint32_t reduceAxes) noexcept
    {
        return mImpl->addTopK(input, op, k, reduceAxes);
    }
 
    IGatherLayer* addGather(ITensor& data, ITensor& indices, int32_t axis) noexcept
    {
        return mImpl->addGather(data, indices, axis);
    }
 
    IGatherLayer* addGatherV2(ITensor& data, ITensor& indices, GatherMode mode)
    {
        return mImpl->addGatherV2(data, indices, mode);
    }
 
    IRaggedSoftMaxLayer* addRaggedSoftMax(ITensor& input, ITensor& bounds) noexcept
    {
        return mImpl->addRaggedSoftMax(input, bounds);
    }
 
    IMatrixMultiplyLayer* addMatrixMultiply(
        ITensor& input0, MatrixOperation op0, ITensor& input1, MatrixOperation op1) noexcept
    {
        return mImpl->addMatrixMultiply(input0, op0, input1, op1);
    }
 
    IConstantLayer* addConstant(Dims dimensions, Weights weights) noexcept
    {
        return mImpl->addConstant(dimensions, weights);
    }
 
    TRT_DEPRECATED IRNNv2Layer* addRNNv2(
        ITensor& input, int32_t layerCount, int32_t hiddenSize, int32_t maxSeqLen, RNNOperation op) noexcept
    {
        return mImpl->addRNNv2(input, layerCount, hiddenSize, maxSeqLen, op);
    }
 
    IIdentityLayer* addIdentity(ITensor& input) noexcept
    {
        return mImpl->addIdentity(input);
    }
 
    void removeTensor(ITensor& tensor) noexcept
    {
        mImpl->removeTensor(tensor);
    }
 
    void unmarkOutput(ITensor& tensor) noexcept
    {
        mImpl->unmarkOutput(tensor);
    }
 
    IPluginV2Layer* addPluginV2(ITensor* const* inputs, int32_t nbInputs, IPluginV2& plugin) noexcept
    {
        return mImpl->addPluginV2(inputs, nbInputs, plugin);
    }
 
    ISliceLayer* addSlice(ITensor& input, Dims start, Dims size, Dims stride) noexcept
    {
        return mImpl->addSlice(input, start, size, stride);
    }
 
    void setName(char const* name) noexcept
    {
        mImpl->setName(name);
    }
 
    char const* getName() const noexcept
    {
        return mImpl->getName();
    }
 
    IShapeLayer* addShape(ITensor& input) noexcept
    {
        return mImpl->addShape(input);
    }
 
    bool hasImplicitBatchDimension() const noexcept
    {
        return mImpl->hasImplicitBatchDimension();
    }
 
    bool markOutputForShapes(ITensor& tensor) noexcept
    {
        return mImpl->markOutputForShapes(tensor);
    }
 
    bool unmarkOutputForShapes(ITensor& tensor) noexcept
    {
        return mImpl->unmarkOutputForShapes(tensor);
    }
 
    IParametricReLULayer* addParametricReLU(ITensor& input, ITensor& slope) noexcept
    {
        return mImpl->addParametricReLU(input, slope);
    }
 
    IConvolutionLayer* addConvolutionNd(
        ITensor& input, int32_t nbOutputMaps, Dims kernelSize, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addConvolutionNd(input, nbOutputMaps, kernelSize, kernelWeights, biasWeights);
    }
 
    IPoolingLayer* addPoolingNd(ITensor& input, PoolingType type, Dims windowSize) noexcept
    {
        return mImpl->addPoolingNd(input, type, windowSize);
    }
 
    //
    IDeconvolutionLayer* addDeconvolutionNd(
        ITensor& input, int32_t nbOutputMaps, Dims kernelSize, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addDeconvolutionNd(input, nbOutputMaps, kernelSize, kernelWeights, biasWeights);
    }
 
    IScaleLayer* addScaleNd(
        ITensor& input, ScaleMode mode, Weights shift, Weights scale, Weights power, int32_t channelAxis) noexcept
    {
        return mImpl->addScaleNd(input, mode, shift, scale, power, channelAxis);
    }
 
    IResizeLayer* addResize(ITensor& input) noexcept
    {
        return mImpl->addResize(input);
    }
 
    TRT_DEPRECATED bool hasExplicitPrecision() const noexcept
    {
        return mImpl->hasExplicitPrecision();
    }
 
    ILoop* addLoop() noexcept
    {
        return mImpl->addLoop();
    }
 
    ISelectLayer* addSelect(ITensor& condition, ITensor& thenInput, ITensor& elseInput) noexcept
    {
        return mImpl->addSelect(condition, thenInput, elseInput);
    }
 
    IAssertionLayer* addAssertion(ITensor& condition, char const* message) noexcept
    {
        return mImpl->addAssertion(condition, message);
    }
 
    IFillLayer* addFill(Dims dimensions, FillOperation op) noexcept
    {
        return mImpl->addFill(dimensions, op);
    }
 
    TRT_DEPRECATED IPaddingLayer* addPaddingNd(ITensor& input, Dims prePadding, Dims postPadding) noexcept
    {
        return mImpl->addPaddingNd(input, prePadding, postPadding);
    }
 
    bool setWeightsName(Weights weights, char const* name) noexcept
    {
        return mImpl->setWeightsName(weights, name);
    }
 
    //
    void setErrorRecorder(IErrorRecorder* recorder) noexcept
    {
        mImpl->setErrorRecorder(recorder);
    }
 
    IErrorRecorder* getErrorRecorder() const noexcept
    {
        return mImpl->getErrorRecorder();
    }
 
    IDequantizeLayer* addDequantize(ITensor& input, ITensor& scale) noexcept
    {
        return mImpl->addDequantize(input, scale);
    }
 
    IScatterLayer* addScatter(ITensor& data, ITensor& indices, ITensor& updates, ScatterMode mode) noexcept
    {
        return mImpl->addScatter(data, indices, updates, mode);
    }
 
    IQuantizeLayer* addQuantize(ITensor& input, ITensor& scale) noexcept
    {
        return mImpl->addQuantize(input, scale);
    }
 
    IIfConditional* addIfConditional() noexcept
    {
        return mImpl->addIfConditional();
    }
 
    IEinsumLayer* addEinsum(ITensor* const* inputs, int32_t nbInputs, char const* equation) noexcept
    {
        return mImpl->addEinsum(inputs, nbInputs, equation);
    }
 
protected:
    apiv::VNetworkDefinition* mImpl;
};
 
enum class CalibrationAlgoType : int32_t
{
    kLEGACY_CALIBRATION = 0,
    kENTROPY_CALIBRATION = 1,
    kENTROPY_CALIBRATION_2 = 2,
    kMINMAX_CALIBRATION = 3,
};
 
template <>
constexpr inline int32_t EnumMax<CalibrationAlgoType>() noexcept
{
    return 4;
}
 
class IInt8Calibrator
{
public:
    virtual int32_t getBatchSize() const noexcept = 0;
 
    virtual bool getBatch(void* bindings[], char const* names[], int32_t nbBindings) noexcept = 0;
 
    virtual void const* readCalibrationCache(std::size_t& length) noexcept = 0;
 
    virtual void writeCalibrationCache(void const* ptr, std::size_t length) noexcept = 0;
 
    virtual CalibrationAlgoType getAlgorithm() noexcept = 0;
 
    virtual ~IInt8Calibrator() noexcept = default;
};
 
class IInt8EntropyCalibrator : public IInt8Calibrator
{
public:
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kENTROPY_CALIBRATION;
    }
 
    virtual ~IInt8EntropyCalibrator() noexcept = default;
};
 
class IInt8EntropyCalibrator2 : public IInt8Calibrator
{
public:
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kENTROPY_CALIBRATION_2;
    }
 
    virtual ~IInt8EntropyCalibrator2() noexcept = default;
};
 
class IInt8MinMaxCalibrator : public IInt8Calibrator
{
public:
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kMINMAX_CALIBRATION;
    }
 
    virtual ~IInt8MinMaxCalibrator() noexcept = default;
};
 
class IInt8LegacyCalibrator : public IInt8Calibrator
{
public:
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kLEGACY_CALIBRATION;
    }
 
    virtual double getQuantile() const noexcept = 0;
 
    virtual double getRegressionCutoff() const noexcept = 0;
 
    virtual void const* readHistogramCache(std::size_t& length) noexcept = 0;
 
    virtual void writeHistogramCache(void const* ptr, std::size_t length) noexcept = 0;
 
    virtual ~IInt8LegacyCalibrator() noexcept = default;
};
 
class IAlgorithmIOInfo : public INoCopy
{
public:
    TensorFormat getTensorFormat() const noexcept
    {
        return mImpl->getTensorFormat();
    }
 
    DataType getDataType() const noexcept
    {
        return mImpl->getDataType();
    }
 
    Dims getStrides() const noexcept
    {
        return mImpl->getStrides();
    }
 
protected:
    virtual ~IAlgorithmIOInfo() noexcept = default;
    apiv::VAlgorithmIOInfo* mImpl;
};
 
class IAlgorithmVariant : public INoCopy
{
public:
    int64_t getImplementation() const noexcept
    {
        return mImpl->getImplementation();
    }
 
    int64_t getTactic() const noexcept
    {
        return mImpl->getTactic();
    }
 
protected:
    virtual ~IAlgorithmVariant() noexcept = default;
    apiv::VAlgorithmVariant* mImpl;
};
 
class IAlgorithmContext : public INoCopy
{
public:
    char const* getName() const noexcept
    {
        return mImpl->getName();
    }
 
    Dims getDimensions(int32_t index, OptProfileSelector select) const noexcept
    {
        return mImpl->getDimensions(index, select);
    }
 
    int32_t getNbInputs() const noexcept
    {
        return mImpl->getNbInputs();
    }
 
    int32_t getNbOutputs() const noexcept
    {
        return mImpl->getNbOutputs();
    }
 
protected:
    virtual ~IAlgorithmContext() noexcept = default;
    apiv::VAlgorithmContext* mImpl;
};
 
class IAlgorithm : public INoCopy
{
public:
    TRT_DEPRECATED IAlgorithmIOInfo const& getAlgorithmIOInfo(int32_t index) const noexcept
    {
        return mImpl->getAlgorithmIOInfo(index);
    }
 
    IAlgorithmVariant const& getAlgorithmVariant() const noexcept
    {
        return mImpl->getAlgorithmVariant();
    }
 
    float getTimingMSec() const noexcept
    {
        return mImpl->getTimingMSec();
    }
 
    std::size_t getWorkspaceSize() const noexcept
    {
        return mImpl->getWorkspaceSize();
    }
 
    IAlgorithmIOInfo const* getAlgorithmIOInfoByIndex(int32_t index) const noexcept
    {
        return mImpl->getAlgorithmIOInfoByIndex(index);
    }
 
protected:
    virtual ~IAlgorithm() noexcept = default;
    apiv::VAlgorithm* mImpl;
}; // IAlgorithm
 
class IAlgorithmSelector
{
public:
    virtual int32_t selectAlgorithms(IAlgorithmContext const& context, IAlgorithm const* const* choices,
        int32_t nbChoices, int32_t* selection) noexcept = 0;
    virtual void reportAlgorithms(IAlgorithmContext const* const* algoContexts, IAlgorithm const* const* algoChoices,
        int32_t nbAlgorithms) noexcept = 0;
 
    virtual ~IAlgorithmSelector() noexcept = default;
};
 
using QuantizationFlags = uint32_t;
 
enum class QuantizationFlag : int32_t
{
    kCALIBRATE_BEFORE_FUSION = 0
};
 
template <>
constexpr inline int32_t EnumMax<QuantizationFlag>() noexcept
{
    return 1;
}
 
using BuilderFlags = uint32_t;
 
enum class BuilderFlag : int32_t
{
    kFP16 = 0,         
    kINT8 = 1,         
    kDEBUG = 2,        
    kGPU_FALLBACK = 3, 
 
    kSTRICT_TYPES TRT_DEPRECATED_ENUM = 4,
 
    kREFIT = 5,                
    kDISABLE_TIMING_CACHE = 6, 
 
    kTF32 = 7,
 
    kSPARSE_WEIGHTS = 8,
 
    kSAFETY_SCOPE = 9,
 
    kOBEY_PRECISION_CONSTRAINTS = 10,
 
    kPREFER_PRECISION_CONSTRAINTS = 11,
 
    kDIRECT_IO = 12,
 
    kREJECT_EMPTY_ALGORITHMS = 13
};
 
template <>
constexpr inline int32_t EnumMax<BuilderFlag>() noexcept
{
    return 14;
}
 
class ITimingCache : public INoCopy
{
public:
    virtual ~ITimingCache() noexcept = default;
 
    nvinfer1::IHostMemory* serialize() const noexcept
    {
        return mImpl->serialize();
    }
 
    bool combine(ITimingCache const& inputCache, bool ignoreMismatch) noexcept
    {
        return mImpl->combine(inputCache, ignoreMismatch);
    }
 
    bool reset() noexcept
    {
        return mImpl->reset();
    }
 
protected:
    apiv::VTimingCache* mImpl;
};
 
enum class MemoryPoolType : int32_t
{
    kWORKSPACE = 0,
 
    kDLA_MANAGED_SRAM = 1,
 
    kDLA_LOCAL_DRAM = 2,
 
    kDLA_GLOBAL_DRAM = 3,
};
 
template <>
constexpr inline int32_t EnumMax<MemoryPoolType>() noexcept
{
    return 4;
}
 
class IBuilderConfig : public INoCopy
{
public:
    virtual ~IBuilderConfig() noexcept = default;
 
    TRT_DEPRECATED virtual void setMinTimingIterations(int32_t minTiming) noexcept
    {
        mImpl->setMinTimingIterations(minTiming);
    }
 
    TRT_DEPRECATED virtual int32_t getMinTimingIterations() const noexcept
    {
        return mImpl->getMinTimingIterations();
    }
 
    virtual void setAvgTimingIterations(int32_t avgTiming) noexcept
    {
        mImpl->setAvgTimingIterations(avgTiming);
    }
 
    int32_t getAvgTimingIterations() const noexcept
    {
        return mImpl->getAvgTimingIterations();
    }
 
    void setEngineCapability(EngineCapability capability) noexcept
    {
        mImpl->setEngineCapability(capability);
    }
 
    EngineCapability getEngineCapability() const noexcept
    {
        return mImpl->getEngineCapability();
    }
 
    void setInt8Calibrator(IInt8Calibrator* calibrator) noexcept
    {
        mImpl->setInt8Calibrator(calibrator);
    }
 
    IInt8Calibrator* getInt8Calibrator() const noexcept
    {
        return mImpl->getInt8Calibrator();
    }
 
    TRT_DEPRECATED void setMaxWorkspaceSize(std::size_t workspaceSize) noexcept
    {
        mImpl->setMaxWorkspaceSize(workspaceSize);
    }
 
    TRT_DEPRECATED std::size_t getMaxWorkspaceSize() const noexcept
    {
        return mImpl->getMaxWorkspaceSize();
    }
 
    void setFlags(BuilderFlags builderFlags) noexcept
    {
        mImpl->setFlags(builderFlags);
    }
 
    BuilderFlags getFlags() const noexcept
    {
        return mImpl->getFlags();
    }
 
    void clearFlag(BuilderFlag builderFlag) noexcept
    {
        mImpl->clearFlag(builderFlag);
    }
 
    void setFlag(BuilderFlag builderFlag) noexcept
    {
        mImpl->setFlag(builderFlag);
    }
 
    bool getFlag(BuilderFlag builderFlag) const noexcept
    {
        return mImpl->getFlag(builderFlag);
    }
 
    void setDeviceType(ILayer const* layer, DeviceType deviceType) noexcept
    {
        mImpl->setDeviceType(layer, deviceType);
    }
 
    DeviceType getDeviceType(ILayer const* layer) const noexcept
    {
        return mImpl->getDeviceType(layer);
    }
 
    bool isDeviceTypeSet(ILayer const* layer) const noexcept
    {
        return mImpl->isDeviceTypeSet(layer);
    }
 
    void resetDeviceType(ILayer const* layer) noexcept
    {
        mImpl->resetDeviceType(layer);
    }
 
    bool canRunOnDLA(ILayer const* layer) const noexcept
    {
        return mImpl->canRunOnDLA(layer);
    }
 
    void setDLACore(int32_t dlaCore) noexcept
    {
        mImpl->setDLACore(dlaCore);
    }
 
    int32_t getDLACore() const noexcept
    {
        return mImpl->getDLACore();
    }
 
    void setDefaultDeviceType(DeviceType deviceType) noexcept
    {
        mImpl->setDefaultDeviceType(deviceType);
    }
 
    DeviceType getDefaultDeviceType() const noexcept
    {
        return mImpl->getDefaultDeviceType();
    }
 
    void reset() noexcept
    {
        mImpl->reset();
    }
 
    TRT_DEPRECATED void destroy() noexcept
    {
        delete this;
    }
 
    void setProfileStream(const cudaStream_t stream) noexcept
    {
        return mImpl->setProfileStream(stream);
    }
 
    cudaStream_t getProfileStream() const noexcept
    {
        return mImpl->getProfileStream();
    }
 
    int32_t addOptimizationProfile(IOptimizationProfile const* profile) noexcept
    {
        return mImpl->addOptimizationProfile(profile);
    }
 
    int32_t getNbOptimizationProfiles() const noexcept
    {
        return mImpl->getNbOptimizationProfiles();
    }
 
    void setProfilingVerbosity(ProfilingVerbosity verbosity) noexcept
    {
        mImpl->setProfilingVerbosity(verbosity);
    }
 
    ProfilingVerbosity getProfilingVerbosity() const noexcept
    {
        return mImpl->getProfilingVerbosity();
    }
 
    void setAlgorithmSelector(IAlgorithmSelector* selector) noexcept
    {
        mImpl->setAlgorithmSelector(selector);
    }
 
    IAlgorithmSelector* getAlgorithmSelector() const noexcept
    {
        return mImpl->getAlgorithmSelector();
    }
 
    bool setCalibrationProfile(IOptimizationProfile const* profile) noexcept
    {
        return mImpl->setCalibrationProfile(profile);
    }
 
    IOptimizationProfile const* getCalibrationProfile() noexcept
    {
        return mImpl->getCalibrationProfile();
    }
 
    void setQuantizationFlags(QuantizationFlags flags) noexcept
    {
        mImpl->setQuantizationFlags(flags);
    }
 
    QuantizationFlags getQuantizationFlags() const noexcept
    {
        return mImpl->getQuantizationFlags();
    }
 
    void clearQuantizationFlag(QuantizationFlag flag) noexcept
    {
        mImpl->clearQuantizationFlag(flag);
    }
 
    void setQuantizationFlag(QuantizationFlag flag) noexcept
    {
        mImpl->setQuantizationFlag(flag);
    }
 
    bool getQuantizationFlag(QuantizationFlag flag) const noexcept
    {
        return mImpl->getQuantizationFlag(flag);
    }
 
    bool setTacticSources(TacticSources tacticSources) noexcept
    {
        return mImpl->setTacticSources(tacticSources);
    }
 
    TacticSources getTacticSources() const noexcept
    {
        return mImpl->getTacticSources();
    }
 
    nvinfer1::ITimingCache* createTimingCache(void const* blob, std::size_t size) const noexcept
    {
        return mImpl->createTimingCache(blob, size);
    }
 
    bool setTimingCache(ITimingCache const& cache, bool ignoreMismatch) noexcept
    {
        return mImpl->setTimingCache(cache, ignoreMismatch);
    }
 
    nvinfer1::ITimingCache const* getTimingCache() const noexcept
    {
        return mImpl->getTimingCache();
    }
 
    void setMemoryPoolLimit(MemoryPoolType pool, std::size_t poolSize) noexcept
    {
        mImpl->setMemoryPoolLimit(pool, poolSize);
    }
 
    std::size_t getMemoryPoolLimit(MemoryPoolType pool) const noexcept
    {
        return mImpl->getMemoryPoolLimit(pool);
    }
 
protected:
    apiv::VBuilderConfig* mImpl;
};
 
using NetworkDefinitionCreationFlags = uint32_t;
 
enum class NetworkDefinitionCreationFlag : int32_t
{
    kEXPLICIT_BATCH = 0,
 
    kEXPLICIT_PRECISION TRT_DEPRECATED_ENUM = 1,
};
 
template <>
constexpr inline int32_t EnumMax<NetworkDefinitionCreationFlag>() noexcept
{
    return 2;
}
 
class IBuilder : public INoCopy
{
public:
    virtual ~IBuilder() noexcept = default;
 
    TRT_DEPRECATED void setMaxBatchSize(int32_t batchSize) noexcept
    {
        mImpl->setMaxBatchSize(batchSize);
    }
 
    TRT_DEPRECATED int32_t getMaxBatchSize() const noexcept
    {
        return mImpl->getMaxBatchSize();
    }
 
    bool platformHasFastFp16() const noexcept
    {
        return mImpl->platformHasFastFp16();
    }
 
    bool platformHasFastInt8() const noexcept
    {
        return mImpl->platformHasFastInt8();
    }
 
    TRT_DEPRECATED void destroy() noexcept
    {
        delete this;
    }
 
    int32_t getMaxDLABatchSize() const noexcept
    {
        return mImpl->getMaxDLABatchSize();
    }
 
    int32_t getNbDLACores() const noexcept
    {
        return mImpl->getNbDLACores();
    }
 
    void setGpuAllocator(IGpuAllocator* allocator) noexcept
    {
        mImpl->setGpuAllocator(allocator);
    }
 
    nvinfer1::IBuilderConfig* createBuilderConfig() noexcept
    {
        return mImpl->createBuilderConfig();
    }
 
    TRT_DEPRECATED nvinfer1::ICudaEngine* buildEngineWithConfig(
        INetworkDefinition& network, IBuilderConfig& config) noexcept
    {
        return mImpl->buildEngineWithConfig(network, config);
    }
 
    nvinfer1::INetworkDefinition* createNetworkV2(NetworkDefinitionCreationFlags flags) noexcept
    {
        return mImpl->createNetworkV2(flags);
    }
 
    nvinfer1::IOptimizationProfile* createOptimizationProfile() noexcept
    {
        return mImpl->createOptimizationProfile();
    }
 
    //
    void setErrorRecorder(IErrorRecorder* recorder) noexcept
    {
        mImpl->setErrorRecorder(recorder);
    }
 
    IErrorRecorder* getErrorRecorder() const noexcept
    {
        return mImpl->getErrorRecorder();
    }
 
    void reset() noexcept
    {
        mImpl->reset();
    }
 
    bool platformHasTf32() const noexcept
    {
        return mImpl->platformHasTf32();
    }
 
    nvinfer1::IHostMemory* buildSerializedNetwork(INetworkDefinition& network, IBuilderConfig& config) noexcept
    {
        return mImpl->buildSerializedNetwork(network, config);
    }
 
    bool isNetworkSupported(INetworkDefinition const& network, IBuilderConfig const& config) const noexcept
    {
        return mImpl->isNetworkSupported(network, config);
    }
 
    ILogger* getLogger() const noexcept
    {
        return mImpl->getLogger();
    }
 
    bool setMaxThreads(int32_t maxThreads) noexcept
    {
        return mImpl->setMaxThreads(maxThreads);
    }
 
    int32_t getMaxThreads() const noexcept
    {
        return mImpl->getMaxThreads();
    }
 
protected:
    apiv::VBuilder* mImpl;
};
 
} // namespace nvinfer1
 
extern "C" TENSORRTAPI void* createInferBuilder_INTERNAL(void* logger, int32_t version) noexcept;
 
namespace nvinfer1
{
namespace
{
 
inline IBuilder* createInferBuilder(ILogger& logger) noexcept
{
    return static_cast<IBuilder*>(createInferBuilder_INTERNAL(&logger, NV_TENSORRT_VERSION));
}
 
} // namespace
 
extern "C" TENSORRTAPI nvinfer1::IPluginRegistry* getBuilderPluginRegistry(
    nvinfer1::EngineCapability capability) noexcept;
 
} // namespace nvinfer1
 
#endif // NV_INFER_H