NvInfer.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef NV_INFER_H
#define NV_INFER_H
 
#include "NvInferLegacyDims.h"
#include "NvInferRuntime.h"
 
//
 
 
namespace nvinfer1
{
 
enum class LayerType : int32_t
{
    kCONVOLUTION = 0,         
    kCAST = 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,           
    kIDENTITY = 20,           
    kPLUGIN_V2 = 21,          
    kSLICE = 22,              
    kSHAPE = 23,              
    kPARAMETRIC_RELU = 24,    
    kRESIZE = 25,             
    kTRIP_LIMIT = 26,         
    kRECURRENCE = 27,         
    kITERATOR = 28,           
    kLOOP_OUTPUT = 29,        
    kSELECT = 30,             
    kFILL = 31,               
    kQUANTIZE = 32,           
    kDEQUANTIZE = 33,         
    kCONDITION = 34,          
    kCONDITIONAL_INPUT = 35,  
    kCONDITIONAL_OUTPUT = 36, 
    kSCATTER = 37,            
    kEINSUM = 38,             
    kASSERTION = 39,          
    kONE_HOT = 40,            
    kNON_ZERO = 41,           
    kGRID_SAMPLE = 42,        
    kNMS = 43,                
    kREVERSE_SEQUENCE = 44,   
    kNORMALIZATION = 45,      
    kPLUGIN_V3 = 46,          
    kSQUEEZE = 47,            
    kUNSQUEEZE = 48,          
};
 
template <>
constexpr inline int32_t EnumMax<LayerType>() noexcept
{
    return 49;
}
 
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, 
    kGELU_ERF = 12,         
    kGELU_TANH = 13         
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ActivationType>
{
    static constexpr int32_t kVALUE = 14;
};
} // 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 const& 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();
    }
 
    TRT_DEPRECATED 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();
    }
 
    TRT_DEPRECATED void setBroadcastAcrossBatch(bool broadcastAcrossBatch) noexcept
    {
        mImpl->setBroadcastAcrossBatch(broadcastAcrossBatch);
    }
 
    TRT_DEPRECATED bool getBroadcastAcrossBatch() const noexcept
    {
        return mImpl->getBroadcastAcrossBatch();
    }
 
    TensorLocation getLocation() const noexcept
    {
        return mImpl->getLocation();
    }
 
    TRT_DEPRECATED void setLocation(TensorLocation location) noexcept
    {
        mImpl->setLocation(location);
    }
 
    TRT_DEPRECATED 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();
    }
 
    void setDimensionName(int32_t index, char const* name) noexcept
    {
        mImpl->setDimensionName(index, name);
    }
 
    char const* getDimensionName(int32_t index) const noexcept
    {
        return mImpl->getDimensionName(index);
    }
 
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);
    }
 
    void setMetadata(char const* metadata) noexcept
    {
        mLayer->setMetadata(metadata);
    }
 
    char const* getMetadata() const noexcept
    {
        return mLayer->getMetadata();
    }
 
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,          
};
 
namespace impl
{
template <>
struct EnumMaxImpl<PaddingMode>
{
    static constexpr int32_t kVALUE = 4;
};
} // namespace impl
 
class IConvolutionLayer : public ILayer
{
public:
    void setNbOutputMaps(int64_t nbOutputMaps) noexcept
    {
        mImpl->setNbOutputMaps(nbOutputMaps);
    }
 
    int64_t getNbOutputMaps() const noexcept
    {
        return mImpl->getNbOutputMaps();
    }
 
    void setNbGroups(int64_t nbGroups) noexcept
    {
        mImpl->setNbGroups(nbGroups);
    }
 
    int64_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 const& padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims const& 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 const& kernelSize) noexcept
    {
        mImpl->setKernelSizeNd(kernelSize);
    }
 
    Dims getKernelSizeNd() const noexcept
    {
        return mImpl->getKernelSizeNd();
    }
 
    void setStrideNd(Dims const& stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims const& padding) noexcept
    {
        mImpl->setPaddingNd(padding);
    }
 
    Dims getPaddingNd() const noexcept
    {
        return mImpl->getPaddingNd();
    }
 
    void setDilationNd(Dims const& dilation) noexcept
    {
        mImpl->setDilationNd(dilation);
    }
 
    Dims getDilationNd() const noexcept
    {
        return mImpl->getDilationNd();
    }
 
    using ILayer::setInput;
 
