onnx 1.17.0__cp311-cp311-win_amd64.whl → 1.18.0__cp311-cp311-win_amd64.whl

onnx/common/ir.h

@@ -9,16 +9,13 @@
 
 #pragma once
 
-#include <stdint.h>
-
 #include <algorithm>
-#include <atomic>
+#include <array>
 #include <cstdint>
 #include <functional>
 #include <iostream>
 #include <limits>
 #include <memory>
-#include <set>
 #include <sstream>
 #include <string>
 #include <unordered_set>
@@ -65,11 +62,11 @@ struct Value;
 
 class ResourceGuard final {
   std::function<void()> destructor_;
-  bool released_;
+  bool released_{false};
 
  public:
   ONNX_DISALLOW_COPY_AND_ASSIGN(ResourceGuard);
-  explicit ResourceGuard(std::function<void()> destructor) : destructor_(std::move(destructor)), released_(false) {}
+  explicit ResourceGuard(std::function<void()> destructor) : destructor_(std::move(destructor)) {}
   ResourceGuard(ResourceGuard&& other) = default;
   ResourceGuard& operator=(ResourceGuard&& other) = default;
 
@@ -134,10 +131,10 @@ struct ScalarAttributeValue final : public AttributeValue {
   ValueType& value() {
     return value_;
   }
-  virtual Ptr clone() const override {
-    return Ptr(new ScalarAttributeValue(name, value_));
+  Ptr clone() const override {
+    return std::make_unique<ScalarAttributeValue>(name, value_);
   }
-  virtual AttributeKind kind() const override {
+  AttributeKind kind() const override {
     return Kind;
   }
 
@@ -149,16 +146,15 @@ template <typename T, AttributeKind Kind>
 struct VectorAttributeValue final : public AttributeValue {
   using ConstructorType = const std::vector<T>&&;
   using ValueType = std::vector<T>;
-  VectorAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {}
+  VectorAttributeValue(Symbol name, ValueType value_) : AttributeValue(name), value_(std::move(value_)) {}
   ValueType& value() {
     return value_;
   }
-  virtual AttributeKind kind() const override {
+  AttributeKind kind() const override {
     return Kind;
   }
-  virtual std::unique_ptr<AttributeValue> clone() const override {
-    auto copy = value_;
-    return Ptr(new VectorAttributeValue(name, std::move(copy)));
+  std::unique_ptr<AttributeValue> clone() const override {
+    return std::make_unique<VectorAttributeValue>(name, ValueType(value_));
   }
 
  private:
@@ -184,7 +180,8 @@ using TypeProtosAttr = VectorAttributeValue<TypeProto, AttributeKind::tps>;
 // we return Derived* pointers because Nodes are normally held as pointers.
 template <typename Derived>
 struct Attributes {
-  Attributes() {}
+  Attributes() = default;
+
   void copyAttributes(const Attributes& rhs) {
     values_.clear();
     values_.reserve(rhs.values_.size());
@@ -243,7 +240,7 @@ struct Attributes {
   template <typename T>
   Derived* set(Symbol name, typename T::ConstructorType v) {
     auto it = find(name, false);
-    auto nv = AVPtr(new T(name, std::forward<typename T::ConstructorType>(v)));
+    auto nv = std::make_unique<T>(name, std::forward<typename T::ConstructorType>(v));
     if (it == values_.end()) {
       values_.push_back(std::move(nv));
     } else {
@@ -317,10 +314,10 @@ struct Value final {
   size_t unique_ = 0; // unique id
   size_t stage_ = 0; // 0-forward, 1-backward, 2-double-backward,...
   use_list uses_in_current_graph_;
-  bool has_unique_name_;
+  bool has_unique_name_{false};
   std::string unique_name_;
-  int32_t elem_type_;
-  bool has_sizes_;
+  int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED};
+  bool has_sizes_{false};
   std::vector<Dimension> sizes_;
 
  public:
@@ -378,7 +375,7 @@ struct Value final {
   Graph* owningGraph();
   const Graph* owningGraph() const;
   // TODO: make this more const correct
-  const use_list uses() const;
+  use_list uses() const;
 
   // Replaces all uses of this node with 'newValue'.
   //
@@ -391,7 +388,7 @@ struct Value final {
   //          %5 = h(%6, %6)
   void replaceAllUsesWith(Value* newValue);
 
-  Value* copyMetadata(Value* from) {
+  Value* copyMetadata(const Value* from) {
     setElemType(from->elemType());
     setSizes(from->sizes());
     if (from->has_unique_name()) {
@@ -419,7 +416,7 @@ struct Node : public Attributes<Node> {
   // using an array to allow the same iterator class for forward and reverse node lists
   // This list represents a topological sort
 
-  Node* next_in_graph[2] = {nullptr, nullptr};
+  std::array<Node*, 2> next_in_graph{nullptr, nullptr};
   Node*& next() {
     return next_in_graph[kNextDirection];
   }
@@ -438,13 +435,13 @@ struct Node : public Attributes<Node> {
   std::vector<Value*> outputs_;
   Graph* graph_;
   size_t stage_;
-  bool has_name_;
+  bool has_name_{false};
   std::string name_;
-  bool has_domain_;
+  bool has_domain_{false};
   std::string domain_;
-  bool has_doc_string_;
+  bool has_doc_string_{false};
   std::string doc_string_;
-  bool has_overload_;
+  bool has_overload_{false};
   std::string overload_;
 
  protected:
@@ -732,7 +729,7 @@ struct Node : public Attributes<Node> {
   }
 
   // Check whether this node is before node n in the graph.
-  bool isBefore(Node* n);
+  bool isBefore(const Node* n);
 
   // iterators of the node list starting at this node
   // useful for resuming a search starting at this node
@@ -842,7 +839,7 @@ class OpSetID final {
   // Default Domain Constructor
   explicit OpSetID(const int64_t version) : domain_(""), version_(version) {}
 
-  explicit OpSetID(const std::string& domain, int64_t version) : domain_(domain), version_(version) {}
+  explicit OpSetID(std::string domain, int64_t version) : domain_(std::move(domain)), version_(version) {}
 
   // target must be in the form "<domain>&<version>"
   std::string toString() const {
@@ -852,8 +849,8 @@ class OpSetID final {
   // target must be in the form "<domain>&<version>"
   static OpSetID fromString(const std::string& target) {
     ONNX_TRY {
-      std::string new_domain = target.substr(0, target.find("$"));
-      int new_version = ONNX_NAMESPACE::stoi(target.substr(target.find("$") + 1, target.length()).c_str());
+      std::string new_domain = target.substr(0, target.find('$'));
+      int new_version = ONNX_NAMESPACE::stoi(target.substr(target.find('$') + 1, target.length()));
       return OpSetID(new_domain, new_version);
     }
     ONNX_CATCH(const std::runtime_error& e) {
@@ -898,9 +895,9 @@ struct Graph final {
 
   std::unordered_set<const Node*> all_nodes;
   std::unordered_set<const Value*> all_values;
-  size_t next_unique_;
+  size_t next_unique_{0};
 
-  size_t new_node_stage_;
+  size_t new_node_stage_{0};
 
   // holds outputs in a way that can be reflected
   // as a Use object
@@ -914,9 +911,9 @@ struct Graph final {
   std::vector<Tensor> initializers_;
   std::vector<std::string> initializer_names_;
 
-  bool has_name_;
+  bool has_name_{false};
   std::string name_;
-  bool has_doc_string_;
+  bool has_doc_string_{false};
   std::string doc_string_;
 
   std::vector<OpSetID> opset_versions_;
@@ -954,14 +951,7 @@ struct Graph final {
   }
 
  public:
-  Graph()
-      : next_unique_(0),
-        new_node_stage_(0),
-        output_(initOutput(create(kReturn, 0))),
-        input_(create(kParam, 0)),
-        initializer_node_(create(kParam, 0)),
-        has_name_(false),
-        has_doc_string_(false) {}
+  Graph() : output_(initOutput(create(kReturn, 0))), input_(create(kParam, 0)), initializer_node_(create(kParam, 0)) {}
 
   bool has_doc_string() const {
     return has_doc_string_;
@@ -1229,7 +1219,7 @@ struct Graph final {
   }
 
   void forEachNode(const std::function<void(Node*)>& fn) {
-    forSelfAndEachSubGraph([fn](Graph* graph) {
+    forSelfAndEachSubGraph([&fn](Graph* graph) {
       for (Node* node : graph->nodes()) {
         fn(node);
       }
@@ -1265,13 +1255,7 @@ struct Graph final {
 };
 
 inline Value::Value(Node* node_, size_t offset_)
-    : node_(node_),
-      offset_(offset_),
-      unique_(node_->graph_->getNextUnique()),
-      stage_(node_->graph_->new_node_stage_),
-      has_unique_name_(false),
-      elem_type_(ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED),
-      has_sizes_(false) {
+    : node_(node_), offset_(offset_), unique_(node_->graph_->getNextUnique()), stage_(node_->graph_->new_node_stage_) {
   node_->graph_->all_values.emplace(this);
 }
 
@@ -1356,14 +1340,7 @@ inline void Value::replaceAllUsesWith(Value* newValue) {
   assert(this->uses().empty());
 }
 
-inline Node::Node(Graph* graph_, NodeKind kind_)
-    : kind_(kind_),
-      graph_(graph_),
-      stage_(graph_->new_node_stage_),
-      has_name_(false),
-      has_domain_(false),
-      has_doc_string_(false),
-      has_overload_(false) {
+inline Node::Node(Graph* graph_, NodeKind kind_) : kind_(kind_), graph_(graph_), stage_(graph_->new_node_stage_) {
   graph_->all_nodes.emplace(this);
 }
 
@@ -1378,7 +1355,7 @@ inline void Node::eraseOutput(size_t i) {
   }
 }
 
-inline bool Node::isBefore(Node* n) {
+inline bool Node::isBefore(const Node* n) {
   if (n == nullptr || this == n) {
     // Bail out early.
     return false;
@@ -1428,7 +1405,7 @@ inline const_graph_node_list_iterator Node::reverseIterator() const {
 // nodes in subgraph are also included.
 // This method is usually used to check whether it is
 // safe to delete a Value.
-inline const use_list Value::uses() const {
+inline use_list Value::uses() const {
   use_list all_uses = uses_in_current_graph_;
   owningGraph()->forEachNode([this, &all_uses](const Node* node) {
     if (node->owningGraph() == this->owningGraph()) {

onnx/common/ir_pb_converter.cc

@@ -20,9 +20,9 @@
 namespace ONNX_NAMESPACE {
 
 // Part 1: convert ONNX Protobuf to IR
-std::unique_ptr<Graph> graphProtoToGraph(const GraphProto& gp, bool nested, const int ir_version = IR_VERSION);
+static std::unique_ptr<Graph> graphProtoToGraph(const GraphProto& gp, bool nested, const int ir_version = IR_VERSION);
 
-Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
+static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   Tensor ret;
 
   ret.sizes().reserve(tp.dims_size());
@@ -51,7 +51,8 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ: {
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1: {
       ret.int32s().reserve(tp.int32_data_size());
       for (int i = 0; i < tp.int32_data_size(); i++) {
         ret.int32s().push_back(tp.int32_data(i));
@@ -107,7 +108,7 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   return ret;
 }
 
-void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const int ir_version = IR_VERSION) {
+static void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const int ir_version = IR_VERSION) {
   Symbol sym = Symbol(ap.name());
   switch (ap.type()) {
     case ONNX_NAMESPACE::AttributeProto_AttributeType_FLOAT:
@@ -153,7 +154,7 @@ void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const i
       std::vector<Tensor> tensors;
       tensors.reserve(ap.tensors_size());
       for (int i = 0; i < ap.tensors_size(); i++) {
-        tensors.push_back(tensorProtoToTensor(ap.tensors(i)));
+        tensors.emplace_back(tensorProtoToTensor(ap.tensors(i)));
       }
       n->ts_(sym, std::move(tensors));
       break;
@@ -192,13 +193,13 @@ void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const i
   }
 }
 
-void convertAttributes(ONNX_NAMESPACE::NodeProto& np, Node* n, const int ir_version = IR_VERSION) {
+static void convertAttributes(const ONNX_NAMESPACE::NodeProto& np, Node* n, const int ir_version = IR_VERSION) {
   for (int i = 0; i < np.attribute_size(); i++) {
     convertAttribute(np.attribute(i), n, ir_version);
   }
 }
 
-std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::TensorShapeProto& tsp) {
+static std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::TensorShapeProto& tsp) {
   std::vector<Dimension> dims;
   dims.reserve(tsp.dim_size());
   for (int i = 0; i < tsp.dim_size(); i++) {
@@ -215,8 +216,8 @@ std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::Tensor
   return dims;
 }
 
-void createDummyValue(
-    std::unique_ptr<Graph>& g,
+static void createDummyValue(
+    const std::unique_ptr<Graph>& g,
     const std::string& name,
     std::unordered_map<std::string, Value*>& value_by_name_of) {
   auto* undef = g->create(kCaptured, 1);
@@ -226,7 +227,7 @@ void createDummyValue(
 }
 
 std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, bool nested, const int ir_version) {
-  std::unique_ptr<Graph> g(new Graph());
+  auto g = std::make_unique<Graph>();
 
   if (gp.has_name()) {
     g->setName(gp.name());
@@ -300,7 +301,7 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
   }
 
   for (int i = 0; i < gp.node_size(); i++) {
-    auto np = gp.node(i);
+    const auto& np = gp.node(i);
     auto* n = g->create(Symbol(np.op_type()), /* num_outputs = */ np.output_size());
     g->appendNode(n);
     for (int j = 0; j < np.output_size(); j++) {
@@ -405,13 +406,13 @@ std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp) {
 }
 
 // Part 2: convert IR to ONNX Protobuf
-std::string value_name(Value* n) {
+static std::string value_name(const Value* n) {
   return n->uniqueName();
 }
 
-void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g);
+static void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g);
 
-void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
+static void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
   if (tensor.hasName()) {
     p->set_name(tensor.name());
   }
@@ -480,7 +481,7 @@ void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
   }
 }
 
-void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
+static void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
   auto attr = n_p->add_attribute();
   attr->set_name(name.toString());
   switch (n->kindOf(name)) {
@@ -550,7 +551,7 @@ void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
   }
 }
 
-void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, Value* n) {
+static void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, const Value* n) {
   if (n->elemType() != 0) {
     tensor_type->set_elem_type(n->elemType());
   }
@@ -569,7 +570,7 @@ void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, Va
   }
 }
 
-void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
+static void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
   v->set_name(value_name(n));
   if (n->elemType() != 0 || n->has_sizes()) {
     ONNX_NAMESPACE::TypeProto* t = v->mutable_type();

onnx/common/ir_pb_converter.h

@@ -13,7 +13,6 @@
 
 #include "onnx/common/common.h"
 #include "onnx/common/ir.h"
-#include "onnx/onnx_pb.h"
 
 namespace ONNX_NAMESPACE {
 

onnx/common/model_helpers.cc

@@ -4,10 +4,6 @@
 
 #include "onnx/common/model_helpers.h"
 
-#include "onnx/checker.h"
-#include "onnx/defs/schema.h"
-#include "onnx/string_utils.h"
-
 namespace ONNX_NAMESPACE {
 
 Common::Status BuildNode(
@@ -18,8 +14,9 @@ Common::Status BuildNode(
     std::vector<std::string> const& inputs,
     std::vector<std::string> const& outputs,
     NodeProto* node) {
-  if (node == NULL) {
-    return Common::Status(Common::CHECKER, Common::INVALID_ARGUMENT, "node_proto should not be nullptr.");
+  if (node == nullptr) {
+    return Common::Status(
+        Common::StatusCategory::CHECKER, Common::StatusCode::INVALID_ARGUMENT, "node_proto should not be nullptr.");
   }
   node->set_name(name);
   node->set_domain(domain);

onnx/common/model_helpers.h

@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "onnx/common/status.h"
-#include "onnx/onnx-operators_pb.h"
+#include "onnx/onnx_pb.h"
 
 namespace ONNX_NAMESPACE {
 

onnx/common/path.h

@@ -32,24 +32,53 @@ constexpr const char k_preferred_path_separator = '/';
 inline std::wstring path_join(const std::wstring& origin, const std::wstring& append) {
   return (std::filesystem::path(origin) / std::filesystem::path(append)).wstring();
 }
-inline std::wstring utf8str_to_wstring(const std::string& utf8str) {
-  if (utf8str.size() > INT_MAX) {
-    fail_check("utf8str_to_wstring: string is too long for converting to wstring.");
+inline std::wstring utf8str_to_wstring(const std::string& utf8str, bool try_decode = false) {
+  if (utf8str.empty()) {
+    return std::wstring();
+  }
+  auto size_required =
+      MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.c_str(), -1, nullptr, 0);
+  if (size_required == 0) {
+    if (try_decode) {
+      return std::wstring(
+          reinterpret_cast<const wchar_t*>(utf8str.c_str()), utf8str.size() / sizeof(std::wstring::value_type));
+    }
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
   }
-  int size_required = MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), NULL, 0);
   std::wstring ws_str(size_required, 0);
-  MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), &ws_str[0], size_required);
+  auto converted_size = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.c_str(), -1, &ws_str[0], size_required);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
+  }
+  if (ws_str.back() == '\0') {
+    ws_str.pop_back();
+  }
   return ws_str;
 }
+
 inline std::string wstring_to_utf8str(const std::wstring& ws_str) {
-  if (ws_str.size() > INT_MAX) {
-    fail_check("wstring_to_utf8str: string is too long for converting to UTF-8.");
+  if (ws_str.empty()) {
+    return std::string();
+  }
+  auto size_required =
+      WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.c_str(), -1, nullptr, 0, nullptr, nullptr);
+  if (size_required == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
   }
-  int size_required =
-      WideCharToMultiByte(CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), NULL, 0, NULL, NULL);
   std::string utf8str(size_required, 0);
-  WideCharToMultiByte(
-      CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), &utf8str[0], size_required, NULL, NULL);
+  auto converted_size = WideCharToMultiByte(
+      CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.c_str(), -1, &utf8str[0], size_required, nullptr, nullptr);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
+  }
+  if (utf8str.back() == '\0') {
+    utf8str.pop_back();
+  }
   return utf8str;
 }
 

onnx/common/proto_util.h

@@ -26,17 +26,17 @@ using FunctionSpecId = std::string;
 // A single string representation of (domain, op, overload)
 using FunctionImplId = std::string;
 
-FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
+inline FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
   if (overload.empty())
     return NormalizeDomain(domain) + "::" + op;
   return NormalizeDomain(domain) + "::" + op + "::" + overload;
 }
 
-FunctionImplId GetFunctionImplId(const FunctionProto& function) {
+inline FunctionImplId GetFunctionImplId(const FunctionProto& function) {
   return GetFunctionImplId(function.domain(), function.name(), function.overload());
 }
 
-FunctionImplId GetCalleeId(const NodeProto& node) {
+inline FunctionImplId GetCalleeId(const NodeProto& node) {
   return GetFunctionImplId(node.domain(), node.op_type(), node.overload());
 }
 

onnx/common/status.cc

@@ -6,30 +6,31 @@
 
 #include "status.h"
 
-#include <assert.h>
+#include <cassert>
+#include <memory>
 
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
 namespace Common {
 
-Status::Status(StatusCategory category, int code, const std::string& msg) {
-  assert(static_cast<int>(StatusCode::OK) != code);
-  state_.reset(new State(category, code, msg));
+Status::Status(StatusCategory category, StatusCode code, const std::string& msg) {
+  assert(StatusCode::OK != code);
+  state_ = std::make_unique<State>(category, code, msg);
 }
 
-Status::Status(StatusCategory category, int code) : Status(category, code, EmptyString()) {}
+Status::Status(StatusCategory category, StatusCode code) : Status(category, code, EmptyString()) {}
 
 bool Status::IsOK() const noexcept {
-  return (state_ == NULL);
+  return (state_ == nullptr);
 }
 
 StatusCategory Status::Category() const noexcept {
   return IsOK() ? StatusCategory::NONE : state_->category;
 }
 
-int Status::Code() const noexcept {
-  return IsOK() ? static_cast<int>(StatusCode::OK) : state_->code;
+StatusCode Status::Code() const noexcept {
+  return IsOK() ? StatusCode::OK : state_->code;
 }
 
 const std::string& Status::ErrorMessage() const {
@@ -50,17 +51,17 @@ std::string Status::ToString() const {
   }
 
   result += " : ";
-  result += ONNX_NAMESPACE::to_string(Code());
+  result += ONNX_NAMESPACE::to_string(static_cast<int>(Code()));
   std::string msg;
 
-  switch (static_cast<StatusCode>(Code())) {
-    case INVALID_ARGUMENT:
+  switch (Code()) {
+    case StatusCode::INVALID_ARGUMENT:
       msg = "INVALID_ARGUMENT";
       break;
-    case INVALID_PROTOBUF:
+    case StatusCode::INVALID_PROTOBUF:
       msg = "INVALID_PROTOBUF";
       break;
-    case FAIL:
+    case StatusCode::FAIL:
       msg = "FAIL";
       break;
     default:

onnx/common/status.h

@@ -14,13 +14,13 @@
 namespace ONNX_NAMESPACE {
 namespace Common {
 
-enum StatusCategory {
+enum class StatusCategory {
   NONE = 0,
   CHECKER = 1,
   OPTIMIZER = 2,
 };
 
-enum StatusCode {
+enum class StatusCode {
   OK = 0,
   FAIL = 1,
   INVALID_ARGUMENT = 2,
@@ -29,24 +29,25 @@ enum StatusCode {
 
 class Status {
  public:
-  Status() noexcept {}
+  Status() noexcept = default;
 
-  Status(StatusCategory category, int code, const std::string& msg);
+  Status(StatusCategory category, StatusCode code, const std::string& msg);
 
-  Status(StatusCategory category, int code);
+  Status(StatusCategory category, StatusCode code);
 
   Status(const Status& other) {
     *this = other;
   }
 
-  void operator=(const Status& other) {
+  Status& operator=(const Status& other) {
     if (&other != this) {
       if (nullptr == other.state_) {
         state_.reset();
       } else if (state_ != other.state_) {
-        state_.reset(new State(*other.state_));
+        state_ = std::make_unique<State>(*other.state_);
       }
     }
+    return *this;
   }
 
   Status(Status&&) = default;
@@ -55,7 +56,7 @@ class Status {
 
   bool IsOK() const noexcept;
 
-  int Code() const noexcept;
+  StatusCode Code() const noexcept;
 
   StatusCategory Category() const noexcept;
 
@@ -75,10 +76,11 @@ class Status {
 
  private:
   struct State {
-    State(StatusCategory cat_, int code_, std::string msg_) : category(cat_), code(code_), msg(std::move(msg_)) {}
+    State(StatusCategory cat_, StatusCode code_, std::string msg_)
+        : category(cat_), code(code_), msg(std::move(msg_)) {}
 
     StatusCategory category = StatusCategory::NONE;
-    int code = 0;
+    StatusCode code{};
     std::string msg;
   };