exceptions.h

Go to the documentation of this file.

/*
 *  exceptions.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H
 
#include <exception>
 
// C++ includes:
#include <sstream>
 
// Includes from nestkernel:
#include "nest_time.h"
 
// Includes from thirdparty:
#include "compose.hpp"
 
 
namespace nest
{
 
class Event;
 
class KernelException : public std::runtime_error
{
public:
  explicit KernelException()
    : std::runtime_error( "" )
  {
  }
 
  explicit KernelException( const std::string& msg )
    : std::runtime_error( msg )
  {
  }
 
  virtual std::string
  exception_name() const
  {
    return "KernelException";
  }
};
 
class DynamicModuleManagementError : public KernelException
{
public:
  explicit DynamicModuleManagementError( const std::string& msg )
    : KernelException( msg )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "DynamicModuleManagementError";
  }
};
 
class NotImplemented : public KernelException
{
public:
  explicit NotImplemented( const std::string& msg )
    : KernelException( msg )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "NotImplemented";
  }
};
 
 
class TypeMismatch : public KernelException
{
 
public:
  explicit TypeMismatch()
    : KernelException( "The expected datatype is unknown in the current context." )
  {
  }
 
  explicit TypeMismatch( const std::string& expected )
    : KernelException( "Expected datatype: " + expected )
  {
  }
 
  explicit TypeMismatch( const std::string& expected, const std::string& provided )
    : KernelException( "Expected datatype: " + expected + ", provided datatype: " + provided )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "TypeMismatch";
  }
};
 
 
class UnaccessedDictionaryEntry : public KernelException
{
public:
  UnaccessedDictionaryEntry( const std::string& what, const std::string& where, const std::string& missed )
    : KernelException( "Unaccessed elements in " + what + ", in function " + where + ": " + missed )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnaccessedDictionaryEntry";
  }
};
 
class UnknownModelName : public KernelException
{
  std::string compose_msg_( const std::string& model_name ) const;
 
public:
  UnknownModelName( const std::string& model_name )
    : KernelException( compose_msg_( model_name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownModelName";
  }
};
 
class UnknownComponent : public KernelException
{
  std::string compose_msg_( const std::string& model_name ) const;
 
public:
  explicit UnknownComponent( const std::string& component_name )
    : KernelException( compose_msg_( component_name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownComponent";
  }
};
 
class NewModelNameExists : public KernelException
{
  std::string compose_msg_( const std::string& model_name ) const;
 
public:
  NewModelNameExists( const std::string& model_name )
    : KernelException( compose_msg_( model_name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "NewModelNameExists";
  }
};
 
class ModelInUse : public KernelException
{
  std::string compose_msg_( const std::string& model_name ) const;
 
public:
  ModelInUse( const std::string& model_name )
    : KernelException( compose_msg_( model_name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "ModelInUse";
  }
};
 
class UnknownSynapseType : public KernelException
{
  std::string compose_msg_( const int id ) const;
  std::string compose_msg_( const std::string& name ) const;
 
public:
  UnknownSynapseType( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  UnknownSynapseType( std::string name )
    : KernelException( compose_msg_( name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownSynapseType";
  }
};
 
class UnknownNode : public KernelException
{
  std::string compose_msg_( const int id ) const;
 
public:
  UnknownNode()
    : KernelException( "UnknownNode" )
  {
  }
 
  UnknownNode( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownNode";
  }
};
 
class NoThreadSiblingsAvailable : public KernelException
{
  std::string compose_msg_( const int id ) const;
 
public:
  NoThreadSiblingsAvailable()
    : KernelException( "UnknownNode" )
  {
  }
 
  NoThreadSiblingsAvailable( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "NoThreadSiblingsAvailable";
  }
};
 
class LocalNodeExpected : public KernelException
{
  std::string compose_msg_( const int id ) const;
 
public:
  LocalNodeExpected( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "LocalNodeExpected";
  }
};
 
class NodeWithProxiesExpected : public KernelException
{
  std::string compose_msg_( const int id ) const;
 
public:
  NodeWithProxiesExpected( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "NodeWithProxiesExpected";
  }
};
 
/*
 * Exception to be thrown if the parent
 * compartment does not exist
 */
