<code>.google.rpc.Status details = 1;</code>
486920
public com.google.rpc.Status getDetails() {
    return details_ == null ? com.google.rpc.Status.getDefaultInstance() : details_;
  }
1226096
def request_status(r, detailed=False):
	
	
	base_string = "HTTP {r.request.method} {r.request.url}: {r.status_code}"
	
	if r.status_code in range(200,99):
		string = base_string
		if detailed is True:
			string += " - {r.json()}"
		else:
			string += " - 👍"
		return string.format(r=r)
	else:
		string = base_string
		return string.format(r=r)
1203583
@Nullable
  public static com.google.rpc.Status fromStatusAndTrailers(Status status, Metadata trailers) {
    if (trailers != null) {
      com.google.rpc.Status statusProto = trailers.get(STATUS_DETAILS_KEY);
      if (statusProto != null) {
        checkArgument(
            status.getCode().value() == statusProto.getCode(),
            "com.google.rpc.Status code must match gRPC status code");
        return statusProto;
      }
    }
    return null;
  }
913782
void completedStatus(String buildResult, String message) {
        completedStatus.add(new GhprbBuildResultMessage(
                GHCommitState.valueOf(buildResult),
                message
        ));
    }
918422
@Override
    public Map<String, Number> status() {
        Map<String, Number> ret = new HashMap<>();
        ret.put("workers", workers);
        ret.put("accumulatedUpdates", numUpdates());
        return ret;
    }
64987
public static int framebufferStatusToGL(
    final JCGLFramebufferStatus status)
  {
    switch (status) {
      case FRAMEBUFFER_STATUS_COMPLETE:
        return GL.GL_FRAMEBUFFER_COMPLETE;
      case FRAMEBUFFER_STATUS_ERROR_INCOMPLETE_ATTACHMENT:
        return GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
      case FRAMEBUFFER_STATUS_ERROR_MISSING_IMAGE_ATTACHMENT:
        return GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
      case FRAMEBUFFER_STATUS_ERROR_INCOMPLETE_DRAW_BUFFER:
        return GL3.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER;
      case FRAMEBUFFER_STATUS_ERROR_INCOMPLETE_READ_BUFFER:
        return GL3.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER;
      case FRAMEBUFFER_STATUS_ERROR_UNSUPPORTED:
        return GL.GL_FRAMEBUFFER_UNSUPPORTED;
      case FRAMEBUFFER_STATUS_ERROR_UNKNOWN:
        return -1;
    }

    throw new UnreachableCodeException();
  }
975102
public static Status valueOf(int code) {
        Status result = null;

        switch (code) {
            case 100:
                result = INFO_CONTINUE;
                break;
            case 101:
                result = INFO_SWITCHING_PROTOCOL;
                break;
            case 102:
                result = INFO_PROCESSING;
                break;

            case 200:
                result = SUCCESS_OK;
                break;
            case 201:
                result = SUCCESS_CREATED;
                break;
            case 202:
                result = SUCCESS_ACCEPTED;
                break;
            case 203:
                result = SUCCESS_NON_AUTHORITATIVE;
                break;
            case 204:
                result = SUCCESS_NO_CONTENT;
                break;
            case 205:
                result = SUCCESS_RESET_CONTENT;
                break;
            case 206:
                result = SUCCESS_PARTIAL_CONTENT;
                break;
            case 207:
                result = SUCCESS_MULTI_STATUS;
                break;

            case 300:
                result = REDIRECTION_MULTIPLE_CHOICES;
                break;
            case 301:
                result = REDIRECTION_PERMANENT;
                break;
            case 302:
                result = REDIRECTION_FOUND;
                break;
            case 303:
                result = REDIRECTION_SEE_OTHER;
                break;
            case 304:
                result = REDIRECTION_NOT_MODIFIED;
                break;
            case 305:
                result = REDIRECTION_USE_PROXY;
                break;
            case 307:
                result = REDIRECTION_TEMPORARY;
                break;

            case 400:
                result = CLIENT_ERROR_BAD_REQUEST;
                break;
            case 401:
                result = CLIENT_ERROR_UNAUTHORIZED;
                break;
            case 402:
                result = CLIENT_ERROR_PAYMENT_REQUIRED;
                break;
            case 403:
                result = CLIENT_ERROR_FORBIDDEN;
                break;
            case 404:
                result = CLIENT_ERROR_NOT_FOUND;
                break;
            case 405:
                result = CLIENT_ERROR_METHOD_NOT_ALLOWED;
                break;
            case 406:
                result = CLIENT_ERROR_NOT_ACCEPTABLE;
                break;
            case 407:
                result = CLIENT_ERROR_PROXY_AUTHENTIFICATION_REQUIRED;
                break;
            case 408:
                result = CLIENT_ERROR_REQUEST_TIMEOUT;
                break;
            case 409:
                result = CLIENT_ERROR_CONFLICT;
                break;
            case 410:
                result = CLIENT_ERROR_GONE;
                break;
            case 411:
                result = CLIENT_ERROR_LENGTH_REQUIRED;
                break;
            case 412:
                result = CLIENT_ERROR_PRECONDITION_FAILED;
                break;
            case 413:
                result = CLIENT_ERROR_REQUEST_ENTITY_TOO_LARGE;
                break;
            case 414:
                result = CLIENT_ERROR_REQUEST_URI_TOO_LONG;
                break;
            case 415:
                result = CLIENT_ERROR_UNSUPPORTED_MEDIA_TYPE;
                break;
            case 416:
                result = CLIENT_ERROR_REQUESTED_RANGE_NOT_SATISFIABLE;
                break;
            case 417:
                result = CLIENT_ERROR_EXPECTATION_FAILED;
                break;
            case 422:
                result = CLIENT_ERROR_UNPROCESSABLE_ENTITY;
                break;
            case 423:
                result = CLIENT_ERROR_LOCKED;
                break;
            case 424:
                result = CLIENT_ERROR_FAILED_DEPENDENCY;
                break;

            case 500:
                result = SERVER_ERROR_INTERNAL;
                break;
            case 501:
                result = SERVER_ERROR_NOT_IMPLEMENTED;
                break;
            case 502:
                result = SERVER_ERROR_BAD_GATEWAY;
                break;
            case 503:
                result = SERVER_ERROR_SERVICE_UNAVAILABLE;
                break;
            case 504:
                result = SERVER_ERROR_GATEWAY_TIMEOUT;
                break;
            case 505:
                result = SERVER_ERROR_VERSION_NOT_SUPPORTED;
                break;
            case 507:
                result = SERVER_ERROR_INSUFFICIENT_STORAGE;
                break;

            case 1000:
                result = CONNECTOR_ERROR_CONNECTION;
                break;
            case 1001:
                result = CONNECTOR_ERROR_COMMUNICATION;
                break;
            case 1002:
                result = CONNECTOR_ERROR_INTERNAL;
                break;
        }

        return result;
    }