protected:
    virtual ~IConvolutionLayer() noexcept = default;
    apiv::VConvolutionLayer* 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,              
    kAVERAGE = 1,          
    kMAX_AVERAGE_BLEND = 2 
};
 
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();
    }
 
    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 const& padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims const& 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 const& windowSize) noexcept
    {
        mImpl->setWindowSizeNd(windowSize);
    }
 
    Dims getWindowSizeNd() const noexcept
    {
        return mImpl->getWindowSizeNd();
    }
 
    void setStrideNd(Dims const& stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims const& 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(int64_t windowSize) noexcept
    {
        mImpl->setWindowSize(windowSize);
    }
 
    int64_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:
    void setNbOutputMaps(int64_t nbOutputMaps) noexcept
    {
        mImpl->setNbOutputMaps(nbOutputMaps);
    }
 
    int64_t getNbOutputMaps() const noexcept
    {
        return mImpl->getNbOutputMaps();
    }
 
    void setNbGroups(int64_t nbGroups) noexcept
    {
        mImpl->setNbGroups(nbGroups);
    }
 
    int64_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 const& padding) noexcept
    {
        mImpl->setPrePadding(padding);
    }
 
    Dims getPrePadding() const noexcept
    {
        return mImpl->getPrePadding();
    }
 
    void setPostPadding(Dims const& 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 const& kernelSize) noexcept
    {
        mImpl->setKernelSizeNd(kernelSize);
    }
 
    Dims getKernelSizeNd() const noexcept
    {
        return mImpl->getKernelSizeNd();
    }
 
    void setStrideNd(Dims const& stride) noexcept
    {
        mImpl->setStrideNd(stride);
    }
 
    Dims getStrideNd() const noexcept
    {
        return mImpl->getStrideNd();
    }
 
    void setPaddingNd(Dims const& padding) noexcept
    {
        mImpl->setPaddingNd(padding);
    }
 
    Dims getPaddingNd() const noexcept
    {
        return mImpl->getPaddingNd();
    }
 
    using ILayer::setInput;
 
    void setDilationNd(Dims const& 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;
};
 
class IPluginV2Layer : public ILayer
{
public:
    IPluginV2& getPlugin() noexcept
    {
        return mImpl->getPlugin();
    }
 
protected:
    apiv::VPluginV2Layer* mImpl;
    virtual ~IPluginV2Layer() noexcept = default;
};
 
class IPluginV3Layer : public ILayer
{
public:
    IPluginV3& getPlugin() noexcept
    {
        return mImpl->getPlugin();
    }
 
protected:
    apiv::VPluginV3Layer* mImpl;
    virtual ~IPluginV3Layer() 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, 
    kISINF = 23, 
    kISNAN = 24, 
};
 
template <>
constexpr inline int32_t EnumMax<UnaryOperation>() noexcept
{
    return 25;
}
 
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:
    void setPrePaddingNd(Dims const& padding) noexcept
    {
        mImpl->setPrePaddingNd(padding);
    }
 
    Dims getPrePaddingNd() const noexcept
    {
        return mImpl->getPrePaddingNd();
    }
 
    void setPostPaddingNd(Dims const& 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 const& 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 SampleMode : int32_t
{
    kSTRICT_BOUNDS = 0,                            
    kWRAP = 1,                                     
    kCLAMP = 2,                                    
    kFILL = 3,                                     
    kREFLECT = 4, 
};
 
template <>
constexpr inline int32_t EnumMax<SampleMode>() noexcept
{
    return 5;
}
 
class ISliceLayer : public ILayer
{
public:
    void setStart(Dims const& start) noexcept
    {
        mImpl->setStart(start);
    }
 
    Dims getStart() const noexcept
    {
        return mImpl->getStart();
    }
 
    void setSize(Dims const& size) noexcept
    {
        return mImpl->setSize(size);
    }
 
    Dims getSize() const noexcept
    {
        return mImpl->getSize();
    }
 
    void setStride(Dims const& stride) noexcept
    {
        mImpl->setStride(stride);
    }
 
    Dims getStride() const noexcept
    {
        return mImpl->getStride();
    }
 
    void setMode(SampleMode mode) noexcept
    {
        mImpl->setMode(mode);
    }
 
    SampleMode getMode() const noexcept
    {
        return mImpl->getMode();
    }
 
    using ILayer::setInput;
 
    void setAxes(Dims const& axes) noexcept
    {
        mImpl->setAxes(axes);
    }
 
    Dims getAxes() const noexcept
    {
        return mImpl->getAxes();
    }
 
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();
    }
 
    using ILayer::setInput;
 
protected:
    apiv::VTopKLayer* mImpl;
    virtual ~ITopKLayer() noexcept = default;
};
 
