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::core::schema::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::core::schema::FormalParameter and ::ONNX_LIGHT_NAMESPACE::core::schema::TypeConstraintParam, the building blocks used to describe input/output parameters and their type constraints.
::ONNX_LIGHT_NAMESPACE::core::schema::TensorType, an enumeration of every element-tensor, sequence-tensor, and optional-tensor type used in type constraints, together with ::ONNX_LIGHT_NAMESPACE::core::schema::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::core::schema::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_shapes shape inference library.

Constructing a schema with invalid arguments throws a ::ONNX_LIGHT_NAMESPACE::core::schema::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.

Maps the upstream compatibility macro to onnx-light’s explicit proto ABI annotation. This keeps declarations from vendored ONNX headers visible when lib_onnx_proto uses hidden visibility by default.

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 core

namespace schema#

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 TensorType = onnx_proto::TensorType #: Re-exports onnx_proto::TensorType so that existing consumers of core::schema::TensorType continue to compile without change.

using SchemaInputValue = std::variant<ValueInfoProto, symbolic::SymTensor, symbolic::SymSequence>#

One concrete value supplied for a node input when calling ::ONNX_LIGHT_NAMESPACE::core::schema::LightOpSchema::Verify, used to check the input against the schema’s type constraints. Exactly one alternative describes a given input:

ValueInfoProto — type/shape as it would appear in a GraphProto value_info entry. Tensor, sequence, and optional value_info types are all supported.
core::symbolic::SymTensor — a single tensor descriptor, as used by the onnx_shapes/onnx_optim optimisation stack.
core::symbolic::SymSequence — a tensor-sequence descriptor, as used by the same optimisation stack (e.g. the output of SequenceConstruct).

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#

Functions

inline constexpr 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).

inline constexpr const char *ToTypeString(TensorType type)#

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

Forwards to onnx_proto::ToTypeString; kept here so that existing callers of core::schema::ToTypeString continue to compile unchanged.

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.

void Verify(const NodeProto &node, const std::vector<std::optional<SchemaInputValue>> *inputs = nullptr) const#

Verifies that node is a valid instantiation of this operator schema, throwing ::ONNX_LIGHT_NAMESPACE::core::schema::SchemaError on the first violation found.

The checks performed are, in order:

node is not deprecated (deprecated() is false).
node.op_type() matches name(), and node.domain() matches domain() (an empty node domain is treated as ::ONNX_LIGHT_NAMESPACE::core::schema::kOnnxDomain).
node.output_size() lies within [min_output(), max_output()].
Every attribute in node.attribute() is recognized (declared in attributes(), or its name starts with "__", an internal-symbol convention that is always accepted), has a type() matching the declared ::ONNX_LIGHT_NAMESPACE::core::schema::AttributeType, and every required attribute (AttributeParam::required) is present.
When inputs is non-null, each populated (non-std::nullopt) entry is resolved to a ::ONNX_LIGHT_NAMESPACE::onnx_proto::TensorType and, if the corresponding formal input’s type names one of type_constraints(), checked for membership in that constraint’s allowed_type_strs. Entries beyond inputs().size() are checked against the last formal input (variadic convention), and entries whose concrete type cannot be determined (e.g. a ValueInfoProto with a map_type or opaque_type) are silently skipped, since LightOpSchema does not model every ONNX type category.

Input arity itself is intentionally not bounded here: unlike outputs, LightOpSchema does not track per-parameter Optional/Variadic metadata for inputs, so node may declare fewer or more inputs than inputs().size() without being rejected.

Parameters:

node – Node to verify against this schema. node.op_type()/node.domain() are expected to already match this schema (see above); callers are responsible for having selected the schema version matching the node’s opset import.
inputs – Optional, one entry per node input, describing its concrete type for type-constraint checking. When null (the default), no input type checking is performed.

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, or when ::ONNX_LIGHT_NAMESPACE::core::schema::LightOpSchema::Verify rejects a node.

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.