Added mapping between absl status code and TfliteSupportErrorCode when payload can't be converted to a valid TfLiteSupportStatus

Author: priankakariat

tensorflow_lite_support/c/common.h

@@ -24,16 +24,22 @@ extern "C" {
 
 // Error codes for TensorFlow Lite Task Library C APIs.
 //
-// One to one mapping with `TfLiteSupportStatus` code starting from kError = 1.
-// Omits `kOk` since `TfLiteErrorCode` is only to be used in the event of an
-// error and does not account for success unlike `TfLiteSupportStatus`. In case
-// of success, TensorFlow Lite Task Library C APIs return the appropriate return
-// value and a null error. One to one mapping makes it easier to convert between
-// `TfLiteSupportStatus` and `TfLiteSupportErrorCode` without long switch statements.
-// kErrorCodeFirst and kErrorCodeLast are also provided for safety checks during
-// conversion. In case of modifications in error codes, ensure that
-// kErrorCodeFirst is set to the least enum value and kErrorCodeLast is set to
-// the greatest enum value.
+// Holds one to one mapping with `TfLiteSupportStatus` code starting from kError
+// = 1. Omits `kOk` since `TfLiteErrorCode` is only to be used in the event of
+// an error and does not account for success unlike `TfLiteSupportStatus`. In
+// case of success, TensorFlow Lite Task Library C APIs return the appropriate
+// return value and a null error. One to one mapping makes it easier to convert
+// between `TfLiteSupportStatus` and `TfLiteSupportErrorCode` without long
+// switch statements.
+//
+// Also holds error codes mapping to absl::Status::code() starting from
+// kNotFound = 900 in cases where the absl::Status payload can't
+// be mapped to a `TfLiteSupportStatus` code. kErrorCodeFirst and kErrorCodeLast
+// are also provided for safety checks during conversion between
+// `TfLiteSupportStatus` and `TfLiteSupportErrorCode`. In case of modifications
+// in error codes, ensure that kErrorCodeFirst and kErrorCodeLast is
+// respectively, set to the least and greatest enum value amongst the error
+// codes mapping to TfLiteSupportStatus.
 enum TfLiteSupportErrorCode {
   // Unspecified error.
   kError = 1,
@@ -144,17 +150,43 @@ enum TfLiteSupportErrorCode {
   kImageProcessingBackendError,
 
   // Convenience error codes for condition checks during type casting.
-
-  // Ensure it holds the least enum value.
+  //
+  // Codes mapping to absl status codes should not be considered for these
+  // ranges.
+  // They must be used exclsively for checking if error codes fall in valid
+  // ranges when converting between TfLiteSupportStatus and
+  // TfLiteSupportErrorCodee.
+
+  // Ensure it holds the least enum value amongst error codes mapping to
+  // TfLiteSupportStatus.
   kErrorCodeFirst = kError,
-  // Ensure it holds the greatest enum value.
+  // Ensure it holds the greatest enum value amongst error codes mapping to
+  // TfLiteSupportStatus.
   kErrorCodeLast = kImageProcessingBackendError,
 
+  // Absl Status Codes Mapping
+  //
+  // Codes starting from 900 will be used to map absl::Status created by TfLite
+  // and are used as is by TfLite Support C++ layer. Such absl status objects
+  // don't have a TfLiteSupportStatus in the payload that can be mapped to other
+  // error codes in this struct. You must use the absl::Status::code() and map
+  // them to the following error codes in such cases.
+  // For more info on respective absl status codes, please see:
+  // https://github.com/abseil/abseil-cpp/blob/master/absl/status/status.h#L91
+
+  // kNotFound indicates some requested entity (such as a file or directory)
+  // was not found.
+  kNotFound = 900,
+  // kInternal indicates an internal error has occurred
+  // and some invariants expected by the underlying system have not been
+  // satisfied. This error code is reserved for serious errors.
+  kInternal,
+
 };
 
-// A `TfLiteSupportError` encapsulates an error code and a descriptive message to
-// return in the event of an error being encountered in any TensorFlow Lite Task
-// Library C API.
+// A `TfLiteSupportError` encapsulates an error code and a descriptive message
+// to return in the event of an error being encountered in any TensorFlow Lite
+// Task Library C API.
 typedef struct TfLiteSupportError {
   // Holds the error code.
   enum TfLiteSupportErrorCode code;

tensorflow_lite_support/c/common_utils.cc

@@ -17,6 +17,7 @@ limitations under the License.
 
 #include <string>
 
+#include "external/com_google_absl/absl/status/status.h"
 #include "external/com_google_absl/absl/strings/cord.h"
 #include "tensorflow_lite_support/cc/common.h"
 
@@ -40,7 +41,7 @@ void CreateTfLiteSupportErrorWithStatus(const absl::Status& status,
   int generic_error_code = static_cast<int>(kError);
   int error_code;
   try {
-    // Try converting payload to integer if not payload is not empty. Otherwise
+    // Try converting payload to integer if payload is not empty. Otherwise
     // convert a string signifying generic error code kError to integer.
     error_code = std::stoi(static_cast<absl::optional<std::string>>(
                                status.GetPayload(kTfLiteSupportPayload))
@@ -51,13 +52,30 @@ void CreateTfLiteSupportErrorWithStatus(const absl::Status& status,
     error_code = generic_error_code;
   }
 
-  // If generated error code is outside the range of enum values possible, set
-  // the error code to 1(kError). Assumes that enums will have an underlying
-  // integer value and kErrorCodeLast and kErrorCodeFirst will always hold the
-  // bounds of this range.
+  // If error_code is outside the range of enum values possible or is kError, we
+  // try to map the absl::Status::code() to assign appropriate
+  // TfLiteSupportErrorCode or kError in default cases. Note: The mapping to
+  // absl::Status::code() is done to generate a more specific error code than
+  // kError in cases when the payload can't be mapped to TfLiteSupportStatus.
+  // This can happen when absl::Status returned by TfLite are in turn returned
+  // without moodification by TfLite Support Methods.
   if (error_code > static_cast<int>(kErrorCodeLast) ||
-      error_code < static_cast<int>(kErrorCodeFirst))
-    error_code = generic_error_code;
+      error_code <= static_cast<int>(kErrorCodeFirst)) {
+    switch (status.code()) {
+      case absl::StatusCode::kInternal:
+        error_code = kInternal;
+        break;
+      case absl::StatusCode::kInvalidArgument:
+        error_code = kInvalidArgumentError;
+        break;
+      case absl::StatusCode::kNotFound:
+        error_code = kNotFound;
+        break;
+      default:
+        error_code = kError;
+        break;
+    }
+  }
 
   *error = new TfLiteSupportError;
   // TfLiteErrorCode has a one to one mapping with TfLiteSupportStatus starting