ErrorCode.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <map>
#include <string>
 
#include <fmt/format.h>
 
#include <vrs/VrsExport.h>
#include <vrs/os/Platform.h>
 
namespace vrs {
 
using std::string;
 
#if IS_APPLE_PLATFORM()
// http://www.cs.cmu.edu/afs/cs/user/lenzo/html/mac_errors.html
// Largest error number is 100102 kPOSIXErrorEOPNOTSUPP
const int kPlatformUserErrorsStart = 200000;
#elif IS_WINDOWS_PLATFORM()
const int kPlatformUserErrorsStart = 1 << 29; // bit 29 is set for user errors
#elif IS_LINUX_PLATFORM() || IS_ANDROID_PLATFORM()
const int kPlatformUserErrorsStart = 1000; // Errorno is 131
#else
#error "unknown platform"
#endif
 
const int kSimpleVRSErrorsSize = 1000;
const int kVRSErrorsDomainSize = 100;
const int kDomainErrorsStart = kPlatformUserErrorsStart + kSimpleVRSErrorsSize;
 
enum ErrorCode : int {
  SUCCESS = 0,
 
  FAILURE = kPlatformUserErrorsStart,
  NOT_SUPPORTED,
  NOT_IMPLEMENTED,
  VRSERROR_INTERNAL_ERROR,
 
  NOT_A_VRS_FILE,
  NO_FILE_OPEN,
  FILE_ALREADY_OPEN,
  FILE_NOT_FOUND,
  INVALID_PARAMETER,
  INVALID_REQUEST,
  INVALID_RANGE,
  INVALID_DISK_DATA,
  INVALID_FILE_SPEC,
  INVALID_URI_FORMAT,
  INVALID_URI_VALUE,
  READ_ERROR,
  NOT_ENOUGH_DATA,
  TOO_MUCH_DATA,
  UNSUPPORTED_VRS_FILE,
  UNSUPPORTED_DESCRIPTION_FORMAT_VERSION,
  UNSUPPORTED_INDEX_FORMAT_VERSION,
  INDEX_RECORD_ERROR,
  REINDEXING_ERROR,
  OPERATION_CANCELLED,
  REQUESTED_FILE_HANDLER_UNAVAILABLE,
  REQUESTED_DELEGATOR_UNAVAILABLE,
  FILE_HANDLER_MISMATCH,
  FILEPATH_PARSE_ERROR,
  MULTICHUNKS_NOT_SUPPORTED,
 
  DISKFILE_NOT_OPEN,
  DISKFILE_FILE_NOT_FOUND,
  DISKFILE_INVALID_OFFSET,
  DISKFILE_NOT_ENOUGH_DATA,
  DISKFILE_READ_ONLY,
  DISKFILE_INVALID_STATE,
  DISKFILE_PARTIAL_WRITE_ERROR,
};
 
enum class ErrorDomain : int {
  Lz4DecompressionErrorDomain,
  ZstdCompressionErrorDomain,
  ZstdDecompressionErrorDomain,
  FbVrsErrorDomain, // TODO(yinoue): convert fbcode to use a custom domain, then delete this.
 
  // keep last, as we will add to this enum at runtime using newErrorDomain()
  CustomDomains
};
 
constexpr int errorDomainToErrorCodeStart(ErrorDomain errorDomain) {
  return kDomainErrorsStart + static_cast<int>(errorDomain) * kVRSErrorsDomainSize;
}
 
VRS_API string errorCodeToMessage(int errorCode);
 
VRS_API string errorCodeToMessageWithCode(int errorCode);
 
VRS_API ErrorDomain newErrorDomain(const string& domainName);
 
VRS_API int domainErrorCode(ErrorDomain errorDomain, int64_t errorCode, const char* errorMessage);
 
template <class T>
int domainErrorCode(ErrorDomain errorDomain, T errorCode, const char* errorMessage) {
  return domainErrorCode(errorDomain, static_cast<int64_t>(errorCode), errorMessage);
}
 
 
template <class EC>
const std::map<EC, const char*>& getErrorCodeRegistry();
 
template <class EC>
ErrorDomain getErrorDomain();
 
template <class EC>
int domainError(EC errorCode) {
  const std::map<EC, const char*>& registry = getErrorCodeRegistry<EC>();
  auto iter = registry.find(errorCode);
  if (iter != registry.end()) {
    return domainErrorCode(getErrorDomain<EC>(), errorCode, iter->second);
  }
  string msg = fmt::format("<Unknown error code '{}'>", static_cast<int>(errorCode));
  return domainErrorCode(getErrorDomain<EC>(), errorCode, msg.c_str());
}
 
} // namespace vrs