Line data    Source code

       1             : /*
       2             :  *
       3             :  * Copyright 2016 gRPC authors.
       4             :  *
       5             :  * Licensed under the Apache License, Version 2.0 (the "License");
       6             :  * you may not use this file except in compliance with the License.
       7             :  * You may obtain a copy of the License at
       8             :  *
       9             :  *     http://www.apache.org/licenses/LICENSE-2.0
      10             :  *
      11             :  * Unless required by applicable law or agreed to in writing, software
      12             :  * distributed under the License is distributed on an "AS IS" BASIS,
      13             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14             :  * See the License for the specific language governing permissions and
      15             :  * limitations under the License.
      16             :  *
      17             :  */
      18             : 
      19             : #ifndef GRPCPP_IMPL_CODEGEN_STATUS_H
      20             : #define GRPCPP_IMPL_CODEGEN_STATUS_H
      21             : 
      22             : #include <grpc/impl/codegen/status.h>
      23             : #include <grpcpp/impl/codegen/config.h>
      24             : #include <grpcpp/impl/codegen/status_code_enum.h>
      25             : 
      26             : namespace grpc {
      27             : 
      28             : /// Did it work? If it didn't, why?
      29             : ///
      30             : /// See \a grpc::StatusCode for details on the available code and their meaning.
      31             : class Status {
      32             :  public:
      33             :   /// Construct an OK instance.
      34           0 :   Status() : code_(StatusCode::OK) {
      35             :     // Static assertions to make sure that the C++ API value correctly
      36             :     // maps to the core surface API value
      37             :     static_assert(StatusCode::OK == static_cast<StatusCode>(GRPC_STATUS_OK),
      38             :                   "Mismatched status code");
      39             :     static_assert(
      40             :         StatusCode::CANCELLED == static_cast<StatusCode>(GRPC_STATUS_CANCELLED),
      41             :         "Mismatched status code");
      42             :     static_assert(
      43             :         StatusCode::UNKNOWN == static_cast<StatusCode>(GRPC_STATUS_UNKNOWN),
      44             :         "Mismatched status code");
      45             :     static_assert(StatusCode::INVALID_ARGUMENT ==
      46             :                       static_cast<StatusCode>(GRPC_STATUS_INVALID_ARGUMENT),
      47             :                   "Mismatched status code");
      48             :     static_assert(StatusCode::DEADLINE_EXCEEDED ==
      49             :                       static_cast<StatusCode>(GRPC_STATUS_DEADLINE_EXCEEDED),
      50             :                   "Mismatched status code");
      51             :     static_assert(
      52             :         StatusCode::NOT_FOUND == static_cast<StatusCode>(GRPC_STATUS_NOT_FOUND),
      53             :         "Mismatched status code");
      54             :     static_assert(StatusCode::ALREADY_EXISTS ==
      55             :                       static_cast<StatusCode>(GRPC_STATUS_ALREADY_EXISTS),
      56             :                   "Mismatched status code");
      57             :     static_assert(StatusCode::PERMISSION_DENIED ==
      58             :                       static_cast<StatusCode>(GRPC_STATUS_PERMISSION_DENIED),
      59             :                   "Mismatched status code");
      60             :     static_assert(StatusCode::UNAUTHENTICATED ==
      61             :                       static_cast<StatusCode>(GRPC_STATUS_UNAUTHENTICATED),
      62             :                   "Mismatched status code");
      63             :     static_assert(StatusCode::RESOURCE_EXHAUSTED ==
      64             :                       static_cast<StatusCode>(GRPC_STATUS_RESOURCE_EXHAUSTED),
      65             :                   "Mismatched status code");
      66             :     static_assert(StatusCode::FAILED_PRECONDITION ==
      67             :                       static_cast<StatusCode>(GRPC_STATUS_FAILED_PRECONDITION),
      68             :                   "Mismatched status code");
      69             :     static_assert(
      70             :         StatusCode::ABORTED == static_cast<StatusCode>(GRPC_STATUS_ABORTED),
      71             :         "Mismatched status code");
      72             :     static_assert(StatusCode::OUT_OF_RANGE ==
      73             :                       static_cast<StatusCode>(GRPC_STATUS_OUT_OF_RANGE),
      74             :                   "Mismatched status code");
      75             :     static_assert(StatusCode::UNIMPLEMENTED ==
      76             :                       static_cast<StatusCode>(GRPC_STATUS_UNIMPLEMENTED),
      77             :                   "Mismatched status code");
      78             :     static_assert(
      79             :         StatusCode::INTERNAL == static_cast<StatusCode>(GRPC_STATUS_INTERNAL),
      80             :         "Mismatched status code");
      81             :     static_assert(StatusCode::UNAVAILABLE ==
      82             :                       static_cast<StatusCode>(GRPC_STATUS_UNAVAILABLE),
      83             :                   "Mismatched status code");
      84             :     static_assert(
      85             :         StatusCode::DATA_LOSS == static_cast<StatusCode>(GRPC_STATUS_DATA_LOSS),
      86             :         "Mismatched status code");
      87           0 :   }
      88             : 
      89             :   /// Construct an instance with associated \a code and \a error_message.
      90             :   /// It is an error to construct an OK status with non-empty \a error_message.
      91           0 :   Status(StatusCode code, const grpc::string& error_message)
      92           0 :       : code_(code), error_message_(error_message) {}
      93             : 
      94             :   /// Construct an instance with \a code,  \a error_message and
      95             :   /// \a error_details. It is an error to construct an OK status with non-empty
      96             :   /// \a error_message and/or \a error_details.
      97           0 :   Status(StatusCode code, const grpc::string& error_message,
      98             :          const grpc::string& error_details)
      99           0 :       : code_(code),
     100           0 :         error_message_(error_message),
     101           0 :         binary_error_details_(error_details) {}
     102             : 
     103             :   // Pre-defined special status objects.
     104             :   /// An OK pre-defined instance.
     105             :   static const Status& OK;
     106             :   /// A CANCELLED pre-defined instance.
     107             :   static const Status& CANCELLED;
     108             : 
     109             :   /// Return the instance's error code.
     110           0 :   StatusCode error_code() const { return code_; }
     111             :   /// Return the instance's error message.
     112           0 :   grpc::string error_message() const { return error_message_; }
     113             :   /// Return the (binary) error details.
     114             :   // Usually it contains a serialized google.rpc.Status proto.
     115           0 :   grpc::string error_details() const { return binary_error_details_; }
     116             : 
     117             :   /// Is the status OK?
     118           0 :   bool ok() const { return code_ == StatusCode::OK; }
     119             : 
     120             :   // Ignores any errors. This method does nothing except potentially suppress
     121             :   // complaints from any tools that are checking that errors are not dropped on
     122             :   // the floor.
     123             :   void IgnoreError() const {}
     124             : 
     125             :  private:
     126             :   StatusCode code_;
     127             :   grpc::string error_message_;
     128             :   grpc::string binary_error_details_;
     129             : };
     130             : 
     131             : }  // namespace grpc
     132             : 
     133             : #endif  // GRPCPP_IMPL_CODEGEN_STATUS_H