error.h

#ifndef SIMDJSON_ERROR_H
#define SIMDJSON_ERROR_H
 
#include "simdjson/base.h"
 
#include <string>
#include <ostream>
 
namespace simdjson {
 
enum error_code {
  SUCCESS = 0,                
  CAPACITY,                   
  MEMALLOC,                   
  TAPE_ERROR,                 
  DEPTH_ERROR,                
  STRING_ERROR,               
  T_ATOM_ERROR,               
  F_ATOM_ERROR,               
  N_ATOM_ERROR,               
  NUMBER_ERROR,               
  BIGINT_ERROR,               
  UTF8_ERROR,                 
  UNINITIALIZED,              
  EMPTY,                      
  UNESCAPED_CHARS,            
  UNCLOSED_STRING,            
  UNSUPPORTED_ARCHITECTURE,   
  INCORRECT_TYPE,             
  NUMBER_OUT_OF_RANGE,        
  INDEX_OUT_OF_BOUNDS,        
  NO_SUCH_FIELD,              
  IO_ERROR,                   
  INVALID_JSON_POINTER,       
  INVALID_URI_FRAGMENT,       
  UNEXPECTED_ERROR,           
  PARSER_IN_USE,              
  OUT_OF_ORDER_ITERATION,     
  INSUFFICIENT_PADDING,       
  INCOMPLETE_ARRAY_OR_OBJECT, 
  SCALAR_DOCUMENT_AS_VALUE,   
  OUT_OF_BOUNDS,              
  TRAILING_CONTENT,           
  OUT_OF_CAPACITY,            
  UNKNOWN_FIELD,              
  NUM_ERROR_CODES             
};
 
 inline bool is_fatal(error_code error) noexcept;
 
inline const char *error_message(error_code error) noexcept;
 
inline std::ostream& operator<<(std::ostream& out, error_code error) noexcept;
 
struct simdjson_error : public std::exception {
  simdjson_error(error_code error) noexcept : _error{error} { }
  const char *what() const noexcept override { return error_message(error()); }
  error_code error() const noexcept { return _error; }
private:
  error_code _error;
};
 
namespace internal {
 
template<typename T>
struct simdjson_result_base : protected std::pair<T, error_code> {
 
  simdjson_inline simdjson_result_base() noexcept;
 
  simdjson_inline simdjson_result_base(error_code error) noexcept;
 
  simdjson_inline simdjson_result_base(T &&value) noexcept;
 
  simdjson_inline simdjson_result_base(T &&value, error_code error) noexcept;
 
  simdjson_inline void tie(T &value, error_code &error) && noexcept;
 
  simdjson_inline error_code get(T &value) && noexcept;
 
  simdjson_inline error_code error() const noexcept;
 
  simdjson_inline bool has_value() const noexcept;
#if SIMDJSON_EXCEPTIONS
 
  simdjson_inline T& operator*() &  noexcept(false);
  simdjson_inline T&& operator*() &&  noexcept(false);
  simdjson_inline T* operator->() noexcept(false);
  simdjson_inline const T* operator->() const noexcept(false);
 
  simdjson_inline T& value() & noexcept(false);
 
  simdjson_inline T&& value() && noexcept(false);
 
  simdjson_inline T&& take_value() && noexcept(false);
 
  simdjson_inline operator T&&() && noexcept(false);
 
#endif // SIMDJSON_EXCEPTIONS
 
  simdjson_inline const T& value_unsafe() const& noexcept;
 
  simdjson_inline T&& value_unsafe() && noexcept;
 
  using value_type = T;
  using error_type = error_code;
}; // struct simdjson_result_base
 
} // namespace internal
 
template<typename T>
struct simdjson_result : public internal::simdjson_result_base<T> {
 
  simdjson_inline simdjson_result() noexcept;
  simdjson_inline simdjson_result(T &&value) noexcept;
  simdjson_inline simdjson_result(error_code error_code) noexcept;
  simdjson_inline simdjson_result(T &&value, error_code error) noexcept;
 
  simdjson_inline void tie(T &value, error_code &error) && noexcept;
 
  simdjson_warn_unused simdjson_inline error_code get(T &value) && noexcept;
 
  template <typename U = T>
  simdjson_warn_unused simdjson_inline error_code get(std::string &value) && noexcept {
    static_assert(std::is_same<U, std::string_view>::value, "SFINAE");
    std::string_view v;
    error_code error = std::forward<simdjson_result<T>>(*this).get(v);
    if (!error) {
      value.assign(v.data(), v.size());
    }
    return error;
  }
 
  simdjson_inline error_code error() const noexcept;
 
 
 
#if SIMDJSON_EXCEPTIONS
  using internal::simdjson_result_base<T>::operator*;
  using internal::simdjson_result_base<T>::operator->;
  simdjson_inline T& value() & noexcept(false);
 
  simdjson_inline T&& value() && noexcept(false);
 
  simdjson_inline T&& take_value() && noexcept(false);
 
  simdjson_inline operator T&&() && noexcept(false);
#endif // SIMDJSON_EXCEPTIONS
 
  simdjson_inline const T& value_unsafe() const& noexcept;
 
  simdjson_inline T&& value_unsafe() && noexcept;
 
  using value_type = T;
  using error_type = error_code;
}; // struct simdjson_result
 
#if SIMDJSON_EXCEPTIONS
 
template<typename T>
inline std::ostream& operator<<(std::ostream& out, simdjson_result<T> value) { return out << value.value(); }
#endif // SIMDJSON_EXCEPTIONS
 
#ifndef SIMDJSON_DISABLE_DEPRECATED_API
using ErrorValues [[deprecated("This is an alias and will be removed, use error_code instead")]] = error_code;
 
[[deprecated("Error codes should be stored and returned as `error_code`, use `error_message()` instead.")]]
inline const std::string error_message(int error) noexcept;
#endif // SIMDJSON_DISABLE_DEPRECATED_API
} // namespace simdjson
 
#endif // SIMDJSON_ERROR_H