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 "sliexceptions.h"
#include "nest_time.h"
#include "name.h"

class SLIInterpreter;

namespace nest {

  class Event;

  class KernelException : public SLIException
  {
  public:
  KernelException()
    : SLIException("KernelException") {}

  KernelException(char const * const what)
    : SLIException(what) {}
    
    virtual ~KernelException() throw() {}

    virtual std::string message(){ return std::string(); }
  };

  class UnknownModelName: public KernelException
  {
    const Name n_;
  public:
  UnknownModelName(const Name &n) 
    : KernelException("UnknownModelName"),
      n_(n) {}
    
    ~UnknownModelName() throw () {}
    std::string message();
  };

  class NewModelNameExists: public KernelException
  {
    const Name n_;
  public:
  NewModelNameExists(const Name &n) 
    : KernelException("NewModelNameExists"),
      n_(n) {}
    ~NewModelNameExists() throw () {}
    std::string message();
  };

  class UnknownModelID: public KernelException
  {
    const long id_;
  public:
  UnknownModelID(long id) 
    : KernelException("UnknownModelID"),
      id_(id) {}
    ~UnknownModelID() throw () {}
    std::string message();
  };

  class ModelInUse: public KernelException
  {
    const std::string modelname_;
  public:
  ModelInUse(const std::string &modelname) 
    : KernelException("ModelInUse"),
      modelname_(modelname) {}

    ~ModelInUse() throw () {}
    std::string message();
  };

  class UnknownSynapseType: public KernelException
  {
    int synapseid_;
    std::string synapsename_;
  public:
  UnknownSynapseType(int id)
    : KernelException("UnknownSynapseType"),
      synapseid_(id),
      synapsename_()
      {}

  UnknownSynapseType(std::string name)
    : KernelException("UnknownSynapseType"),
      synapseid_(),
      synapsename_(name)
      {}
    
    ~UnknownSynapseType() throw () {}

    std::string message();
  };

  class UnknownNode: public KernelException
  {
    int id_;
  public:
    UnknownNode()
      : KernelException("UnknownNode"),
      id_(-1)
      {}
    UnknownNode(int id) 
      : KernelException("UnknownNode"),
      id_(id)
      {}

    ~UnknownNode() throw () {}

    std::string message();
  };

  class NoThreadSiblingsAvailable: public KernelException
  {
    int id_;
  public:
    NoThreadSiblingsAvailable()
      : KernelException("UnknownNode"),
      id_(-1)
      {}
    NoThreadSiblingsAvailable(int id)
      : KernelException("UnknownNode"),
      id_(id)
      {}

    ~NoThreadSiblingsAvailable() throw () {}

    std::string message();
  };

      
  class LocalNodeExpected: public KernelException
  {
    int id_;
  public:
  LocalNodeExpected(int id)
    : KernelException("LocalNodeExpected"),
      id_(id)
      {}

    ~LocalNodeExpected() throw () {}

    std::string message();
  };

  class NodeWithProxiesExpected: public KernelException
  {
    int id_;
  public:
  NodeWithProxiesExpected(int id)
    : KernelException("NodeWithProxiesExpected"),
      id_(id)
      {}

    ~NodeWithProxiesExpected() throw () {}

    std::string message();
  };

  class UnknownReceptorType: public KernelException
  {
    long receptor_type_;
    std::string name_;
  public:
  UnknownReceptorType(long receptor_type, std::string name)
    : KernelException("UnknownReceptorType"),
      receptor_type_(receptor_type), 
      name_(name) {}

    ~UnknownReceptorType() throw () {}
    std::string message();
  };

  class IncompatibleReceptorType: public KernelException
  {
    long receptor_type_;
    std::string name_;
    std::string event_type_;
  public:
  IncompatibleReceptorType(long receptor_type, std::string name,
               std::string event)
    : KernelException("IncompatibleReceptorType"),
      receptor_type_(receptor_type), 
      name_(name),
      event_type_(event)
      {}

    ~IncompatibleReceptorType() throw () {}
    std::string message();
  };

