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/iceberg_export.h"
#include "iceberg/result.h"
 
namespace iceberg {
 
#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]] {                                                     \
    return AddError(ErrorKind::kInvalidArgument, __VA_ARGS__);                         \
  }                                                                                    \
  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]] {                                  \
      return AddError(ErrorKind::kInvalidArgument, __VA_ARGS__); \
    }                                                            \
  } while (false)
 
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;
 
  template <typename... Args>
  auto& AddError(this auto& self, ErrorKind kind, const std::format_string<Args...> fmt,
                 Args&&... args) {
    self.errors_.emplace_back(kind, std::format(fmt, std::forward<Args>(args)...));
    return self;
  }
 
  auto& AddError(this auto& self, Error err) {
    self.errors_.push_back(std::move(err));
    return self;
  }
 
  auto& AddError(this auto& self, std::unexpected<Error> err) {
    self.errors_.push_back(std::move(err.error()));
    return self;
  }
 
  [[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";
      for (const auto& [kind, message] : errors_) {
        error_msg += "  - " + message + "\n";
      }
      return ValidationFailed("{}", error_msg);
    }
    return {};
  }
 
  void ClearErrors() { errors_.clear(); }
 
  [[nodiscard]] const std::vector<Error>& errors() const { return errors_; }
 
 protected:
  std::vector<Error> errors_;
};
 
}  // namespace iceberg