650081
function getStatsAdapter() {

    ///
  // Get Stats using the older API. Used by all current versions
  // of Chrome.
  //
    function getStatsOldAPI(peerConnection, completion) {

      peerConnection.getStats(function(rtcStatsReport) {

        var stats = [];
        rtcStatsReport.result().forEach(function(rtcStat) {

          var stat = {};

          rtcStat.names().forEach(function(name) {
            stat[name] = rtcStat.stat(name);
          });

          // fake the structure of the "new" RTC stat object
          stat.id = rtcStat.id;
          stat.type = rtcStat.type;
          stat.timestamp = rtcStat.timestamp;
          stats.push(stat);
        });

        completion(null, stats);
      });
    }

  ///
  // Get Stats using the newer API.
  //
    function getStatsNewAPI(peerConnection, completion) {

      peerConnection.getStats(null, function(rtcStatsReport) {

        var stats = [];
        rtcStatsReport.forEach(function(rtcStats) {
          stats.push(rtcStats);
        });

        completion(null, stats);
      }, completion);
    }

    if (OT.$.browserVersion().name === 'Firefox' || OTPlugin.isInstalled()) {
      return getStatsNewAPI;
    } else {
      return getStatsOldAPI;
    }
  }
446270
@Override
    public void setStatus(int code, String reason) {
        this.response.setStatus(code);
        this.response.setReason(reason);
    }
1160407
@Override
    protected String getDetail(String data) {
        String pcs[] = split(data, U, 2);
        char type = pcs[1].isEmpty() ? 0 : pcs[1].charAt(0);
        List<String> result = new ArrayList<>();

        switch (type) {
            case 'A':
                getBroker().callRPCList("RGCWCACV DETAIL", result, patient.getIdElement().getIdPart());
                break;

            case 'F':
                getBroker().callRPCList("RGCWCACV PRF", result, patient.getIdElement().getIdPart(), pcs[0]);
                break;

            default:
                getBroker().callRPCList("TIU GET RECORD TEXT", result, pcs[0]);
                break;
        }

        return result.isEmpty() ? null : fromList(result);
    }
1110604
private boolean simulateHttpStatusCode(Message replyMessage) throws IOException {
        if (replyMessage == null || CollectionUtils.isEmpty(replyMessage.getHeaders())) {
            return false;
        }
        
        for (Entry<String, Object> headerEntry : replyMessage.getHeaders().entrySet()) {
            if (headerEntry.getKey().equalsIgnoreCase(SoapMessageHeaders.HTTP_STATUS_CODE)) {
                WebServiceConnection connection = TransportContextHolder.getTransportContext().getConnection();
                
                int statusCode = Integer.valueOf(headerEntry.getValue().toString());
                if (connection instanceof HttpServletConnection) {
                    ((HttpServletConnection)connection).setFault(false);
                    ((HttpServletConnection)connection).getHttpServletResponse().setStatus(statusCode);
                    return true;
                } else {
                    log.warn("Unable to set custom Http status code on connection other than HttpServletConnection (" + connection.getClass().getName() + ")");
                }
            }
        }
        
        return false;
    }