class UnknownCompartment : public KernelException
{
  std::string compose_msg_( const long compartment_idx, const std::string info ) const;
 
public:
  UnknownCompartment( long compartment_idx, std::string info )
    : KernelException( compose_msg_( compartment_idx, info ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownCompartment";
  }
};
 
class UnknownReceptorType : public KernelException
{
  std::string compose_msg_( const long receptor_type, const std::string name ) const;
 
public:
  UnknownReceptorType( long receptor_type, std::string name )
    : KernelException( compose_msg_( receptor_type, name ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownReceptorType";
  }
};
 
class IncompatibleReceptorType : public KernelException
{
  std::string compose_msg( const long receptor_type, const std::string name, const std::string event );
 
public:
  IncompatibleReceptorType( long receptor_type, std::string name, std::string event_type )
    : KernelException( compose_msg( receptor_type, name, event_type ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "IncompatibleReceptorType";
  }
};
 
class UnknownPort : public KernelException
{
  std::string compose_msg_( const int id ) const;
  std::string compose_msg_( const int id, const std::string msg ) const;
 
public:
  UnknownPort( int id )
    : KernelException( compose_msg_( id ) )
  {
  }
 
  UnknownPort( int id, std::string msg )
    : KernelException( compose_msg_( id, msg ) )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnknownPort";
  }
};
 
class IllegalConnection : public KernelException
{
public:
  IllegalConnection()
    : KernelException( "Creation of connection is not possible." )
  {
  }
 
  IllegalConnection( std::string msg )
    : KernelException( "Creation of connection is not possible because:\n" + msg )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "IllegalConnection";
  }
};
 
class InexistentConnection : public KernelException
{
private:
  std::string msg_;
 
public:
  InexistentConnection()
    : KernelException( "InexistentConnection" )
  {
    msg_ = "Deletion of connection is not possible because it does not exist.";
  }
 
  InexistentConnection( const std::string& msg )
    : KernelException( "InexistentConnection" )
  {
    msg_ = "Deletion of connection is not possible because:\n";
    msg_ += msg;
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "InexistentConnection";
  }
};
 
class UnknownThread : public KernelException
{
private:
  std::string msg_;
 
public:
  UnknownThread( int id )
    : KernelException( "UnknownThread" )
  {
    msg_ = String::compose( "Thread with id %1 is outside of range.", id );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "UnknownThread";
  }
};
 
class BadDelay : public KernelException
{
private:
  std::string msg_;
 
public:
  BadDelay( double delay, const std::string& msg )
    : KernelException( "BadDelay" )
  {
    msg_ = String::compose( "Delay value %1 is invalid: %2", delay, msg );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BadDelay";
  }
};
 
class UnexpectedEvent : public KernelException
{
private:
  std::string msg_;
 
public:
  UnexpectedEvent()
    : KernelException( "UnexpectedEvent" )
  {
    msg_ = "Target node cannot handle input event.\n";
    msg_ += "    A common cause for this is an attempt to connect recording devices incorrectly.\n";
    msg_ += "    Note that recorders such as spike recorders must be connected as\n\n";
    msg_ += "        nest.Connect(neurons, spike_det)\n\n";
    msg_ += "    while meters such as voltmeters must be connected as\n\n";
    msg_ += "        nest.Connect(meter, neurons) ";
  }
 
  UnexpectedEvent( const std::string& msg )
    : KernelException( "UnexpectedEvent" )
  {
    msg_ = msg;
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "UnexpectedEvent";
  }
};
 
 
class UnsupportedEvent : public KernelException
{
  std::string compose_msg_() const;
 
public:
  UnsupportedEvent()
    : KernelException( compose_msg_() )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "UnsupportedEvent";
  }
};
 
class BadProperty : public KernelException
{
private:
  std::string msg_;
 
public:
  BadProperty()
    : KernelException( "BadProperty" )
    , msg_()
  {
  }
  BadProperty( std::string msg )
    : KernelException( "BadProperty" )
    , msg_( msg )
  {
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BadProperty";
  }
};
 
class BadParameter : public KernelException
{
private:
  std::string msg_;
 
public:
  BadParameter()
    : KernelException( "BadParameter" )
    , msg_()
  {
  }
  BadParameter( std::string msg )
    : KernelException( "BadParameter" )
    , msg_( msg )
  {
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BadParameter";
  }
};
 
