light_op_schema.h#

Declares the lightweight ONNX operator schema types used by onnx_light.

This header defines the core data structures that onnx_light uses to describe ONNX operators without depending on the full onnx library:

::ONNX_LIGHT_NAMESPACE::onnx_op::LightOpSchema, a read-only record that captures a single operator at a specific opset version (name, domain, since_version, documentation string, formal inputs and outputs, and type constraints).
::ONNX_LIGHT_NAMESPACE::onnx_op::FormalParameter and ::ONNX_LIGHT_NAMESPACE::onnx_op::TypeConstraintParam, the building blocks used to describe input/output parameters and their type constraints.
::ONNX_LIGHT_NAMESPACE::onnx_op::TensorType, an enumeration of every element-tensor, sequence-tensor, and optional-tensor type used in type constraints, together with ::ONNX_LIGHT_NAMESPACE::onnx_op::ToTypeString to convert it to the canonical ONNX type string (e.g. "tensor(float)").
A collection of helper functions returning common type sets reused across operator schemas (FloatTypes(), AllNumericTypes(), AllTensorTypes(), CastTypesVer*(), EqualTypesV*(), etc.).
::ONNX_LIGHT_NAMESPACE::onnx_op::StripDocs to obtain a memory-light copy of a schema list with documentation strings cleared, useful in memory-constrained environments.

The schemas produced by the helpers in the sibling operator_sets_*.h headers are aggregated by operator_sets.h via GetAllOnnxOpSchemasWithHistory() and consumed by both documentation generators and the onnx_optim shape inference library.

Constructing a schema with invalid arguments throws a ::ONNX_LIGHT_NAMESPACE::onnx_op::SchemaError.

namespace onnx_light

Alias that makes onnx-light headers compatible with code that references ONNX_LIGHT_NAMESPACE (the macro used in the standard onnx package).

Set to ONNX_LIGHT_NAMESPACE so both names resolve to the same namespace.

Symbol-visibility attribute for the public onnx-light C++ API.

Defined as empty because onnx-light does not require explicit __declspec(dllexport) or __attribute__((visibility("default"))) annotations — visibility is controlled at the shared-library level. The macro is provided so that vendored ONNX headers that decorate their declarations with ONNX_API compile without modification.

Namespace alias so that ONNX C++ code (and consumers such as onnxruntime) that refers to the literal onnx namespace — rather than the ONNX_NAMESPACE macro — resolves to the onnx-light namespace. The standard onnx package lives in namespace onnx; onnx-light uses onnx_light (via ONNX_LIGHT_NAMESPACE), so this alias keeps onnx-light a true drop-in. It is only introduced when the onnx-light namespace differs from onnx.

namespace onnx_op#

Typedefs

using AttributeDefault = std::variant<std::monostate, int64_t, double, std::string, std::vector<int64_t>, std::vector<double>, std::vector<std::string>>#

Typed default value carried by an :class:AttributeParam.

Mirrors the subset of onnx::AttributeProto value fields that can sensibly be expressed as a literal default in an operator schema:

std::monostate — no default value (the attribute is required or has no documented default).
int64_t — default for AttributeType::INT (also used for boolean-valued INT attributes; 0/1).
double — default for AttributeType::FLOAT.
std::string — default for AttributeType::STRING.
std::vector<int64_t>/std::vector<double>/std::vector<std::string> — defaults for INTS/FLOATS/STRINGS.

TENSOR/GRAPH/SPARSE_TENSOR/TYPE_PROTO attributes have no literal default in practice and are therefore represented as std::monostate.

using SchemaBuilder = std::function<std::vector<LightOpSchema>()>#: Type of a builder function that produces the versioned schema history for a single ONNX operator. Each per-domain GetAllOnnxOp*SchemasWithHistory function maintains a static std::map<std::string, SchemaBuilder> keyed by op_type so that, when a caller requests a specific operator, only the matching builder runs instead of constructing the entire domain. This mirrors the dispatch-table pattern used by the shape-inference subsystem.

Enums

enum class AttributeType : int32_t#

Enumeration of attribute scalar/list types supported by ONNX.

The enumerator values mirror onnx::AttributeProto::AttributeType so an AttributeType from onnx_op can be compared against (or converted to) the proto enum without a lookup table. The enumeration is duplicated here so that onnx_op remains free of any dependency on the full ONNX schema registry.

Values:

enumerator UNDEFINED#

enumerator FLOAT#

enumerator INT#

enumerator STRING#

enumerator TENSOR#

enumerator GRAPH#

enumerator FLOATS#

enumerator INTS#

enumerator STRINGS#

enumerator TENSORS#

enumerator GRAPHS#

enumerator SPARSE_TENSOR#

enumerator SPARSE_TENSORS#

enumerator TYPE_PROTO#

enumerator TYPE_PROTOS#

enum class TensorType : uint8_t#

Identifies an element or sequence tensor type supported by onnx-light.

Each enumerator corresponds to a concrete ONNX element type or to a sequence-of-tensor or optional-tensor type used in type-constraint definitions. The mapping from an enumerator to its canonical ONNX type string is implemented exhaustively by ToTypeString(); the naming convention is:

kXxx"tensor(xxx)", e.g. kFloat"tensor(float)", kInt64"tensor(int64)", kBfloat16"tensor(bfloat16)".
kSeqXxx"seq(tensor(xxx))", e.g. kSeqFloat"seq(tensor(float))". The two map-valued sequences are kSeqMapStringFloat"seq(map(string, float))" and kSeqMapInt64Float"seq(map(int64, float))".
kMapXxxYyy"map(xxx, yyy)", e.g. kMapStringInt64"map(string, int64)". Used for operators like DictVectorizer whose inputs are dictionaries.
kOptXxx"optional(tensor(xxx))" and kOptSeqXxx"optional(seq(tensor(xxx)))".
kUndefined"tensor(undefined)".

Values:

enumerator kBool#

enumerator kString#

enumerator kUint8#

enumerator kUint16#

enumerator kUint32#

enumerator kUint64#

enumerator kInt8#

enumerator kInt16#

enumerator kInt32#

enumerator kInt64#

enumerator kFloat16#

enumerator kFloat#

enumerator kDouble#

enumerator kBfloat16#

enumerator kFloat8e4m3fn#

enumerator kFloat8e4m3fnuz#

enumerator kFloat8e5m2#

enumerator kFloat8e5m2fnuz#

enumerator kFloat8e8m0#

enumerator kFloat4e2m1#

enumerator kUint4#

enumerator kInt4#

enumerator kUint2#

enumerator kInt2#

enumerator kComplex64#

enumerator kComplex128#

enumerator kSeqBool#

enumerator kSeqString#

enumerator kSeqUint8#

enumerator kSeqUint16#

enumerator kSeqUint32#

enumerator kSeqUint64#

enumerator kSeqInt8#

enumerator kSeqInt16#

enumerator kSeqInt32#

enumerator kSeqInt64#

enumerator kSeqFloat16#

enumerator kSeqFloat#

enumerator kSeqDouble#

enumerator kSeqComplex64#

enumerator kSeqComplex128#

enumerator kSeqMapStringFloat#

enumerator kSeqMapInt64Float#

enumerator kMapStringInt64#

enumerator kMapInt64String#

enumerator kMapInt64Float#

enumerator kMapInt64Double#

enumerator kMapStringFloat#

enumerator kMapStringDouble#

enumerator kOptSeqBool#

enumerator kOptSeqString#

enumerator kOptSeqUint8#

enumerator kOptSeqUint16#

enumerator kOptSeqUint32#

enumerator kOptSeqUint64#

enumerator kOptSeqInt8#

enumerator kOptSeqInt16#

enumerator kOptSeqInt32#

enumerator kOptSeqInt64#

enumerator kOptSeqFloat16#

enumerator kOptSeqFloat#

enumerator kOptSeqDouble#

enumerator kOptSeqComplex64#

enumerator kOptSeqComplex128#

enumerator kOptBool#

enumerator kOptString#

enumerator kOptUint8#

enumerator kOptUint16#

enumerator kOptUint32#

enumerator kOptUint64#

enumerator kOptInt8#

enumerator kOptInt16#

enumerator kOptInt32#

enumerator kOptInt64#

enumerator kOptFloat16#

enumerator kOptFloat#

enumerator kOptDouble#

enumerator kOptComplex64#

enumerator kOptComplex128#

enumerator kUndefined#

Functions

const char *AttributeType_Name(AttributeType t)#: Returns the canonical ONNX name for an AttributeType (e.g. "INTS").

std::string AttributeDefaultRepr(const AttributeDefault &d)#: Returns a stable textual representation of an AttributeDefault (e.g. "1", "0.5", "foo", "[1, 2, 3]", or "" for monostate).

const char *ToTypeString(TensorType type)#

Returns the ONNX type-string representation of a TensorType value.

Parameters:: type – Tensor type enumerator to convert.
Returns:: Null-terminated string such as "tensor(float)" or "seq(tensor(int64))".

std::vector<TensorType> FloatTypes()#: Returns floating-point tensor types (float16, float, double, bfloat16).

std::vector<TensorType> NumericTypesForMathReduction()#: Returns numeric types used in reduction ops (excludes low-precision floats).

std::vector<TensorType> NumericTypesForMathReductionIr4()#: Returns numeric types used in reduction ops for IR version 4 and later.

