Error.hpp

/*
 * Error.hpp
 *
 * Copyright (C) 2022 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_ERROR_HPP
#define LAUNCHER_PLUGINS_ERROR_HPP
 
#include <string>
#include <system_error>
#include <vector>
 
#include <PImpl.hpp>
#include <logging/Logger.hpp>
 
namespace rstudio {
namespace launcher_plugins {
namespace system {
 
class FilePath;
 
 } // namespace system
 
 
class Error;
class Success;
 
class ErrorLock
{
   friend class Error;
   friend class Success;
 
   virtual ~ErrorLock() = default;
 
private:
   ErrorLock() = default;
 
   ErrorLock(const ErrorLock&) = default;
};
 
class ErrorLocation
{
public:
   ErrorLocation();
 
   ErrorLocation(const ErrorLocation& in_other);
 
   ErrorLocation(ErrorLocation&& in_other) noexcept;
 
   ErrorLocation(const char* in_function, const char* in_file, long in_line);
 
   ErrorLocation& operator=(const ErrorLocation& in_other);
 
   bool operator==(const ErrorLocation& in_location) const;
 
   std::string asString() const;
 
   const std::string& getFile() const;
 
   const std::string& getFunction() const;
 
   long getLine() const;
 
   bool hasLocation() const;
 
private:
   // The private implementation of ErrorLocation.
   PRIVATE_IMPL(m_impl);
};
 
typedef std::vector<std::pair<std::string, std::string> > ErrorProperties;
 
class Error : public virtual ErrorLock
{
public:
   Error();
 
   Error(const Error& in_other);
 
   Error(std::string in_name, int in_code, const ErrorLocation& in_location);
 
   Error(std::string in_name, int in_code, const Error& in_cause, const ErrorLocation& in_location);
 
   Error(std::string in_name, int in_code, std::string in_message, const ErrorLocation& in_location);
 
   Error(std::string in_name,
         int in_code,
         std::string in_message,
         const Error& in_cause,
         const ErrorLocation& in_location);
 
   ~Error() override = default;
 
   explicit operator bool() const;
 
   bool operator!() const;
 
   bool operator==(const Error& in_other) const;
 
   bool operator!=(const Error& in_other) const;
 
   void addOrUpdateProperty(const std::string& in_name, const std::string& in_value);
 
   void addOrUpdateProperty(const std::string& in_name, const system::FilePath& in_value);
 
   void addOrUpdateProperty(const std::string& in_name, int in_value);
 
   void addProperty(const std::string& in_name, const std::string& in_value);
 
   void addProperty(const std::string& in_name, const system::FilePath& in_value);
 
   void addProperty(const std::string& in_name, int in_value);
 
   std::string asString() const;
 
   bool hasCause() const;
   
   const Optional<Error>& getCause() const;
 
   int getCode() const;
 
   const ErrorLocation& getLocation() const;
 
   const std::string& getMessage() const;
 
   const std::string& getName() const;
 
   const ErrorProperties& getProperties() const;
 
   std::string getProperty(const std::string& name) const;
 
   std::string getSummary() const;
 
   bool isExpected() const;
 
   void setExpected();
 
private:
   void copyOnWrite();
 
   bool isError() const;
 
   // The private implementation of Error.
   PRIVATE_IMPL_SHARED(m_impl);
 
   Impl& impl() const;
};
 
class Success : public Error
{
public:
   Success() : Error() {}
};
 
std::ostream& operator<<(std::ostream& io_ostream, const Error& in_error);
 
Error systemError(int in_code, const ErrorLocation& in_location);
 
Error systemError(const std::error_code& in_code, const ErrorLocation& in_location);
 
Error systemError(const std::system_error& in_error, const ErrorLocation& in_location);
 
Error systemError(int in_code, const Error& in_cause, const ErrorLocation& in_location);
 
Error systemError(const std::error_code& in_code, const Error& in_cause, const ErrorLocation& in_location);
 
Error systemError(const std::system_error& in_error, const Error& in_cause, const ErrorLocation& in_location);
 
Error systemError(int in_code, const std::string& in_description, const ErrorLocation& in_location);
 
Error systemError(const std::error_code& in_code, const std::string& in_description, const ErrorLocation& in_location);
 
Error systemError(
   const std::system_error& in_error,
   const std::string& in_description,
   const ErrorLocation& in_location);
 
Error systemError(
   int in_code,
   const std::string& in_description,
   const Error& in_cause,
   const ErrorLocation& in_location);
 
Error systemError(
   const std::error_code& in_code,
   const std::string& in_description,
   const Error& in_cause,
   const ErrorLocation& in_location);
 
Error systemError(
   const std::system_error& in_error,
   const std::string& in_description,
   const Error& in_cause,
   const ErrorLocation& in_location);
 
Error systemCallError(
   const std::string& in_function,
   int in_code,
   const ErrorLocation& in_location);
 
Error systemCallError(
   const std::string& in_function,
   int in_code,
   const std::string& in_message,
   const ErrorLocation& in_location);
 
Error unknownError(const std::string& in_message, const ErrorLocation& in_location);
 
Error unknownError(const std::string& in_message, const Error& in_cause, const ErrorLocation& in_location);
 
} // namespace launcher_plugins
} // namespace rstudio
 
#ifdef STRIPPED_FILENAME
#define ERROR_LOCATION rstudio::launcher_plugins::ErrorLocation( \
      __FUNCTION__, STRIPPED_FILENAME, __LINE__)
#else
#define ERROR_LOCATION rstudio::launcher_plugins::ErrorLocation( \
      __FUNCTION__, __FILE__, __LINE__)
#endif
 
#define CATCH_UNEXPECTED_EXCEPTION                                                                  \
   catch(const std::exception& e)                                                                   \
   {                                                                                                \
      rstudio::launcher_plugins::logging::logErrorMessage(std::string("Unexpected exception: ") +   \
                        e.what(), ERROR_LOCATION);                                                  \
   }                                                                                                \
   catch(...)                                                                                       \
   {                                                                                                \
      rstudio::launcher_plugins::logging::logErrorMessage("Unknown exception", ERROR_LOCATION);     \
   }
 
#endif