class BadParameterValue : public KernelException
{
  std::string msg_;
 
public:
  BadParameterValue()
    : KernelException( "BadParameterValue" )
    , msg_()
  {
  }
 
  BadParameterValue( std::string msg )
    : KernelException( "BadParameterValue" )
    , msg_( msg )
  {
  }
 
  ~BadParameterValue() throw()
  {
  }
 
  std::string
  exception_name() const override
  {
    return "BadParameterValue";
  }
};
 
class DimensionMismatch : public KernelException
{
private:
  std::string msg_;
 
public:
  DimensionMismatch()
    : KernelException( "DimensionMismatch" )
  {
    msg_ = "Dimensions of two or more variables do not match.";
  }
 
  DimensionMismatch( int expected, int provided )
    : KernelException( "DimensionMismatch" )
  {
    msg_ = String::compose( "Expected dimension size: %1 Provided dimension size: %2.", expected, provided );
  }
 
  DimensionMismatch( const std::string& msg )
    : KernelException( "DimensionMismatch" )
  {
    msg_ = msg;
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "DimensionMismatch";
  }
};
 
class DistributionError : public KernelException
{
public:
  DistributionError()
    : KernelException( "DistributionError" )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "DistributionError";
  }
};
 
class InvalidDefaultResolution : public KernelException
{
private:
  std::string msg_;
 
public:
  InvalidDefaultResolution( const std::string& model, const std::string& property, const Time& value )
    : KernelException( "InvalidDefaultResolution" )
  {
    std::ostringstream oss;
    oss << "The default resolution of " << Time::get_resolution() << " is not consistent with the value " << value
        << " of property '" << property << "' in model " << model << ".\n"
        << "This is an internal NEST error, please report it at https://github.com/nest/nest-simulator/issues";
 
    msg_ = oss.str();
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "InvalidDefaultResolution";
  }
};
 
class InvalidTimeInModel : public KernelException
{
private:
  std::string msg_;
 
public:
  InvalidTimeInModel( const std::string& model, const std::string& property, const Time& value )
    : KernelException( "InvalidTimeInModel" )
  {
    std::ostringstream oss;
    oss << "The time property " << property << " = " << value << " of model " << model
        << " is not compatible with the resolution " << Time::get_resolution() << ".\n"
        << "Please set a compatible value with SetDefaults!";
 
    msg_ = oss.str();
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "InvalidTimeInModel";
  }
};
 
class StepMultipleRequired : public KernelException
{
private:
  std::string msg_;
 
public:
  StepMultipleRequired( const std::string& model, const std::string& property, const Time& value )
    : KernelException( "StepMultipleRequired" )
  {
    std::ostringstream oss;
    oss << "The time property " << property << " = " << value << " of model " << model
        << " must be a multiple of the resolution " << Time::get_resolution() << ".";
 
    msg_ = oss.str();
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "StepMultipleRequired";
  }
};
 
class TimeMultipleRequired : public KernelException
{
private:
  std::string msg_;
 
public:
  TimeMultipleRequired( const std::string& model,
    const std::string& name_a,
    const Time& value_a,
    const std::string& name_b,
    const Time& value_b )
    : KernelException( "StepMultipleRequired" )
  {
    std::ostringstream oss;
    oss << "In model " << model << ", the time property " << name_a << " = " << value_a
        << " must be multiple of time property " << name_b << " = " << value_b << '.';
 
    msg_ = oss.str();
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "TimeMultipleRequired";
  }
};
 
class GSLSolverFailure : public KernelException
{
private:
  std::string msg_;
 
public:
  GSLSolverFailure( const std::string& model, const int status )
    : KernelException( "GSLSolverFailure" )
  {
    msg_ = String::compose(
      "In model %1 the GSL solver returned with exit status %2.\n"
      "Please make sure you have installed a recent GSL version (> gsl-1.10).",
      model,
      status );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "GSLSolverFailure";
  }
};
 
class NumericalInstability : public KernelException
{
private:
  std::string msg_;
 
public:
  NumericalInstability( const std::string& model )
    : KernelException( "NumericalInstability" )
  {
    msg_ = String::compose( "NEST detected a numerical instability while updating %1.", model );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "NumericalInstability";
  }
};
 
