ArcaneException.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ArcaneException.h                                           (C) 2000-2025 */
/*                                                                           */
/* Exceptions thrown by Arcane.                                              */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ARCANEEXCEPTION_H
#define ARCANE_CORE_ARCANEEXCEPTION_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Exception.h"
#include "arcane/utils/String.h"
 
#include "arcane/core/ArcaneTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT BadIDException
: public Exception
{
 public:

  BadIDException(const String& where, const String& invalid_name);
  ~BadIDException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  String m_invalid_name; 
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT BadItemIdException
: public Exception
{
 public:

  BadItemIdException(const String& where, Integer bad_id);
  ~BadItemIdException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  Integer m_bad_id; 
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT InternalErrorException
: public Exception
{
 public:
 
  InternalErrorException(const String& where, const String& why);
  InternalErrorException(const TraceInfo& where, const String& why);
  InternalErrorException(const InternalErrorException& ex) ARCANE_NOEXCEPT;
  ~InternalErrorException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  String m_why;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT BadVariableKindTypeException
: public Exception
{
 public:
 
  BadVariableKindTypeException(const TraceInfo& where, IVariable* valid_var,
                               eItemKind kind, eDataType datatype, int dimension);
  ~BadVariableKindTypeException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  IVariable* m_valid_var;
  eItemKind m_item_kind;
  eDataType m_data_type;
  int m_dimension;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT BadPartialVariableItemGroupNameException
: public Exception
{
 public:
 
  BadPartialVariableItemGroupNameException(const TraceInfo& where, IVariable* valid_var,
                                           const String& item_group_name);
  ~BadPartialVariableItemGroupNameException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  IVariable* m_valid_var;
  String m_item_group_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT UnknownItemTypeException
: public Exception
{
 public:
 
  UnknownItemTypeException(const String& where, Integer nb_node, Integer item_id);
  UnknownItemTypeException(const UnknownItemTypeException& ex) ARCANE_NOEXCEPT;
  ~UnknownItemTypeException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
 
  Integer m_nb_node;
  Integer m_item_id;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT BadReferenceException
: public Exception
{
 public:
 
  explicit BadReferenceException(const String& where);
  ~BadReferenceException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT ReaderWriterException
: public Exception
{
 public:
 
  ReaderWriterException(const String& where, const String& message);
  ReaderWriterException(const TraceInfo& where, const String& message);
  ReaderWriterException(const ReaderWriterException& ex) ARCANE_NOEXCEPT;
  ~ReaderWriterException() ARCANE_NOEXCEPT override {}
 
 public:
 
  void explain(std::ostream& m) const override;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT AssertionException
: public Exception
{
 public:

  explicit AssertionException(const TraceInfo& where);

  AssertionException(const TraceInfo& where, const String& expected, const String& actual);
 
 public:
 
  void explain(std::ostream& m) const override;

  const char* file() const { return m_file; }

  int line() const { return m_line; }
 
 public:
 
  using Exception::message;
  using Exception::where;
 
 private:
 
  const char* m_file;
  int m_line;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif