error.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <stdexcept>    // for exception
#include <string>       // for string
#include <string_view>  // for string
 
#include <fmt/format.h>  // for fmt::format
 
namespace cloe {
 
class Error;
 
class Error : public std::exception {
 public:
  Error(std::string_view what) : err_(what.data()) {}
 
  template <typename... Args>
  Error(std::string_view format, Args&&... args)
      : err_(fmt::format(fmt::runtime(format), std::forward<Args>(args)...)) {}
 
  virtual ~Error() noexcept = default;
 
  const char* what() const noexcept override { return err_.what(); }
 
  bool has_explanation() const { return !explanation_.empty(); }
 
  void set_explanation(std::string explanation);
 
  template <typename... Args>
  void set_explanation(std::string_view format, Args&&... args) {
    set_explanation(fmt::format(fmt::runtime(format), std::forward<Args>(args)...));
  }
 
  const std::string& explanation() const { return explanation_; }
 
  Error explanation(std::string explanation) && {
    set_explanation(std::move(explanation));
    return std::move(*this);
  }
 
  template <typename... Args>
  Error explanation(std::string_view format, Args&&... args) && {
    set_explanation(fmt::format(fmt::runtime(format), std::forward<Args>(args)...));
    return std::move(*this);
  }
 
 private:
  std::runtime_error err_;
  std::string explanation_;
};
 
class ConcludedError : public std::exception {
 public:
  explicit ConcludedError(std::exception& e) : cause_(e) {}
  virtual ~ConcludedError() noexcept = default;
 
  std::exception& cause() const noexcept { return cause_; }
  const char* what() const noexcept override { return cause_.what(); }
 
 private:
  std::exception& cause_;
};
 
}  // namespace cloe