enum class MatrixOperation : int32_t
{
    kNONE = 0,
 
    kTRANSPOSE = 1,
 
    kVECTOR = 2,
};
 
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 INonZeroLayer : public ILayer
{
protected:
    virtual ~INonZeroLayer() noexcept = default;
    apiv::VNonZeroLayer* mImpl;
};
 
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 ICastLayer : public ILayer
{
public:
    void setToType(DataType toType) noexcept
    {
        mImpl->setToType(toType);
    }
 
    DataType getToType() const noexcept
    {
        return mImpl->getToType();
    }
 
protected:
    apiv::VCastLayer* mImpl;
    virtual ~ICastLayer() 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 const& 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 InterpolationMode : int32_t
{
    kNEAREST = 0, 
    kLINEAR = 1,  
    kCUBIC = 2    
};
 
namespace impl
{
template <>
struct EnumMaxImpl<InterpolationMode>
{
    static constexpr int32_t kVALUE = 3;
};
} // 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 const& 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(InterpolationMode interpolationMode) noexcept
    {
        mImpl->setResizeMode(interpolationMode);
    }
 
    InterpolationMode getResizeMode() const noexcept
    {
        return mImpl->getResizeMode();
    }
 
    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();
    }
 
    void setCubicCoeff(float A) noexcept
    {
        mImpl->setCubicCoeff(A);
    }
 
    float getCubicCoeff() const noexcept
    {
        return mImpl->getCubicCoeff();
    }
 
    void setExcludeOutside(bool excludeFlag) noexcept
    {
        mImpl->setExcludeOutside(excludeFlag);
    }
 
    bool getExcludeOutside() const noexcept
    {
        return mImpl->getExcludeOutside();
    }
 
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,
 
    kRANDOM_NORMAL = 2
};
 
template <>
constexpr inline int32_t EnumMax<FillOperation>() noexcept
{
    return 3;
}
 
class IFillLayer : public ILayer
{
public:
    //
    void setDimensions(Dims const& 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;
 
    //
    void setAlphaInt64(int64_t alpha) noexcept
    {
        mImpl->setAlphaInt64(alpha);
    }
 
    int64_t getAlphaInt64() const noexcept
    {
        return mImpl->getAlphaInt64();
    }
 
    void setBetaInt64(int64_t beta) noexcept
    {
        mImpl->setBetaInt64(beta);
    }
 
    int64_t getBetaInt64() const noexcept
    {
        return mImpl->getBetaInt64();
    }
 
    bool isAlphaBetaInt64() const noexcept
    {
        return mImpl->isAlphaBetaInt64();
    }
 
    void setToType(DataType toType) noexcept
    {
        mImpl->setToType(toType);
    }
 
    DataType getToType() const noexcept
    {
        return mImpl->getToType();
    }
 
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);
    }
 
    void setToType(DataType toType) noexcept
    {
        mImpl->setToType(toType);
    }
 
    DataType getToType() const noexcept
    {
        return mImpl->getToType();
    }
 
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);
    }
 
    void setToType(DataType toType) noexcept
    {
        mImpl->setToType(toType);
    }
 
    DataType getToType() const noexcept
    {
        return mImpl->getToType();
    }
 
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 IOneHotLayer : public ILayer
{
public:
    void setAxis(int32_t axis) noexcept
    {
        mImpl->setAxis(axis);
    }
 
    int32_t getAxis() const noexcept
    {
        return mImpl->getAxis();
    }
 
protected:
    apiv::VOneHotLayer* mImpl;
};
 
class IGridSampleLayer : public ILayer
{
public:
    void setInterpolationMode(InterpolationMode mode) noexcept
    {
        mImpl->setInterpolationMode(mode);
    }
 
    InterpolationMode getInterpolationMode() const noexcept
    {
        return mImpl->getInterpolationMode();
    }
 
    void setAlignCorners(bool alignCorners) noexcept
    {
        mImpl->setAlignCorners(alignCorners);
    }
 
    bool getAlignCorners() const noexcept
    {
        return mImpl->getAlignCorners();
    }
 
    bool setSampleMode(SampleMode mode) noexcept
    {
        return mImpl->setSampleMode(mode);
    }
 