std::vector<TensorType> AllNumericTypes()#: Returns all numeric (integer and floating-point) tensor types.

std::vector<TensorType> AllNumericTypesIr4()#: Returns all numeric tensor types for IR version 4 and later.

std::vector<TensorType> AllTensorTypes()#: Returns all scalar tensor types (no sequence types).

std::vector<TensorType> AllTensorSequenceTypes()#: Returns all sequence-of-tensor types.

std::vector<TensorType> AllOptionalTypes()#: Returns all optional tensor and optional sequence tensor types. Matches OpSchema::all_optional_types() from the full ONNX library.

std::vector<TensorType> CastTypesVer1And6()#: Returns the Cast input/output types valid for opset versions 1 and 6.

std::vector<TensorType> CastTypesVer9()#: Returns the Cast input/output types valid from opset version 9.

std::vector<TensorType> CastTypesVer13()#: Returns the Cast input/output types valid from opset version 13.

std::vector<TensorType> CastTypesVer19()#: Returns the Cast input/output types valid from opset version 19.

std::vector<TensorType> CastTypesVer21()#: Returns the Cast input/output types valid from opset version 21.

std::vector<TensorType> CastTypesVer23()#: Returns the Cast input/output types valid from opset version 23.

std::vector<TensorType> CastTypesVer24()#: Returns the Cast input/output types valid from opset version 24.

std::vector<TensorType> CastTypesVer25()#: Returns the Cast input/output types valid from opset version 25.

std::vector<TensorType> EqualTypesV1V7()#: Returns the Equal input types valid for opset versions 1 and 7.

std::vector<TensorType> EqualTypesV11()#: Returns the Equal input types valid from opset version 11.

std::vector<TensorType> EqualTypesV13()#: Returns the Equal input types valid from opset version 13.

std::vector<TensorType> EqualTypesV19()#: Returns the Equal input types valid from opset version 19.

std::vector<TensorType> ConcatTypesVer1()#: Returns the Concat input/output types valid for opset version 1 (float16, float, double).

std::vector<TensorType> ConcatTypesVer4And11()#: Returns the Concat input/output types valid for opset versions 4 and 11 (matches OpSchema::all_tensor_types() from the full ONNX library).

std::vector<TensorType> ConcatTypesVer13()#: Returns the Concat input/output types valid from opset version 13 (matches OpSchema::all_tensor_types_ir4() from the full ONNX library).

std::vector<LightOpSchema> StripDocs(const std::vector<LightOpSchema> &schemas)#: Returns a copy of schemas with all documentation strings replaced by an empty string. Useful when callers want the schema metadata but do not need documentation, saving memory in memory-constrained environments.

std::vector<LightOpSchema> CollectSchemasFromBuilders(const std::map<std::string, SchemaBuilder> &builders, const std::string &op_type, bool init_doc)#: Invokes builders from a name → SchemaBuilder map and concatenates their results. When op_type is empty, every builder is invoked (in alphabetical order of keys when builders is a std::map). When op_type is non-empty, only the builder whose key equals op_type is invoked (returning an empty vector if absent). If init_doc is false, the resulting schemas have their documentation strings stripped (see StripDocs).

Variables

constexpr const char *kOnnxDomain = "ai.onnx"#: The standard ONNX operator domain string.

struct AttributeParam#

#include <light_op_schema.h>

Describes a single operator attribute as exposed by LightOpSchema.

Attribute metadata is intentionally lightweight to keep onnx_op free of any dependency on the full ONNX schema registry. The type field uses the AttributeType enumeration above; default_value is a typed variant (see :type:AttributeDefault) and is std::monostate when the attribute is required or has no documented default.

Public Members

std::string name#: Attribute name as it appears in the ONNX spec.

std::string description#: Human-readable description of the attribute.

AttributeType type#: Attribute type (mirrors onnx::AttributeProto::AttributeType).

bool required#: True if the attribute is required (no default value).

AttributeDefault default_value#: Typed default value (std::monostate when required or absent).

struct FormalParameter#

#include <light_op_schema.h>

Describes a single formal input or output parameter of an ONNX operator.

Public Members

std::string name#: Parameter name as it appears in the ONNX spec.

std::string description#: Human-readable description of the parameter.

std::string type#: Type-constraint identifier string (e.g. “T”, “T1”).

class LightOpSchema#

#include <light_op_schema.h>

Lightweight, read-only description of an ONNX operator schema at one specific opset version.

A LightOpSchema captures everything that documentation and validation tools need about a single versioned operator: its name, domain, the opset version it was introduced in, its documentation string, the formal inputs and outputs, and the type constraints that govern them.

Public Types

enum class NodeDeterminism : uint8_t#

