sliexceptions.h

Go to the documentation of this file.

/*
 *  sliexceptions.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 SLIEXCEPTIONS_H
#define SLIEXCEPTIONS_H

#include <iostream>
#include <string>
#include "name.h"
#include <vector>

class SLIInterpreter;


#define UNKNOWN "unknown"
#define UNKNOWN_NUM -1

class SLIException: public std::exception
{
  std::string what_;
 public:
 SLIException(char const * const what)
   : what_(what)
  {}
  
  virtual ~SLIException() throw() {};

  virtual const char * what() const throw()
  {
    return what_.c_str();
  }

  virtual std::string message() = 0;
};
  
class InterpreterError: public SLIException
{
public:
  virtual ~InterpreterError() throw() {}
  
 InterpreterError(char const * const what)
   : SLIException(what)
  {}
};

class WrappedThreadException: public SLIException
{
 public:
  WrappedThreadException(std::exception&);
  virtual ~WrappedThreadException() throw() {}
  std::string message() { return message_; }

 private:
  std::string message_;
};

class DivisionByZero: public SLIException
{
 public:
  virtual ~DivisionByZero() throw() {}
  
 DivisionByZero()
   : SLIException("DivisionByZero")
    {}
  std::string message();

};

// -------------------- Type Mismatch -------------------------
class TypeMismatch: public InterpreterError //SLIException
{
  std::string expected_;
  std::string provided_;
public:
  ~TypeMismatch() throw() {}

  TypeMismatch() :
      InterpreterError("TypeMismatch")
      {}
  
  TypeMismatch(const std::string& expectedType)
      : InterpreterError("TypeMismatch"),
        expected_(expectedType)
      {}

  TypeMismatch(const std::string& expectedType, const std::string& providedType)
      : InterpreterError("TypeMismatch"), 
        expected_(expectedType), 
        provided_(providedType)
      {}
  
  std::string message();
};

class SystemSignal: public InterpreterError
{
  int signal_;
 public:
  ~SystemSignal() throw() {}
 SystemSignal(int s)
   : InterpreterError("SystemSignal"), 
    signal_(s){}

  std::string message();
};

// -------------------- Array Size Mismatch -------------------------
class RangeCheck: public InterpreterError
{
  int size_;
public:
  ~RangeCheck() throw() {}

 RangeCheck(int s = 0)
   : InterpreterError("RangeCheck"),
    size_(s)
    {}

  std::string message();

};

class ArgumentType: public InterpreterError
{
  int where; // Number of the parameter that was wrong.
 public:
 ArgumentType(int w)
   : InterpreterError("ArgumentType"),
    where(w){}
  
  std::string message();

};

class BadParameterValue: public SLIException
{
  std::string msg_;

public:

  BadParameterValue()
    : SLIException("BadParameterValue"),
      msg_()
  {}

  BadParameterValue(std::string msg)
    : SLIException("BadParameterValue"),
      msg_(msg)
  {}
  
  ~BadParameterValue() throw () {}
  
  std::string message();
};

// -------------------- Dict Error -------------------------
class DictError: public InterpreterError
{
public:
  virtual ~DictError() throw() {}

 DictError(char const * const)
   : InterpreterError("DictError")
    {}
};

// -------------------- Unknown Name -------------------------
class UndefinedName: public DictError // was UnknownName
{
  std::string name_;
 public:
  ~UndefinedName() throw() {}
 UndefinedName(const std::string& name)
   : DictError("UndefinedName"),
    name_(name)
    {}

  std::string message();

};

// -------------------- Entry Type Mismatch -------------------------
class EntryTypeMismatch: public DictError
{
  std::string expected_;
  std::string provided_;
 public:
  ~EntryTypeMismatch() throw() {}
 EntryTypeMismatch(const std::string& expectedType, const std::string& providedType)
   : DictError("EntryTypeMismatch"), 
    expected_(expectedType), 
    provided_(providedType)
    {}
  
  std::string message();
};

// -------------------- Stack Error -------------------------
class StackUnderflow: public InterpreterError
{
  int needed;
  int given;
 public:
 StackUnderflow(int n, int g)
   : InterpreterError("StackUnderflow"), 
    needed(n), 
    given(g){};

  std::string message();
};



// -------------------- I/O Error -------------------------
class IOError: public SLIException
{
public:
  ~IOError() throw() {}
 IOError()
   : SLIException("IOError")
    {}
  
  std::string message();
};

class UnaccessedDictionaryEntry: public DictError
{
  std::string msg_;
 public:
  ~UnaccessedDictionaryEntry() throw() {}
  //input: string with names of not accessed
 UnaccessedDictionaryEntry(const std::string& m)
   : DictError("UnaccessedDictionaryEntry"),
    msg_(m) {}

  std::string message();
};


// ------------ Module related error --------------------------

class DynamicModuleManagementError: public SLIException
{
  std::string msg_;
 public:
  ~DynamicModuleManagementError() throw() {}

 DynamicModuleManagementError()
   : SLIException("DynamicModuleManagementError"),
    msg_()
    {}

 DynamicModuleManagementError(std::string msg)
   : SLIException("DynamicModuleManagementError"),
    msg_(msg)
    {}

  std::string message();
};

class NamingConflict: public SLIException
{
  std::string msg_;
 public:
  ~NamingConflict() throw() {}
 NamingConflict(const std::string& m)
   : SLIException("NamingConflict"),
    msg_(m)
    {}

  std::string message();
};

class NotImplemented: public SLIException
{
  std::string msg_;
 public:
  ~NotImplemented() throw() {}
 NotImplemented(const std::string& m)
   : SLIException("NotImplemented"),
    msg_(m)
    {}

  std::string message();
};

#endif