    SampleMode getSampleMode() const noexcept
    {
        return mImpl->getSampleMode();
    }
 
protected:
    apiv::VGridSampleLayer* mImpl;
    virtual ~IGridSampleLayer() noexcept = default;
}; // class IGridSampleLayer
 
enum class BoundingBoxFormat : int32_t
{
    kCORNER_PAIRS = 0,
    kCENTER_SIZES = 1
};
 
template <>
constexpr inline int32_t EnumMax<BoundingBoxFormat>() noexcept
{
    return 2;
}
 
class INMSLayer : public ILayer
{
public:
    void setBoundingBoxFormat(BoundingBoxFormat fmt) noexcept
    {
        mImpl->setBoundingBoxFormat(fmt);
    }
 
    BoundingBoxFormat getBoundingBoxFormat() const noexcept
    {
        return mImpl->getBoundingBoxFormat();
    }
 
    void setTopKBoxLimit(int32_t limit) noexcept
    {
        mImpl->setTopKBoxLimit(limit);
    }
 
    int32_t getTopKBoxLimit() const noexcept
    {
        return mImpl->getTopKBoxLimit();
    }
 
    using ILayer::setInput;
 
protected:
    apiv::VNMSLayer* mImpl;
    virtual ~INMSLayer() noexcept = default;
}; // class INMSLayer
 
class IReverseSequenceLayer : public ILayer
{
public:
    void setBatchAxis(int32_t batchAxis) noexcept
    {
        mImpl->setBatchAxis(batchAxis);
    }
 
    int32_t getBatchAxis() const noexcept
    {
        return mImpl->getBatchAxis();
    }
 
    void setSequenceAxis(int32_t sequenceAxis) noexcept
    {
        mImpl->setSequenceAxis(sequenceAxis);
    }
 
    int32_t getSequenceAxis() const noexcept
    {
        return mImpl->getSequenceAxis();
    }
 
protected:
    apiv::VReverseSequenceLayer* mImpl;
    virtual ~IReverseSequenceLayer() noexcept = default;
}; // class IReverseSequenceLayer
 
class INormalizationLayer : public ILayer
{
public:
    void setEpsilon(float eps) noexcept
    {
        return mImpl->setEpsilon(eps);
    }
 
    float getEpsilon() const noexcept
    {
        return mImpl->getEpsilon();
    }
 
    void setAxes(uint32_t axesMask) noexcept
    {
        return mImpl->setAxes(axesMask);
    }
 
    uint32_t getAxes() const noexcept
    {
        return mImpl->getAxes();
    }
 
    void setNbGroups(int64_t nbGroups) noexcept
    {
        return mImpl->setNbGroups(nbGroups);
    }
 
    int64_t getNbGroups() const noexcept
    {
        return mImpl->getNbGroups();
    }
 
    void setComputePrecision(DataType type) noexcept
    {
        return mImpl->setComputePrecision(type);
    }
 
    DataType getComputePrecision() const noexcept
    {
        return mImpl->getComputePrecision();
    }
 
protected:
    apiv::VNormalizationLayer* mImpl;
    virtual ~INormalizationLayer() noexcept = default;
};
 
class ISqueezeLayer : public ILayer
{
public:
    using ILayer::setInput;
 
protected:
    apiv::VSqueezeLayer* mImpl;
    virtual ~ISqueezeLayer() noexcept = default;
};
 
class IUnsqueezeLayer : public ILayer
{
public:
    using ILayer::setInput;
 
protected:
    apiv::VUnsqueezeLayer* mImpl;
    virtual ~IUnsqueezeLayer() noexcept = default;
};
 
class INetworkDefinition : public INoCopy
{
public:
    virtual ~INetworkDefinition() noexcept = default;
 
    ITensor* addInput(char const* name, DataType type, Dims const& dimensions) noexcept
    {
        return mImpl->addInput(name, type, dimensions);
    }
 
    void markOutput(ITensor& tensor) noexcept
    {
        mImpl->markOutput(tensor);
    }
 
    bool markDebug(ITensor& tensor) noexcept
    {
        return mImpl->markDebug(tensor);
    }
 
    bool unmarkDebug(ITensor& tensor) noexcept
    {
        return mImpl->unmarkDebug(tensor);
    }
 
    bool isDebugTensor(nvinfer1::ITensor const& tensor) const noexcept
    {
        return mImpl->isDebugTensor(tensor);
    }
 
    IActivationLayer* addActivation(ITensor& input, ActivationType type) noexcept
    {
        return mImpl->addActivation(input, type);
    }
 