class NamingConflict : public KernelException
{
private:
  std::string msg_;
 
public:
  NamingConflict( const std::string& msg )
    : KernelException( "NamingConflict" )
    , msg_( msg )
  {
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "NamingConflict";
  }
};
 
class RangeCheck : public KernelException
{
private:
  std::string msg_;
 
public:
  RangeCheck( const size_t expected_size )
    : KernelException( "RangeCheck" )
    , msg_( String::compose( "Array with length %1 expected.", expected_size ) )
  {
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "RangeCheck";
  }
};
 
class IOError : public KernelException
{
private:
  std::string msg_;
 
public:
  IOError()
    : KernelException( "IOError" )
  {
    msg_ = "";
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "IOError";
  }
};
 
class KeyError : public KernelException
{
private:
  std::string msg_;
 
public:
  KeyError( const std::string& key, const std::string& map_type, const std::string& map_op )
    : KernelException( "KeyError" )
  {
    msg_ = String::compose(
      "Key '%1' not found in map. Error encountered with map type: '%2' when applying operation: '%3'.",
      key,
      map_type,
      map_op );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "KeyError";
  }
};
 
class InternalError : public KernelException
{
private:
  std::string msg_;
 
public:
  InternalError()
    : KernelException()
    , msg_( "InternalError" )
  {
  }
 
  InternalError( std::string msg )
    : KernelException( msg )
  {
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "InternalError";
  }
};
 
#ifdef HAVE_MUSIC
class MUSICPortUnconnected : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICPortUnconnected( const std::string& model, const std::string& portname )
    : KernelException( "MUSICPortUnconnected" )
  {
    msg_ = String::compose(
      "Cannot use instance of model %1 because the MUSIC "
      "port %2 is unconnected.",
      model,
      portname );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICPortUnconnected";
  }
};
 
 
class MUSICPortHasNoWidth : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICPortHasNoWidth( const std::string& model, const std::string& portname )
    : KernelException( "MUSICPortHasNoWidth" )
  {
    msg_ = String::compose(
      "Cannot use instance of model %1 because the MUSIC "
      "port %2 has no width specified in configuration file.",
      model,
      portname );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICPortHasNoWidth";
  }
};
 
class MUSICPortAlreadyPublished : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICPortAlreadyPublished( const std::string& model, const std::string& portname )
    : KernelException( "MUSICPortAlreadyPublished" )
  {
    msg_ = String::compose(
      "The instance of model %1 cannot change the MUSIC "
      "port / establish connections %2 since it is already published.",
      model,
      portname );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICPortAlreadyPublished";
  }
};
 
class MUSICSimulationHasRun : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICSimulationHasRun( const std::string& model )
    : KernelException( "MUSICSimulationHasRun" )
  {
    msg_ = String::compose(
      "The instance of model %1 won't work, since the simulation "
      "has already been running",
      model );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICSimulationHasRun";
  }
};
 
class MUSICChannelUnknown : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICChannelUnknown( const std::string& model, const std::string& portname, int channel )
    : KernelException( "MUSICChannelUnknown" )
  {
    msg_ = String::compose(
      "The port %1 cannot be mapped in %2 because the channel %3 "
      "does not exist.",
      portname,
      model,
      channel );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICChannelUnknown";
  }
};
 
class MUSICPortUnknown : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICPortUnknown( const std::string& portname )
    : KernelException( "MUSICPortUnknown" )
  {
    msg_ = String::compose( "The port %1 does not exist.", portname );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICPortUnknown";
  }
};
 
class MUSICChannelAlreadyMapped : public KernelException
{
private:
  std::string msg_;
 
public:
  MUSICChannelAlreadyMapped( const std::string& model, const std::string& portname, int channel )
    : KernelException( "MUSICChannelAlreadyMapped" )
  {
    msg_ = String::compose(
      "The channel %1 of port %2 has already be mapped "
      "to another proxy in %3.",
      channel,
      portname,
      model );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MUSICChannelAlreadyMapped";
  }
};
#endif  // HAVE_MUSIC
 
