NvInfer.h

前往此文件的文档。

/*
 * SPDX-FileCopyrightText: Copyright (c) 1993-2025 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
 *
 * https://apache.ac.cn/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,
 kCUMULATIVE = 49,
 kDYNAMIC_QUANTIZE = 50
};
 
template <>
constexpr inline int32_t EnumMax<LayerType>() noexcept
{
 return 51;
}
 
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, // SAME_UPPER
 kSAME_LOWER = 3, // SAME_LOWER
};
 
namespace impl // 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 // 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 TRT_DEPRECATED 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();
    }
 
    //
/* 使用 ILayer::setInput; */ 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
{
返回 2;
}
 
class ITopKLayer : public ILayer
{
public
 void setOperation(TopKOperation op) noexcept
    {
 mImpl->setOperation(op);
    }
 
 TopKOperation getOperation() const noexcept
    {
返回 mImpl->getOperation();
    }
 
 void setK(int32_t k) noexcept
    {
 mImpl->setK(k);
    }
 
 int32_t getK() const noexcept
    {
返回 mImpl->getK();
    }
 
 void setReduceAxes(uint32_t reduceAxes) noexcept
    {
 mImpl->setReduceAxes(reduceAxes);
    }
 
 uint32_t getReduceAxes() const noexcept
    {
返回 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
{
返回 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
    {
返回 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
    {
返回 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
    {
返回 mImpl->getWeights();
    }
 
 void setDimensions(Dims const& dimensions) noexcept
    {
 mImpl->setDimensions(dimensions);
    }
 
 Dims getDimensions() const noexcept
    {
返回 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
    {
返回 mImpl->setOutputDimensions(dimensions);
    }
 
 Dims getOutputDimensions() const noexcept
    {
返回 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
    {
返回 mImpl->getScales(size, scales);
    }
 
 void setResizeMode(InterpolationMode interpolationMode) noexcept
    {
 mImpl->setResizeMode(interpolationMode);
    }
 
 InterpolationMode getResizeMode() const noexcept
    {
返回 mImpl->getResizeMode();
    }
 
 using ILayer::setInput;
 
 void setCoordinateTransformation(ResizeCoordinateTransformation coordTransform) noexcept
    {
 mImpl->setCoordinateTransformation(coordTransform);
    }
 
 ResizeCoordinateTransformation getCoordinateTransformation() const noexcept
    {
返回 mImpl->getCoordinateTransformation();
    }
 
 void setSelectorForSinglePixel(ResizeSelector selector) noexcept
    {
 mImpl->setSelectorForSinglePixel(selector);
    }
 
 ResizeSelector getSelectorForSinglePixel() const noexcept
    {
返回 mImpl->getSelectorForSinglePixel();
    }
 
 void setNearestRounding(ResizeRoundMode value) noexcept
    {
 mImpl->setNearestRounding(value);
    }
 
 ResizeRoundMode getNearestRounding() const noexcept
    {
返回 mImpl->getNearestRounding();
    }
 
 void setCubicCoeff(float A) noexcept
    {
 mImpl->setCubicCoeff(A);
    }
 
 float getCubicCoeff() const noexcept
    {
返回 mImpl->getCubicCoeff();
    }
 
 void setExcludeOutside(bool excludeFlag) noexcept
    {
 mImpl->setExcludeOutside(excludeFlag);
    }
 
 bool getExcludeOutside() const noexcept
    {
返回 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
{
返回 3;
}
 
enum class TripLimit : int32_t
{
 
 kCOUNT = 0,
 kWHILE = 1
};
 
template <>
constexpr inline int32_t EnumMax<TripLimit>() noexcept
{
返回 2;
}
 
class ILoop;
 
class ILoopBoundaryLayer : public ILayer
{
public
 ILoop* getLoop() const noexcept
    {
返回 mBoundary->getLoop();
    }
 
protected
 virtual ~ILoopBoundaryLayer() noexcept = default;
 apiv::VLoopBoundaryLayer* mBoundary;
};
 
class IIfConditionalBoundaryLayer : public ILayer
{
public
 IIfConditional* getConditional() const noexcept
    {
返回 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

    {
  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 IDynamicQuantizeLayer : public ILayer
{
public
 using ILayer::setInput;
 
 void setToType(DataType toType) noexcept
    {
 mImpl->setToType(toType);
    }
 
 DataType getToType() const noexcept
    {
 return mImpl->getToType();
    }
 
 void setScaleType(DataType scaleType) noexcept
    {
 mImpl->setScaleType(scaleType);
    }
 
 DataType getScaleType() const noexcept
    {
 return mImpl->getScaleType();
    }
 
 void setAxis(int32_t axis) noexcept
    {
 mImpl->setAxis(axis);
    }
 
 int32_t getAxis() const noexcept
    {
 return mImpl->getAxis();
    }
 
 void setBlockSize(int32_t size) noexcept
    {
 mImpl->setBlockSize(size);
    }
 
 int32_t getBlockSize() const noexcept
    {
 return mImpl->getBlockSize();
    }
 
protected
 virtual ~IDynamicQuantizeLayer() noexcept = default;
 apiv::VDynamicQuantizeLayer* 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;
};
 
enum class CumulativeOperation : int32_t
{
 kSUM = 0,
};
 
namespace impl
{
 
template <>
struct EnumMaxImpl<CumulativeOperation>
{
 static constexpr int32_t kVALUE = 1;
};
 
} // namespace impl
 
class ICumulativeLayer : public ILayer
{
public
 bool setOperation(CumulativeOperation op) noexcept
    {
 return mImpl->setOperation(op);
    }
 
 CumulativeOperation getOperation() const noexcept
    {
 return mImpl->getOperation();
    }
 
 void setExclusive(bool exclusive) noexcept
    {
 mImpl->setExclusive(exclusive);
    }
 
 bool getExclusive() const noexcept
    {
 return mImpl->getExclusive();
    }
 
 void setReverse(bool reverse) noexcept
    {
 mImpl->setReverse(reverse);
    }
 
 bool getReverse() const noexcept
    {
 return mImpl->getReverse();
    }
 
protected
 apiv::VCumulativeLayer* mImpl;
 virtual ~ICumulativeLayer() 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);
    }
 
 TRT_DEPRECATED 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
    {
7637 return mImpl->addFill(dimensions, op);
    }
 
 IFillLayer* addFill(Dims const& dimensions, FillOperation op, DataType outputType) noexcept
    {
7663 return mImpl->addFillV2(dimensions, op, outputType);
    }
 
 IPaddingLayer* addPaddingNd(ITensor& input, Dims const& prePadding, Dims const& postPadding) noexcept
    {
7679 return mImpl->addPaddingNd(input, prePadding, postPadding);
    }
 
 bool setWeightsName(Weights weights, char const* name) noexcept
    {
7703 return mImpl->setWeightsName(weights, name);
    }
 
    //
 void setErrorRecorder(IErrorRecorder* recorder) noexcept
    {
7722 mImpl->setErrorRecorder(recorder);
    }
 
 IErrorRecorder* getErrorRecorder() const noexcept
    {
7737 return mImpl->getErrorRecorder();
    }
 
 TRT_DEPRECATED IDequantizeLayer* addDequantize(ITensor& input, ITensor& scale) noexcept
    {
7758 return mImpl->addDequantize(input, scale);
    }
 
 IDequantizeLayer* addDequantize(ITensor& input, ITensor& scale, DataType outputType) noexcept
    {
7779 return mImpl->addDequantizeV2(input, scale, outputType);
    }
 
 IScatterLayer* addScatter(ITensor& data, ITensor& indices, ITensor& updates, ScatterMode mode) noexcept
    {
7799 return mImpl->addScatter(data, indices, updates, mode);
    }
 
 TRT_DEPRECATED IQuantizeLayer* addQuantize(ITensor& input, ITensor& scale) noexcept
    {
7820 return mImpl->addQuantize(input, scale);
    }
 
 IQuantizeLayer* addQuantize(ITensor& input, ITensor& scale, DataType outputType) noexcept
    {
7841 return mImpl->addQuantizeV2(input, scale, outputType);
    }
 
 IDynamicQuantizeLayer* addDynamicQuantize(
7866 ITensor& input, int32_t axis, int32_t blockSize, DataType outputType, DataType scaleType) noexcept
    {
7868 return mImpl->addDynamicQuantize(input, axis, blockSize, outputType, scaleType);
    }
 
 IEinsumLayer* addEinsum(ITensor* const* inputs, int32_t nbInputs, char const* equation) noexcept
    {
7883 return mImpl->addEinsum(inputs, nbInputs, equation);
    }
 
 IGridSampleLayer* addGridSample(ITensor& input, ITensor& grid) noexcept
    {
7901 return mImpl->addGridSample(input, grid);
    }
 
 INMSLayer* addNMS(ITensor& boxes, ITensor& scores, ITensor& maxOutputBoxesPerClass) noexcept
    {
7919 return mImpl->addNMS(boxes, scores, maxOutputBoxesPerClass);
    }
 
 IReverseSequenceLayer* addReverseSequence(ITensor& input, ITensor& sequenceLens) noexcept
    {
7936 return mImpl->addReverseSequence(input, sequenceLens);
    }
 
 INormalizationLayer* addNormalization(ITensor& input, ITensor& scale, ITensor& bias, uint32_t axesMask) noexcept
    {
7962 return mImpl->addNormalization(input, scale, bias, axesMask);
    }
 
 ICumulativeLayer* addCumulative(ITensor& input, ITensor& axis, CumulativeOperation operation, bool exclusive, bool reverse) noexcept
    {
7984 return mImpl->addCumulative(input, axis, operation, exclusive, reverse);
    }
 
 virtual IBuilder& getBuilder() const noexcept
    {
7995 return mImpl->getBuilder();
    }
 
 bool markWeightsRefittable(char const* name) noexcept
    {
8008 return mImpl->markWeightsRefittable(name);
    }
 
 bool unmarkWeightsRefittable(char const* name) noexcept
    {
8020 return mImpl->unmarkWeightsRefittable(name);
    }
 
 bool areWeightsMarkedRefittable(char const* name) const noexcept
    {
8033 return mImpl->areWeightsMarkedRefittable(name);
    }
 
 ISqueezeLayer* addSqueeze(ITensor& input, ITensor& axes) noexcept
    {
8052 return mImpl->addSqueeze(input, axes);
    }
 
 IUnsqueezeLayer* addUnsqueeze(ITensor& input, ITensor& axes) noexcept
    {
8073 return mImpl->addUnsqueeze(input, axes);
    }
 
protected
 apiv::VNetworkDefinition* mImpl;
};
 
enum class CalibrationAlgoType : int32_t
{
 kLEGACY_CALIBRATION = 0, //< 传统校准算法。
 kENTROPY_CALIBRATION = 1, //< 熵校准算法。
 kENTROPY_CALIBRATION_2 = 2, //< 熵校准算法版本 2。
 kMINMAX_CALIBRATION = 3, //< 最小值-最大值校准算法。
};
 
template <>
constexpr inline int32_t EnumMax<CalibrationAlgoType>() noexcept
{
8103 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
    {
8193 return InterfaceInfo{"IInt8EntropyCalibrator", 1, 0};
    }
 
 CalibrationAlgoType getAlgorithm() noexcept override
    {
8201 return CalibrationAlgoType::kENTROPY_CALIBRATION;
    }
 
 ~IInt8EntropyCalibrator() noexcept override = default;
};
8206 } // 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
    {
8233 return InterfaceInfo{"IInt8EntropyCalibrator2", 1, 0};
    }
 
 CalibrationAlgoType getAlgorithm() noexcept override
    {
8241 return CalibrationAlgoType::kENTROPY_CALIBRATION_2;
    }
 
 ~IInt8EntropyCalibrator2() noexcept override = default;
};
8246 } // 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
    {
8273 return InterfaceInfo{"IInt8MinMaxCalibrator", 1, 0};
    }
 
 CalibrationAlgoType getAlgorithm() noexcept override
    {
8281 return CalibrationAlgoType::kMINMAX_CALIBRATION;
    }
 
 ~IInt8MinMaxCalibrator() noexcept override = default;
};
8286 } // 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
    {
8312 return InterfaceInfo{"IInt8Calibrator", 1, 0};
    }
 
 CalibrationAlgoType getAlgorithm() noexcept override
    {
8320 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;
};
8365 } // namespace v_1_0
 
using IInt8LegacyCalibrator = v_1_0::IInt8LegacyCalibrator;
 
class TRT_DEPRECATED 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 TRT_DEPRECATED 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 TRT_DEPRECATED 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 TRT_DEPRECATED 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 TRT_DEPRECATED 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,
 
 kFP4 = 26,
 
 kEDITABLE_TIMING_CACHE = 27,
};
 
template <>
constexpr inline int32_t EnumMax<BuilderFlag>() noexcept
{
 return 28;
}
 
namespace v_1_0
{
struct TimingCacheKey
{
 uint8_t data[16];
};
 
struct TimingCacheValue
{
 uint64_t tacticHash;
 float timingMSec;
 static constexpr uint64_t kINVALID_TACTIC_HASH = UINT64_MAX;
};
} // namespace v_1_0
 
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();
    }
 