    ILRNLayer* addLRN(ITensor& input, int64_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);
    }
 
    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);
    }
 
    IShuffleLayer* addShuffle(ITensor& input) noexcept
    {
        return mImpl->addShuffle(input);
    }
 
    IOneHotLayer* addOneHot(ITensor& indices, ITensor& values, ITensor& depth, int32_t axis) noexcept
    {
        return mImpl->addOneHot(indices, values, depth, axis);
    }
 
    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);
    }
 
    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) noexcept
    {
        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);
    }
 
    INonZeroLayer* addNonZero(ITensor& input) noexcept
    {
        return mImpl->addNonZero(input);
    }
 
    IConstantLayer* addConstant(Dims const& dimensions, Weights weights) noexcept
    {
        return mImpl->addConstant(dimensions, weights);
    }
 
    IIdentityLayer* addIdentity(ITensor& input) noexcept
    {
        return mImpl->addIdentity(input);
    }
 
    ICastLayer* addCast(ITensor& input, DataType toType) noexcept
    {
        return mImpl->addCast(input, toType);
    }
 
    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);
    }
 
    IPluginV3Layer* addPluginV3(ITensor* const* inputs, int32_t nbInputs, ITensor* const* shapeInputs,
        int32_t nbShapeInputs, IPluginV3& plugin) noexcept
    {
        return mImpl->addPluginV3(inputs, nbInputs, shapeInputs, nbShapeInputs, plugin);
    }
 
    ISliceLayer* addSlice(ITensor& input, Dims const& start, Dims const& size, Dims const& 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);
    }
 
    TRT_DEPRECATED bool hasImplicitBatchDimension() const noexcept
    {
        return mImpl->hasImplicitBatchDimension();
    }
 
    NetworkDefinitionCreationFlags getFlags() const noexcept
    {
        return mImpl->getFlags();
    }
 
    bool getFlag(NetworkDefinitionCreationFlag networkDefinitionCreationFlag) const noexcept
    {
        return mImpl->getFlag(networkDefinitionCreationFlag);
    }
 
    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, int64_t nbOutputMaps, Dims const& kernelSize, Weights kernelWeights, Weights biasWeights) noexcept
    {
        return mImpl->addConvolutionNd(input, nbOutputMaps, kernelSize, kernelWeights, biasWeights);
    }
 
    IPoolingLayer* addPoolingNd(ITensor& input, PoolingType type, Dims const& windowSize) noexcept
    {
        return mImpl->addPoolingNd(input, type, windowSize);
    }
 
    //
    IDeconvolutionLayer* addDeconvolutionNd(
        ITensor& input, int64_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);
    }
 
    ILoop* addLoop() noexcept
    {
        return mImpl->addLoop();
    }
 
    IIfConditional* addIfConditional() noexcept
    {
        return mImpl->addIfConditional();
    }
 
    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);
    }
 
    TRT_DEPRECATED IFillLayer* addFill(Dims const& dimensions, FillOperation op) noexcept
    {
        return mImpl->addFill(dimensions, op);
    }
 
    IFillLayer* addFill(Dims const& dimensions, FillOperation op, DataType outputType) noexcept
    {
        return mImpl->addFillV2(dimensions, op, outputType);
    }
 
    IPaddingLayer* addPaddingNd(ITensor& input, Dims const& prePadding, Dims const& 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();
    }
 
    TRT_DEPRECATED IDequantizeLayer* addDequantize(ITensor& input, ITensor& scale) noexcept
    {
        return mImpl->addDequantize(input, scale);
    }
 
    IDequantizeLayer* addDequantize(ITensor& input, ITensor& scale, DataType outputType) noexcept
    {
        return mImpl->addDequantizeV2(input, scale, outputType);
    }
 
    IScatterLayer* addScatter(ITensor& data, ITensor& indices, ITensor& updates, ScatterMode mode) noexcept
    {
        return mImpl->addScatter(data, indices, updates, mode);
    }
 
    TRT_DEPRECATED IQuantizeLayer* addQuantize(ITensor& input, ITensor& scale) noexcept
    {
        return mImpl->addQuantize(input, scale);
    }
 
    IQuantizeLayer* addQuantize(ITensor& input, ITensor& scale, DataType outputType) noexcept
    {
        return mImpl->addQuantizeV2(input, scale, outputType);
    }
 
 
    IEinsumLayer* addEinsum(ITensor* const* inputs, int32_t nbInputs, char const* equation) noexcept
    {
        return mImpl->addEinsum(inputs, nbInputs, equation);
    }
 
    IGridSampleLayer* addGridSample(ITensor& input, ITensor& grid) noexcept
    {
        return mImpl->addGridSample(input, grid);
    }
 
    INMSLayer* addNMS(ITensor& boxes, ITensor& scores, ITensor& maxOutputBoxesPerClass) noexcept
    {
        return mImpl->addNMS(boxes, scores, maxOutputBoxesPerClass);
    }
 
    IReverseSequenceLayer* addReverseSequence(ITensor& input, ITensor& sequenceLens) noexcept
    {
        return mImpl->addReverseSequence(input, sequenceLens);
    }
 
    INormalizationLayer* addNormalization(ITensor& input, ITensor& scale, ITensor& bias, uint32_t axesMask) noexcept
    {
        return mImpl->addNormalization(input, scale, bias, axesMask);
    }
 
    virtual IBuilder& getBuilder() const noexcept
    {
        return mImpl->getBuilder();
    }
 
    bool markWeightsRefittable(char const* name) noexcept
    {
        return mImpl->markWeightsRefittable(name);
    }
 
    bool unmarkWeightsRefittable(char const* name) noexcept
    {
        return mImpl->unmarkWeightsRefittable(name);
    }
 
    bool areWeightsMarkedRefittable(char const* name) const noexcept
    {
        return mImpl->areWeightsMarkedRefittable(name);
    }
 
    ISqueezeLayer* addSqueeze(ITensor& input, ITensor& axes) noexcept
    {
        return mImpl->addSqueeze(input, axes);
    }
 
    IUnsqueezeLayer* addUnsqueeze(ITensor& input, ITensor& axes) noexcept
    {
        return mImpl->addUnsqueeze(input, axes);
    }
 
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 TRT_DEPRECATED IInt8Calibrator : public IVersionedInterface
{
public:
    TRT_DEPRECATED 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;
 
    ~IInt8Calibrator() noexcept override = default;
};
 