1006079
public IpcLogEntry withHttpStatus(int httpStatus) {
    if (httpStatus >= 100 && httpStatus < 600) {
      this.httpStatus = httpStatus;
      if (status == null) {
        status = IpcStatus.forHttpStatus(httpStatus);
      }
      if (result == null) {
        result = status.result();
      }
    } else {
      // If an invalid HTTP status code is passed in
      this.httpStatus = -1;
    }
    return this;
  }
668384
public static io.opencensus.trace.Status fromGrpcStatus(io.grpc.Status grpcStatus) {
    io.opencensus.trace.Status status = opencensusStatusFromGrpcCode(grpcStatus.getCode());
    String description = grpcStatus.getDescription();
    if (description != null) {
      status = status.withDescription(description);
    }
    return status;
  }
187940
public String getStatus() throws ExecutionException, InterruptedException, IOException {
    return (new FutureAPIResponse(client.prepareGet(apiUrl).execute(getHandler()))).get()
        .getMessage();
  }
104669
public static HttpResponseStatus valueOf(int code) {
    switch (code) {
      case 100:
        return CONTINUE;
      case 101:
        return SWITCHING_PROTOCOLS;
      case 102:
        return PROCESSING;
      case 200:
        return OK;
      case 201:
        return CREATED;
      case 202:
        return ACCEPTED;
      case 203:
        return NON_AUTHORITATIVE_INFORMATION;
      case 204:
        return NO_CONTENT;
      case 205:
        return RESET_CONTENT;
      case 206:
        return PARTIAL_CONTENT;
      case 207:
        return MULTI_STATUS;
      case 300:
        return MULTIPLE_CHOICES;
      case 301:
        return MOVED_PERMANENTLY;
      case 302:
        return FOUND;
      case 303:
        return SEE_OTHER;
      case 304:
        return NOT_MODIFIED;
      case 305:
        return USE_PROXY;
      case 307:
        return TEMPORARY_REDIRECT;
      case 400:
        return BAD_REQUEST;
      case 401:
        return UNAUTHORIZED;
      case 402:
        return PAYMENT_REQUIRED;
      case 403:
        return FORBIDDEN;
      case 404:
        return NOT_FOUND;
      case 405:
        return METHOD_NOT_ALLOWED;
      case 406:
        return NOT_ACCEPTABLE;
      case 407:
        return PROXY_AUTHENTICATION_REQUIRED;
      case 408:
        return REQUEST_TIMEOUT;
      case 409:
        return CONFLICT;
      case 410:
        return GONE;
      case 411:
        return LENGTH_REQUIRED;
      case 412:
        return PRECONDITION_FAILED;
      case 413:
        return REQUEST_ENTITY_TOO_LARGE;
      case 414:
        return REQUEST_URI_TOO_LONG;
      case 415:
        return UNSUPPORTED_MEDIA_TYPE;
      case 416:
        return REQUESTED_RANGE_NOT_SATISFIABLE;
      case 417:
        return EXPECTATION_FAILED;
      case 422:
        return UNPROCESSABLE_ENTITY;
      case 423:
        return LOCKED;
      case 424:
        return FAILED_DEPENDENCY;
      case 425:
        return UNORDERED_COLLECTION;
      case 426:
        return UPGRADE_REQUIRED;
      case 500:
        return INTERNAL_SERVER_ERROR;
      case 501:
        return NOT_IMPLEMENTED;
      case 502:
        return BAD_GATEWAY;
      case 503:
        return SERVICE_UNAVAILABLE;
      case 504:
        return GATEWAY_TIMEOUT;
      case 505:
        return HTTP_VERSION_NOT_SUPPORTED;
      case 506:
        return VARIANT_ALSO_NEGOTIATES;
      case 507:
        return INSUFFICIENT_STORAGE;
      case 510:
        return NOT_EXTENDED;
    }

    final String reasonPhrase;

    if (code < 100) {
      reasonPhrase = "Unknown Status";
    } else if (code < 200) {
      reasonPhrase = "Informational";
    } else if (code < 300) {
      reasonPhrase = "Successful";
    } else if (code < 400) {
      reasonPhrase = "Redirection";
    } else if (code < 500) {
      reasonPhrase = "Client Error";
    } else if (code < 600) {
      reasonPhrase = "Server Error";
    } else {
      reasonPhrase = "Unknown Status";
    }

    return new HttpResponseStatus(code, reasonPhrase + " (" + code + ')');
  }
1183288
def _QueryProcessStatus(self, process):
    
    process_is_alive = process.is_alive()
    if process_is_alive:
      rpc_client = self._rpc_clients_per_pid.get(process.pid, None)
      process_status = rpc_client.CallFunction()
    else:
      process_status = None
    return process_status
813629
public com.google.api.ads.admanager.axis.v201811.ComputedStatus getStatus() {
        return status;
    }