error_collector.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <string>
#include <vector>
 
#include "iceberg/compat/compiler.h"
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
 
// The builder macros name Iceberg symbols with their full namespace, so builders outside
// namespace iceberg can use them.
#define ICEBERG_BUILDER_RETURN_IF_ERROR(result)                 \
  if (auto&& result_name = result; !result_name) [[unlikely]] { \
    errors_.emplace_back(std::move(result_name.error()));       \
    return *this;                                               \
  }
 
#define ICEBERG_BUILDER_ASSIGN_OR_RETURN_IMPL(result_name, lhs, rexpr) \
  auto&& result_name = (rexpr);                                        \
  ICEBERG_BUILDER_RETURN_IF_ERROR(result_name)                         \
  lhs = std::move(result_name.value());
 
#define ICEBERG_BUILDER_ASSIGN_OR_RETURN(lhs, rexpr) \
  ICEBERG_BUILDER_ASSIGN_OR_RETURN_IMPL(             \
      ICEBERG_ASSIGN_OR_RAISE_NAME(result_, __COUNTER__), lhs, rexpr)
 
#define ICEBERG_BUILDER_ASSIGN_OR_RETURN_WITH_ERROR_IMPL(result_name, lhs, rexpr, ...) \
  auto&& result_name = (rexpr);                                                        \
  if (!result_name) [[unlikely]] {                                                     \
    AddError(::iceberg::ErrorKind::kInvalidArgument, __VA_ARGS__);                     \
    return *this;                                                                      \
  }                                                                                    \
  lhs = std::move(result_name.value());
 
#define ICEBERG_BUILDER_ASSIGN_OR_RETURN_WITH_ERROR(lhs, rexpr, ...) \
  ICEBERG_BUILDER_ASSIGN_OR_RETURN_WITH_ERROR_IMPL(                  \
      ICEBERG_ASSIGN_OR_RAISE_NAME(result_, __COUNTER__), lhs, rexpr, __VA_ARGS__)
 
#define ICEBERG_BUILDER_CHECK(expr, ...)                             \
  do {                                                               \
    if (!(expr)) [[unlikely]] {                                      \
      AddError(::iceberg::ErrorKind::kInvalidArgument, __VA_ARGS__); \
      return *this;                                                  \
    }                                                                \
  } while (false)
 
namespace iceberg {
 
class ICEBERG_EXPORT ErrorCollector {
 public:
  ErrorCollector() = default;
  virtual ~ErrorCollector() = default;
 
  ErrorCollector(ErrorCollector&&) = default;
  ErrorCollector& operator=(ErrorCollector&&) = default;
 
  ErrorCollector(const ErrorCollector&) = default;
  ErrorCollector& operator=(const ErrorCollector&) = default;
 
#if ICEBERG_CXX20_COMPAT
  template <typename... Args>
  ErrorCollector& AddError(ErrorKind kind, const std::format_string<Args...> fmt,
                           Args&&... args) {
    RecordError({kind, std::format(fmt, std::forward<Args>(args)...)});
    return *this;
  }
#else
  template <typename... Args>
  auto& AddError(this auto& self, ErrorKind kind, const std::format_string<Args...> fmt,
                 Args&&... args) {
    static_cast<ErrorCollector&>(self).RecordError(
        {kind, std::format(fmt, std::forward<Args>(args)...)});
    return self;
  }
#endif
 
#if ICEBERG_CXX20_COMPAT
  ErrorCollector& AddError(Error err) {
    RecordError(std::move(err));
    return *this;
  }
#else
  auto& AddError(this auto& self, Error err) {
    static_cast<ErrorCollector&>(self).RecordError(std::move(err));
    return self;
  }
#endif
 
#if ICEBERG_CXX20_COMPAT
  ErrorCollector& AddError(::iceberg::unexpected<Error> err) {
    RecordError(std::move(err.error()));
    return *this;
  }
#else
  auto& AddError(this auto& self, ::iceberg::unexpected<Error> err) {
    static_cast<ErrorCollector&>(self).RecordError(std::move(err.error()));
    return self;
  }
  auto& AddError(this auto& self, std::unexpected<Error> err) {
    static_cast<ErrorCollector&>(self).RecordError(std::move(err.error()));
    return self;
  }
#endif
 
  [[nodiscard]] bool has_errors() const { return !errors_.empty(); }
 
  [[nodiscard]] size_t error_count() const { return errors_.size(); }
 
  [[nodiscard]] Status CheckErrors() const {
    if (!errors_.empty()) {
      std::string error_msg = "Validation failed due to the following errors:\n";
      bool all_retryable = true;
      for (const auto& [kind, message] : errors_) {
        all_retryable &= kind == ErrorKind::kRetryableValidationFailed;
        error_msg += "  - " + message + "\n";
      }
      if (all_retryable) {
        return RetryableValidationFailed("{}", error_msg);
      }
      return ValidationFailed("{}", error_msg);
    }
    return {};
  }
 
  void ClearErrors() { errors_.clear(); }
 
  [[nodiscard]] const std::vector<Error>& errors() const { return errors_; }
 
 private:
  void RecordError(Error err) { errors_.push_back(std::move(err)); }
 
 protected:
  std::vector<Error> errors_;
};
 
}  // namespace iceberg