namespace v_1_0
{
class TRT_DEPRECATED IInt8EntropyCalibrator : public IInt8Calibrator
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IInt8EntropyCalibrator", 1, 0};
    }
 
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kENTROPY_CALIBRATION;
    }
 
    ~IInt8EntropyCalibrator() noexcept override = default;
};
} // namespace v_1_0
 
using IInt8EntropyCalibrator = v_1_0::IInt8EntropyCalibrator;
 
namespace v_1_0
{
class TRT_DEPRECATED IInt8EntropyCalibrator2 : public IInt8Calibrator
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IInt8EntropyCalibrator2", 1, 0};
    }
 
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kENTROPY_CALIBRATION_2;
    }
 
    ~IInt8EntropyCalibrator2() noexcept override = default;
};
} // namespace v_1_0
 
using IInt8EntropyCalibrator2 = v_1_0::IInt8EntropyCalibrator2;
 
namespace v_1_0
{
class TRT_DEPRECATED IInt8MinMaxCalibrator : public IInt8Calibrator
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IInt8MinMaxCalibrator", 1, 0};
    }
 
    CalibrationAlgoType getAlgorithm() noexcept override
    {
        return CalibrationAlgoType::kMINMAX_CALIBRATION;
    }
 
    ~IInt8MinMaxCalibrator() noexcept override = default;
};
} // namespace v_1_0
 
using IInt8MinMaxCalibrator = v_1_0::IInt8MinMaxCalibrator;
 
namespace v_1_0
{
class TRT_DEPRECATED IInt8LegacyCalibrator : public IInt8Calibrator
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IInt8Calibrator", 1, 0};
    }
 
    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;
 
    ~IInt8LegacyCalibrator() noexcept override = default;
};
} // namespace v_1_0
 
using IInt8LegacyCalibrator = v_1_0::IInt8LegacyCalibrator;
 
class IAlgorithmIOInfo : public INoCopy
{
public:
    DataType getDataType() const noexcept
    {
        return mImpl->getDataType();
    }
 
    Dims getStrides() const noexcept
    {
        return mImpl->getStrides();
    }
 
    int64_t getVectorizedDim() const noexcept
    {
        return mImpl->getVectorizedDim();
    }
 
    int64_t getComponentsPerElement() const noexcept
    {
        return mImpl->getComponentsPerElement();
    }
 
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:
    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
 
namespace v_1_0
{
class IAlgorithmSelector : public IVersionedInterface
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IAlgorithmSelector", 1, 0};
    }
    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;
};
} // namespace v_1_0
 