 int64_t queryKeys(TimingCacheKey* keyBuffer, int64_t capacity) const noexcept
    {
 return mImpl->queryKeys(keyBuffer, capacity);
    }
 
 TimingCacheValue query(TimingCacheKey const& key) const noexcept
    {
 return mImpl->query(key);
    }
 
 bool update(TimingCacheKey const& key, TimingCacheValue const& value) noexcept
    {
 return mImpl->update(key, value);
    }
 
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
 
enum class TilingOptimizationLevel : int32_t
{
 kNONE = 0,
 
 kFAST = 1,
 
 kMODERATE = 2,
 
 kFULL = 3
 
};
 
namespace impl
{
template <>
struct EnumMaxImpl<TilingOptimizationLevel>
{
 static constexpr int32_t kVALUE = 4;
};
} // 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
 
 virtual bool stepComplete(char const* phaseName, int32_t step) noexcept
 
 virtual void phaseFinish(char const* phaseName) noexcept
 
}; // 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();
    }
 
 TRT_DEPRECATED void setAlgorithmSelector(IAlgorithmSelector* selector) noexcept
    {
 mImpl->setAlgorithmSelector(selector);
    }
 
 TRT_DEPRECATED 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();
    }
 
 bool setTilingOptimizationLevel(TilingOptimizationLevel level) noexcept
    {
 return mImpl->setTilingOptimizationLevel(level);
    }
 
 TilingOptimizationLevel getTilingOptimizationLevel() const noexcept
    {
 return mImpl->getTilingOptimizationLevel();
    }
 
 bool setL2LimitForTiling(int64_t size) noexcept
    {
 return mImpl->setL2LimitForTiling(size);
    }
 
 int64_t getL2LimitForTiling() const noexcept
    {
 return mImpl->getL2LimitForTiling();
    }
 
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);
    }
 
 [[nodiscard]] nvinfer1::IBuilderConfig* createBuilderConfig() noexcept
    {
 return mImpl->createBuilderConfig();
    }
 
 [[nodiscard]] nvinfer1::INetworkDefinition* createNetworkV2(NetworkDefinitionCreationFlags flags) noexcept
    {
 return mImpl->createNetworkV2(flags);
    }
 
 [[nodiscard]] 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