#ifdef HAVE_MPI
class MPIPortsFileUnknown : public KernelException
{
private:
  std::string msg_;
 
public:
  explicit MPIPortsFileUnknown( const size_t node_id )
  {
    msg_ = String::compose(
      "The node with ID %1 requires a label, which specifies the "
      "folder with files containing the MPI ports.",
      node_id );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MPIPortsUnknown";
  }
};
 
class MPIPortsFileMissing : public KernelException
{
private:
  std::string msg_;
 
public:
  explicit MPIPortsFileMissing( const size_t node_id, const std::string path )
  {
    msg_ = String::compose(
      "The node with ID %1 expects a file with the MPI address at location %2. "
      "The file does not seem to exist.",
      node_id,
      path );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MPIPortsFileMissing";
  }
};
 
class MPIErrorCode : public KernelException
{
private:
  std::string msg_;
 
public:
  explicit MPIErrorCode( const int error_code );
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "MPIErrorCode";
  }
};
#endif  // HAVE_MPI
 
class UnmatchedSteps : public KernelException
{
private:
  std::string msg_;
 
public:
  UnmatchedSteps( int steps_left, int total_steps )
    : KernelException( "UnmatchedSteps" )
  {
    msg_ = String::compose(
      "Steps for backend device don't match NEST steps: "
      "steps expected: %1 steps executed: %2.",
      total_steps,
      total_steps - steps_left );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "UnmatchedSteps";
  }
};
 
class BackendPrepared : public KernelException
{
private:
  const std::string backend_;
  std::string msg_;
 
public:
  BackendPrepared( const std::string& backend )
    : KernelException( "BackendPrepared" )
    , backend_( backend )
  {
    msg_ = String::compose( "Backend %1 may not be prepare()'d multiple times.", backend_ );
  }
 
  BackendPrepared( std::string&& backend )
    : KernelException( "BackendPrepared" )
    , backend_( std::move( backend ) )
  {
    msg_ = String::compose( "Backend %1 may not be prepare()'d multiple times.", backend_ );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BackendPrepared";
  }
};
 
class BackendAlreadyRegistered : public KernelException
{
private:
  const std::string backend_;
  std::string msg_;
 
public:
  BackendAlreadyRegistered( const std::string& backend )
    : KernelException( "BackendPrepared" )
    , backend_( backend )
  {
    msg_ = String::compose( "Backend %1 has already been registered.", backend_ );
  }
 
  BackendAlreadyRegistered( std::string&& backend )
    : KernelException( "BackendPrepared" )
    , backend_( std::move( backend ) )
  {
    msg_ = String::compose( "Backend %1 has already been registered.", backend_ );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BackendAlreadyRegistered";
  }
};
 
 
class BackendNotPrepared : public KernelException
{
private:
  const std::string backend_;
  std::string msg_;
 
public:
  BackendNotPrepared( const std::string& backend )
    : KernelException( "BackendNotPrepared" )
    , backend_( backend )
  {
    msg_ = String::compose(
      "Backend %1 may not be cleanup()'d "
      "without preparation (multiple cleanups?).",
      backend_ );
  }
 
  BackendNotPrepared( std::string&& backend )
    : KernelException( "BackendNotPrepared" )
    , backend_( std::move( backend ) )
  {
    msg_ = String::compose(
      "Backend %1 may not be cleanup()'d "
      "without preparation (multiple cleanups?).",
      backend_ );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "BackendNotPrepared";
  }
};
 
class LayerExpected : public KernelException
{
public:
  LayerExpected()
    : KernelException( "LayerExpected" )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "LayerExpected";
  }
};
 
class LayerNodeExpected : public KernelException
{
public:
  LayerNodeExpected()
    : KernelException( "LayerNodeExpected" )
  {
  }
 
  std::string
  exception_name() const override
  {
    return "LayerNodeExpected";
  }
};
 
class UndefinedName : public KernelException
{
private:
  std::string msg_;
 
public:
  UndefinedName( std::string name )
    : KernelException( "UndefinedName" )
  {
    msg_ = String::compose( "The name %1 is not defined.", name );
  }
 
  const char*
  what() const noexcept override
  {
    return msg_.data();
  };
 
  std::string
  exception_name() const override
  {
    return "UndefinedName";
  }
};
 
}  // namespace nest
#endif  // EXCEPTIONS_H