using IAlgorithmSelector = v_1_0::IAlgorithmSelector;
 
using QuantizationFlags = uint32_t;
 
enum class QuantizationFlag : int32_t
{
    kCALIBRATE_BEFORE_FUSION TRT_DEPRECATED_ENUM = 0
};
 
template <>
constexpr inline int32_t EnumMax<QuantizationFlag>() noexcept
{
    return 1;
}
 
enum class RuntimePlatform : int32_t
{
    kSAME_AS_BUILD = 0,
 
    kWINDOWS_AMD64 = 1,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<RuntimePlatform>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
using BuilderFlags = uint32_t;
 
enum class BuilderFlag : int32_t
{
    kFP16 = 0,
 
    kINT8 = 1,
 
    kDEBUG = 2,
 
    kGPU_FALLBACK = 3,
 
    kREFIT = 4,
 
    kDISABLE_TIMING_CACHE = 5,
 
    kTF32 = 6,
 
    kSPARSE_WEIGHTS = 7,
 
    kSAFETY_SCOPE = 8,
 
    kOBEY_PRECISION_CONSTRAINTS = 9,
 
    kPREFER_PRECISION_CONSTRAINTS = 10,
 
    kDIRECT_IO TRT_DEPRECATED_ENUM = 11,
 
    kREJECT_EMPTY_ALGORITHMS = 12,
 
    kVERSION_COMPATIBLE = 13,
 
    kEXCLUDE_LEAN_RUNTIME = 14,
 
    kFP8 = 15,
 
    kERROR_ON_TIMING_CACHE_MISS = 16,
 
    kBF16 = 17,
 
    kDISABLE_COMPILATION_CACHE = 18,
 
    kSTRIP_PLAN = 19,
 
    kWEIGHTLESS TRT_DEPRECATED_ENUM = kSTRIP_PLAN,
 
    kREFIT_IDENTICAL = 20,
 
    kWEIGHT_STREAMING = 21,
 
    kINT4 = 22,
 
    kREFIT_INDIVIDUAL = 23,
 
    kSTRICT_NANS = 24,
 
    kMONITOR_MEMORY = 25,
 
};
 
template <>
constexpr inline int32_t EnumMax<BuilderFlag>() noexcept
{
    return 26;
}
 
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,
 
    kTACTIC_DRAM = 4,
 
    kTACTIC_SHARED_MEMORY = 5,
};
 
template <>
constexpr inline int32_t EnumMax<MemoryPoolType>() noexcept
{
    return 6;
}
 
enum class PreviewFeature : int32_t
{
    kPROFILE_SHARING_0806 TRT_DEPRECATED_ENUM = 0,
 
    kALIASED_PLUGIN_IO_10_03 = 1
};
 
namespace impl
{
template <>
struct EnumMaxImpl<PreviewFeature>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
enum class HardwareCompatibilityLevel : int32_t
{
    kNONE = 0,
 
    kAMPERE_PLUS = 1,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<HardwareCompatibilityLevel>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
namespace v_1_0
{
class IProgressMonitor : public IVersionedInterface
{
public:
    IProgressMonitor() = default;
    virtual ~IProgressMonitor() noexcept = default;
 
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IProgressMonitor", 1, 0};
    }
 
    virtual void phaseStart(char const* phaseName, char const* parentPhase, int32_t nbSteps) noexcept = 0;
 
    virtual bool stepComplete(char const* phaseName, int32_t step) noexcept = 0;
 
    virtual void phaseFinish(char const* phaseName) noexcept = 0;
 
}; // class IProgressMonitor
} // namespace v_1_0
 
using IProgressMonitor = v_1_0::IProgressMonitor;
 
class IBuilderConfig : public INoCopy
{
public:
    virtual ~IBuilderConfig() noexcept = default;
 
    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();
    }
 
    TRT_DEPRECATED void setInt8Calibrator(IInt8Calibrator* calibrator) noexcept
    {
        mImpl->setInt8Calibrator(calibrator);
    }
 
