result.h File Reference

#include <filesystem>
#include <iostream>
#include <string>
#include <vector>
#include "flex/utils/error_pb/interactive.pb.h"
#include "glog/logging.h"

Include dependency graph for result.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	gs::Status
class	gs::Result< T >
struct	gs::is_gs_result_type< T >
struct	gs::is_gs_result_type< Result< T > >
struct	gs::is_gs_status_type< T >
struct	gs::is_gs_status_type< Status >

Namespaces
	gs
	std

Macros
#define	RETURN_IF_NOT_OK(expr)
#define	ASSIGN_AND_RETURN_IF_RESULT_NOT_OK(var, expr)
#define	ASSIGN_AND_RETURN_IF_STATUS_NOT_OK(var, expr)
#define	FLEX_AUTO(var, expr)   ASSIGN_AND_RETURN_IF_NOT_OK(auto var, expr)
#define	RETURN_FLEX_LEAF_ERROR(code, msg)

Typedefs
using	gs::StatusCode = gs::flex::interactive::Code

Functions
std::string	std::to_string (const gs::flex::interactive::Code &status)

Macro Definition Documentation

ASSIGN_AND_RETURN_IF_RESULT_NOT_OK

#define ASSIGN_AND_RETURN_IF_RESULT_NOT_OK	(		var,
			expr
	)

Value:

  {                                                                        \
    auto&& FLEX_TMP_VAR = expr;                                            \
    static_assert(                                                         \
        ::gs::is_gs_result_type<                                           \
            typename std::decay<decltype(FLEX_TMP_VAR)>::type>::value,     \
        "The expression must return a Result type");                       \
    if (!FLEX_TMP_VAR.ok()) {                                              \
      return FLEX_TMP_VAR;                                                 \
    }                                                                      \
    var = std::forward<decltype(FLEX_TMP_VAR)>(FLEX_TMP_VAR).move_value(); \
  }

ASSIGN_AND_RETURN_IF_STATUS_NOT_OK

#define ASSIGN_AND_RETURN_IF_STATUS_NOT_OK	(		var,
			expr
	)

Value:

  {                                                                        \
    auto&& FLEX_TMP_VAR = expr;                                            \
    static_assert(                                                         \
        ::gs::is_gs_status_type<                                           \
            typename std::decay<decltype(FLEX_TMP_VAR)>::type>::value,     \
        "The expression must return a Status type");                       \
    if (!FLEX_TMP_VAR.ok()) {                                              \
      return FLEX_TMP_VAR;                                                 \
    }                                                                      \
    var = std::forward<decltype(FLEX_TMP_VAR)>(FLEX_TMP_VAR).move_value(); \
  }

FLEX_AUTO

#define FLEX_AUTO	(		var,
			expr
	)		ASSIGN_AND_RETURN_IF_NOT_OK(auto var, expr)

RETURN_FLEX_LEAF_ERROR

#define RETURN_FLEX_LEAF_ERROR	(		code,
			msg
	)

Value:

  return ::boost::leaf::new_error(        \
      gs::Status(::gs::flex::interactive::Code::code, msg))

RETURN_IF_NOT_OK

#define RETURN_IF_NOT_OK

(

expr

)

Value:

  do {                         \
    auto status = (expr);      \
    if (!status.ok()) {        \
      return status;           \
    }                          \
  } while (0)