  class UnknownPort: public KernelException
  {
    int id_;
  public:
  UnknownPort(int id)
    : KernelException("UnknownPort"),
      id_(id)
      {}

    ~UnknownPort() throw () {}

    std::string message();
  };

  class IllegalConnection: public KernelException
  {
  public:
  IllegalConnection() 
    : KernelException("IllegalConnection"),
      msg_()
  {}

  IllegalConnection(std::string msg)
    : KernelException("IllegalConnection"),
      msg_(msg)
      {}

    ~IllegalConnection() throw () {}

    std::string message();
    
  private:
    std::string msg_;
  };

  class UnknownThread: public KernelException
  {
    int id_;
  public:
  UnknownThread(int id)
    : KernelException("UnknownThread"),
      id_(id) 
      {}
    
    ~UnknownThread() throw () {}
    
    std::string message();
  };

  class BadDelay: public KernelException
  {
    double delay_;
    std::string message_;

  public:
  BadDelay(double delay,
           std::string message)
    : KernelException("BadDelay"),
      delay_(delay),
      message_(message)
      {}
    
    ~BadDelay() throw () {}
    
    std::string message();
  };

  class UnexpectedEvent: public KernelException
  {
  public:
  UnexpectedEvent()
    : KernelException("UnexpectedEvent") 
      {}

    ~UnexpectedEvent() throw () {}

    std::string message();
  };

  class UnsupportedEvent: public KernelException
  {
  public:
  UnsupportedEvent()
    : KernelException("UnsupportedEvent")
      {}
    
    ~UnsupportedEvent() throw () {}
    std::string message();
  };
  
  class BadProperty: public KernelException
  {
    std::string msg_;
  public:
  BadProperty()
    : KernelException("BadProperty"),
      msg_()
    {}
  BadProperty(std::string msg)
    : KernelException("BadProperty"),
      msg_(msg)
      {}

    ~BadProperty() throw () {}

    std::string message();
  };

  class BadParameter: public KernelException
  {
    std::string msg_;
  public:
  BadParameter()
    : KernelException("BadParameter"),
      msg_()
    {}
  BadParameter(std::string msg)
    : KernelException("BadParameter"),
      msg_(msg)
      {}

    ~BadParameter() throw () {}

    std::string message();
  };

  class DimensionMismatch: public KernelException
  {
    int expected_;
    int provided_;
  public:
  DimensionMismatch()
    : KernelException("DimensionMismatch"),
      expected_(),
      provided_()
    {}

  DimensionMismatch(int expected, int provided)
    : KernelException("DimensionMismatch"),
      expected_(expected),
      provided_(provided)
    {}

    ~DimensionMismatch() throw () {}

    std::string message();
  };

  class DistributionError: public KernelException
  {
  public:
  DistributionError()
    : KernelException("DistributionError") {}
    ~DistributionError() throw () {}

    std::string message();
  };
  
  class SubnetExpected: public KernelException
  {
  public:
  SubnetExpected()
    : KernelException("SubnetExpected") {}
    ~SubnetExpected() throw () {}
    
    std::string message();
  };

  class SimulationError: public KernelException
  {
  public:
  SimulationError()
    : KernelException("SimulationError") {}
    ~SimulationError() throw () {}
    
    std::string message();
  };
  
  class InvalidDefaultResolution: public KernelException
  {
  public:
    InvalidDefaultResolution(const std::string& model,
                             const Name& property, const Time& value)
      : KernelException("InvalidDefaultResolution"),
        model_(model), prop_(property), val_(value)
      {}
    ~InvalidDefaultResolution() throw() {}
    
    std::string message();

  private:
    const std::string model_;
    const Name        prop_;
    const Time        val_;
  };

  class InvalidTimeInModel: public KernelException
  {
  public:
    InvalidTimeInModel(const std::string& model,
                             const Name& property, const Time& value)
      : KernelException("InvalidTimeInModel"),
        model_(model), prop_(property), val_(value)
      {}
    ~InvalidTimeInModel() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const Name        prop_;
      const Time        val_;
  };