Describes whether evaluating the operator produces deterministic outputs.

Mirrors OpSchema::NodeDeterminism from the full ONNX library.

Values:

enumerator Unknown#: Determinism has not been specified for this operator.

enumerator NonDeterministic#: The operator may produce different outputs for identical inputs.

enumerator Deterministic#: The operator always produces the same outputs for identical inputs.

Public Functions

inline LightOpSchema(std::string name, std::string domain, int since_version, std::string doc, std::vector<FormalParameter> inputs, std::vector<FormalParameter> outputs, std::vector<TypeConstraintParam> type_constraints, bool has_function_implementation = false, bool init_doc = true)#

Constructs a schema record for a versioned ONNX operator.

Parameters:

name – Operator name (e.g. “Add”).
domain – Operator domain (e.g. “ai.onnx”).
since_version – Opset version at which this schema was introduced.
doc – Documentation string (may contain Markdown).
inputs – Ordered list of formal input parameters.
outputs – Ordered list of formal output parameters.
type_constraints – Type constraints referenced by the parameters.
has_function_implementation – Whether the op has a function body.
init_doc – If true (default), the documentation string is stored on the schema. When false, the doc argument is discarded and doc() returns an empty string. This can be used to save memory when documentation is not needed by the consumer.

inline LightOpSchema(std::string name, std::string domain, int since_version, std::string doc, std::vector<FormalParameter> inputs, std::vector<FormalParameter> outputs, std::vector<TypeConstraintParam> type_constraints, std::vector<AttributeParam> attributes, bool has_function_implementation = false, bool init_doc = true)#

Constructs a schema record for a versioned ONNX operator with attributes.

Same as the other constructor but also stores the operator’s attribute metadata, which the documentation generator uses to surface cross-version attribute differences.

inline const std::string &name() const#: Returns the operator name.

inline const std::string &domain() const#: Returns the operator domain.

inline int since_version() const#: Returns the opset version at which this schema was introduced.

inline const std::string &doc() const#: Returns the operator documentation string.

inline const std::vector<FormalParameter> &inputs() const#: Returns the list of formal input parameters.

inline const std::vector<FormalParameter> &outputs() const#: Returns the list of formal output parameters.

inline const std::vector<TypeConstraintParam> &type_constraints() const#: Returns the type constraints for this schema.

inline const std::vector<AttributeParam> &attributes() const#: Returns the operator attributes (may be empty when not populated).

inline bool has_function_implementation() const#: Returns true if the operator has a function body implementation.

inline int min_output() const#: Returns the minimum number of outputs supported by this operator. Defaults to outputs().size(); can be overridden via set_min_output for operators with variadic outputs.

inline int max_output() const#: Returns the maximum number of outputs supported by this operator. Defaults to outputs().size(); can be overridden via set_max_output for operators with variadic outputs (use std::numeric_limits<int>::max() for unbounded variadic outputs).

inline bool deprecated() const#: Returns true if this versioned operator is deprecated.

inline NodeDeterminism node_determinism() const#: Returns the operator’s node determinism (Unknown when unspecified).

inline bool non_deterministic() const#: Returns true if the operator is explicitly marked non-deterministic.

inline LightOpSchema &set_min_output(int v)#: Sets the minimum number of outputs. Returns *this for chaining.

inline LightOpSchema &set_max_output(int v)#: Sets the maximum number of outputs. Returns *this for chaining.

inline LightOpSchema &set_deprecated(bool v = true)#: Marks this operator as deprecated. Returns *this for chaining.

inline LightOpSchema &set_node_determinism(NodeDeterminism v)#: Sets the operator’s node determinism. Returns *this for chaining.

Private Members

std::string name_#

std::string domain_#

int since_version_#

std::string doc_#

std::vector<FormalParameter> inputs_#

std::vector<FormalParameter> outputs_#

std::vector<TypeConstraintParam> type_constraints_#

std::vector<AttributeParam> attributes_#

bool has_function_implementation_#

int min_output_#

int max_output_#

bool deprecated_#

NodeDeterminism node_determinism_ = NodeDeterminism::Unknown #

class SchemaError : public std::runtime_error#

#include <light_op_schema.h>

Thrown when a LightOpSchema is constructed with invalid arguments.

Public Functions

inline explicit SchemaError(const std::string &message)#: Constructs a SchemaError with the given diagnostic message.

struct TypeConstraintParam#

#include <light_op_schema.h>

Specifies which tensor types are permitted for a named type parameter.

Public Members

std::string type_param_str#: Type-parameter identifier (e.g. “T”).

std::vector<TensorType> allowed_type_strs#: Set of tensor types that satisfy this constraint.

std::string description#: Human-readable description of the constraint.