ItemDelegateErrors.h

#ifndef CBE__delegate__ItemDelegateErrors_h__
#define CBE__delegate__ItemDelegateErrors_h__
 
#include "cbe/Types.h"
 
#include "cbe/util/ErrorInfo.h"
#include "cbe/util/Exception.h"
#include "cbe/Filter.h"
#include "cbe/Item.h"
 
#include <iosfwd>
#include <string>
 
namespace cbe {
  namespace util {
 
struct Context;
 
  } // namespace util
  namespace delegate {
 
class LoadError {
public:
  class Error {
  public:
    Filter      filter{};
    ErrorCode   errorCode{};
    std::string reason{};
    std::string message{};
 
    Error();
    Error(Filter&&      filter,
          ErrorCode     errorCode,
          std::string&& reason,
          std::string&& message);
  }; // class LoadError::Error
 
  virtual ~LoadError() = 0;
 
  virtual void onLoadError(Error&& error, cbe::util::Context&& context) = 0;
 
  friend std::ostream& operator<<(std::ostream&           os,
                                  const LoadError::Error& error);
}; // struct LoadError
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class JoinError {
public:
  class Error {
  public:
    ErrorCode   errorCode{};
    std::string reason{};
    std::string message{};
 
    Error();
    Error(ErrorCode     errorCode,
          std::string&& reason,
          std::string&& message);
  }; // class JoinError::Error
 
  virtual ~JoinError() = 0;
 
  virtual void onJoinError(Error&& error, cbe::util::Context&& context) = 0;
 
  friend std::ostream& operator<<(std::ostream&           os,
                                  const JoinError::Error& error);
}; // class JoinError::Error
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class ItemError {
public:
  struct Error {
  public:
    Item        container{cbe::DefaultCtor{}};
    ItemType    type{};
    ErrorCode   errorCode{};
    std::string reason{};
    std::string message{};
 
    Error();
    Error(Item          container,
          ItemType      type,
          ErrorCode     errorCode,
          std::string&& reason,
          std::string&& message);
  }; // struct ItemError
 
  virtual ~ItemError() = 0;
  virtual void onItemError(Error&& error, cbe::util::Context&& context) = 0;
 
  friend std::ostream& operator<<(std::ostream&           os,
                                  const ItemError::Error& error);
}; // class ItemItemError::Error
 
  } // namespace delegate
} // namespace cbe
 
 
#endif // #ifndef CBE__delegate__ItemDelegateErrors_h__