  class StepMultipleRequired: public KernelException
  {
  public:
    StepMultipleRequired(const std::string& model,
                             const Name& property, const Time& value)
      : KernelException("StepMultipleRequired"),
        model_(model), prop_(property), val_(value)
      {}
    ~StepMultipleRequired() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const Name        prop_;
      const Time        val_;
  };
  
  class TimeMultipleRequired: public KernelException
  {
  public:
    TimeMultipleRequired(const std::string& model,
                         const Name& name_a, const Time& value_a,
                         const Name& name_b, const Time& value_b)
      : KernelException("StepMultipleRequired"),
        model_(model), prop_a_(name_a), val_a_(value_a),
        prop_b_(name_b), val_b_(value_b)
      {}
    ~TimeMultipleRequired() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const Name        prop_a_;
      const Time        val_a_;
      const Name        prop_b_;
      const Time        val_b_;
  };

  class GSLSolverFailure: public KernelException
  {
  public:
    GSLSolverFailure(const std::string& model,
                     const int status)
      : KernelException("GSLSolverFailure"),
        model_(model),
        status_(status)
      {}
    ~GSLSolverFailure() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const int status_;
  };

  class NumericalInstability: public KernelException
  {
  public:
    NumericalInstability(const std::string& model)
      : KernelException("GSLSolverFailure"),
        model_(model)
      {}
    ~NumericalInstability() throw() {}
    
    std::string message();

    private:
      const std::string model_;
  };

#ifdef HAVE_MUSIC

  class MUSICPortUnconnected : public KernelException
  {
  public:
  MUSICPortUnconnected(const std::string& model, const std::string& portname)
    : KernelException("MUSICPortUnconnected"),
      model_(model),
      portname_(portname)
      {}
    ~MUSICPortUnconnected() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const std::string portname_;
  };

  class MUSICPortHasNoWidth : public KernelException
  {
  public:
  MUSICPortHasNoWidth(const std::string& model, const std::string& portname)
    : KernelException("MUSICPortHasNoWidth"),
      model_(model),
      portname_(portname)
      {}
    ~MUSICPortHasNoWidth() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const std::string portname_;
  };


  class MUSICPortAlreadyPublished : public KernelException
  {
  public:
  MUSICPortAlreadyPublished(const std::string& model, const std::string& portname)
    : KernelException("MUSICPortAlreadyPublished"),
      model_(model),
      portname_(portname)
      {}
    ~MUSICPortAlreadyPublished() throw() {}
    
    std::string message();

    private:
      const std::string model_;
      const std::string portname_;
  };
  
  class MUSICSimulationHasRun : public KernelException
  {
  public:
  MUSICSimulationHasRun(const std::string& model)
    : KernelException("MUSICSimulationHasRun"),
      model_(model)
      {}
    ~MUSICSimulationHasRun() throw() {}
    
    std::string message();

    private:
      const std::string model_;
  };
  
 
  class MUSICChannelUnknown : public KernelException
  {
  public:
  MUSICChannelUnknown(const std::string& model, const std::string& portname, int channel)
    : KernelException("MUSICChannelUnknown"),
      portname_(portname),
      channel_(channel),
      model_(model)
      {}
    ~MUSICChannelUnknown() throw() {}
    
    std::string message();

    private:
    const std::string portname_;
    const int channel_;
    const std::string model_;
  };

  class MUSICPortUnknown : public KernelException
  {
  public:
  MUSICPortUnknown(const std::string& portname)
    : KernelException("MUSICPortUnknown"),
      portname_(portname)
      {}
    ~MUSICPortUnknown() throw() {}
    
    std::string message();

    private:
    const std::string portname_;
  };

  class MUSICChannelAlreadyMapped : public KernelException
  {
  public:
  MUSICChannelAlreadyMapped(const std::string& model, const std::string& portname, int channel)
    : KernelException("MUSICChannelAlreadyMapped"),
      portname_(portname),
      channel_(channel),
      model_(model)
      {}
    ~MUSICChannelAlreadyMapped() throw() {}
    
    std::string message();

    private:
    const std::string portname_;
    const int channel_;
    const std::string model_;
  };
#endif
}
#endif