    TRT_DEPRECATED IInt8Calibrator* getInt8Calibrator() const noexcept
    {
        return mImpl->getInt8Calibrator();
    }
 
    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();
    }
 
    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();
    }
 
    TRT_DEPRECATED bool setCalibrationProfile(IOptimizationProfile const* profile) noexcept
    {
        return mImpl->setCalibrationProfile(profile);
    }
 
    TRT_DEPRECATED 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);
    }
 
    void setPreviewFeature(PreviewFeature feature, bool enable) noexcept
    {
        mImpl->setPreviewFeature(feature, enable);
    }
 
    bool getPreviewFeature(PreviewFeature feature) const noexcept
    {
        return mImpl->getPreviewFeature(feature);
    }
 
    void setBuilderOptimizationLevel(int32_t level) noexcept
    {
        mImpl->setBuilderOptimizationLevel(level);
    }
 
    int32_t getBuilderOptimizationLevel() noexcept
    {
        return mImpl->getBuilderOptimizationLevel();
    }
 
    void setHardwareCompatibilityLevel(HardwareCompatibilityLevel hardwareCompatibilityLevel) noexcept
    {
        mImpl->setHardwareCompatibilityLevel(hardwareCompatibilityLevel);
    }
 
    HardwareCompatibilityLevel getHardwareCompatibilityLevel() const noexcept
    {
        return mImpl->getHardwareCompatibilityLevel();
    }
 
    void setPluginsToSerialize(char const* const* paths, int32_t nbPaths) noexcept
    {
        mImpl->setPluginsToSerialize(paths, nbPaths);
    }
 
    char const* getPluginToSerialize(int32_t index) const noexcept
    {
        return mImpl->getPluginToSerialize(index);
    }
 
    int32_t getNbPluginsToSerialize() const noexcept
    {
        return mImpl->getNbPluginsToSerialize();
    }
 
    void setMaxAuxStreams(int32_t nbStreams) noexcept
    {
        mImpl->setMaxAuxStreams(nbStreams);
    }
 
    int32_t getMaxAuxStreams() const noexcept
    {
        return mImpl->getMaxAuxStreams();
    }
 
    void setProgressMonitor(IProgressMonitor* monitor) noexcept
    {
        return mImpl->setProgressMonitor(monitor);
    }
 
    IProgressMonitor* getProgressMonitor() const noexcept
    {
        return mImpl->getProgressMonitor();
    }
 
    void setRuntimePlatform(RuntimePlatform runtimePlatform) noexcept
    {
        mImpl->setRuntimePlatform(runtimePlatform);
    }
 
    RuntimePlatform getRuntimePlatform() const noexcept
    {
        return mImpl->getRuntimePlatform();
    }
 
    void setMaxNbTactics(int32_t maxNbTactics) noexcept
    {
        mImpl->setMaxNbTactics(maxNbTactics);
    }
 
    int32_t getMaxNbTactics() const noexcept
    {
        return mImpl->getMaxNbTactics();
    }
 
protected:
    apiv::VBuilderConfig* mImpl;
};
 
using NetworkDefinitionCreationFlags = uint32_t;
 
enum class NetworkDefinitionCreationFlag : int32_t
{
    kEXPLICIT_BATCH TRT_DEPRECATED_ENUM = 0,
 
    kSTRONGLY_TYPED = 1,
};
 
template <>
constexpr inline int32_t EnumMax<NetworkDefinitionCreationFlag>() noexcept
{
    return 2;
}
 
class IBuilder : public INoCopy
{
public:
    virtual ~IBuilder() noexcept = default;
 
    TRT_DEPRECATED bool platformHasFastFp16() const noexcept
    {
        return mImpl->platformHasFastFp16();
    }
 
    TRT_DEPRECATED bool platformHasFastInt8() const noexcept
    {
        return mImpl->platformHasFastInt8();
    }
 
    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();
    }
 
    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();
    }
 
    TRT_DEPRECATED bool platformHasTf32() const noexcept
    {
        return mImpl->platformHasTf32();
    }
 
    nvinfer1::IHostMemory* buildSerializedNetwork(INetworkDefinition& network, IBuilderConfig& config) noexcept
    {
        return mImpl->buildSerializedNetwork(network, config);
    }
 
    nvinfer1::ICudaEngine* buildEngineWithConfig(INetworkDefinition& network, IBuilderConfig& config) noexcept
    {
        return mImpl->buildEngineWithConfig(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();
    }
 
    IPluginRegistry& getPluginRegistry() noexcept
    {
        return mImpl->getPluginRegistry();
    }
 
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 safe
{
class IPluginRegistry;
} // namespace safe
 
extern "C" TENSORRTAPI nvinfer1::safe::IPluginRegistry* getBuilderSafePluginRegistry(
    nvinfer1::EngineCapability capability) noexcept;
 
} // namespace nvinfer1
 
#endif // NV_INFER_H