Class Error

cpp/fory/util/error.h:100–305

Error class for Fory serialization and deserialization operations. This class supports two usage patterns: 1. Static factory functions for creating new errors (recommended for general use) 2. Mutable error pattern for performance-critical read paths ## Pattern 1: Static Factory Functions (General Use) ```cpp // CORRECT: Use static factory functions auto err = Error::type_error("Expected string

/// - Error::invalid() - For general invalid state
/// - Error::unknown() - For generic errors
class Error {
public:
  /// Default constructor - creates an "OK" (no error) state.
  /// Used for stack-allocated error variables in read paths.
  Error() : ok_(true), state_(nullptr) {}
  // Static factory functions - Use these instead of constructors!

  /// Creates a type mismatch error with the given type IDs.
  static Error type_mismatch(uint32_t type_a, uint32_t type_b) {
    return Error(ErrorCode::TypeMismatch,
                 "Type mismatch: type_a = " + std::to_string(type_a) +
                     ", type_b = " + std::to_string(type_b));
  }

  /// Creates a buffer out of bound error.
  static Error buffer_out_of_bound(size_t offset, size_t length,
                                   size_t capacity) {
    return Error(ErrorCode::BufferOutOfBound,
                 "Buffer out of bound: " + std::to_string(offset) + " + " +
                     std::to_string(length) + " > " + std::to_string(capacity));
  }

  /// Creates an encoding error.
  static Error encode_error(const std::string &msg) {
    return Error(ErrorCode::EncodeError, msg);
  }

  /// Creates an invalid data error.
  static Error invalid_data(const std::string &msg) {
    return Error(ErrorCode::InvalidData, msg);
  }

  /// Creates an invalid reference error.
  static Error invalid_ref(const std::string &msg) {
    return Error(ErrorCode::InvalidRef, msg);
  }

  /// Creates an unknown enum error.
  static Error unknown_enum(const std::string &msg) {
    return Error(ErrorCode::UnknownEnum, msg);
  }

  /// Creates a type error.
  static Error type_error(const std::string &msg) {
    return Error(ErrorCode::TypeError, msg);
  }

  /// Creates an encoding format error.
  static Error encoding_error(const std::string &msg) {
    return Error(ErrorCode::EncodingError, msg);
  }

  /// Creates a depth exceeded error.
  static Error depth_exceed(const std::string &msg) {
    return Error(ErrorCode::DepthExceed, msg);
  }

  /// Creates an unsupported operation error.