DeSR Dependency Parser

ixe/include/error.h

/*
**  IXE C++ Library
**  ixe/include/error.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2000  Ideare SpA.
**  Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR 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 this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_ERROR_H
#define IXE_ERROR_H

// Settings
#include "platform.h"

// standard
#include <stdexcept>

// local

namespace IXE {

class Error : public std::exception
{
private:
  std::string msg;

  void operator=(const Error &copyme);
protected:
  Error(std::string const& error_msg) : msg(error_msg) {}
  Error(const Error &copyme) : msg(copyme.msg) {}
public:
  std::string message() { return msg; }

  virtual ~Error() throw() { }
};

//----------------------------------------------------------------------

class LogicError : public Error {
    protected:
        LogicError(std::string const& msg) : Error(msg) {}
};

class RuntimeError : public Error {
    protected:
        RuntimeError(std::string const& msg) : Error(msg) {}
};

//----------------------------------------------------------------------

class AssertionError : public LogicError {
public:
  AssertionError(std::string const& msg) :
    LogicError(msg + " - assertion failed") {}
};

class UnimplementedError : public LogicError {
public:
  UnimplementedError(std::string const& msg) : LogicError(msg) {}
};

class InvalidArgumentError : public LogicError {
public:
  InvalidArgumentError(std::string const& msg) : LogicError(msg) {}
};

//----------------------------------------------------------------------

class ConfigFileError : public RuntimeError {
public:
  ConfigFileError(std::string const& msg) : RuntimeError(msg) {}
};

class FileError : public RuntimeError {
public:
  FileError(std::string const& msg) : RuntimeError(msg) {}
};

class MmapError : public RuntimeError {
public:
  MmapError(std::string const& msg) : RuntimeError(msg) {}
};

class FormatError : public RuntimeError {
public:
  FormatError(std::string const& msg) : RuntimeError(msg) {}
};

class DocNotFoundError : public RuntimeError {
public:
  DocNotFoundError(std::string const& msg) : RuntimeError(msg) {}
};

class InternalError : public RuntimeError {
public:
  InternalError(std::string const& msg) : RuntimeError(msg) {}
};

class IndexingError : public RuntimeError {
public:
  IndexingError(std::string const& msg) : RuntimeError(msg) {}
};

class RangeError : public RuntimeError {
public:
  RangeError(std::string const& msg) : RuntimeError(msg) {}
};

class ReaderError : public RuntimeError {
public:
  ReaderError(std::string const& msg) : RuntimeError(msg) {}
};

class CollectionError : public RuntimeError {
public:
  CollectionError(std::string const& msg) : RuntimeError(msg) {}
};

class NetworkError : public RuntimeError {
public:
  NetworkError(std::string const& msg) : RuntimeError(msg) {}
};

class MemoryError : public RuntimeError {
public:
  MemoryError(std::string const& msg) : RuntimeError(msg) {}
};

class OpeningError : public CollectionError {
public:
  OpeningError(std::string const& msg) : CollectionError(msg) {}
};

class TableError : public CollectionError {
public:
  TableError(std::string const& msg) : CollectionError(msg) {}
};

class ParserError : public RuntimeError {
public:
  ParserError(char const* msg) : RuntimeError(msg) {}
};

class QueryError : public RuntimeError {
public:
  QueryError(std::string const& msg) : RuntimeError(msg) {}
};

class InvalidResultError : public RuntimeError {
public:
  InvalidResultError(std::string const& msg) : RuntimeError(msg) {}
};

class SystemError : public RuntimeError {
public:
  SystemError(std::string const& msg) : RuntimeError(msg) {}
};

class IOError : public RuntimeError {
public:
  IOError(std::string const& msg) : RuntimeError(msg) {}
  IOError(char const* msg) : RuntimeError(msg) {}
};

// System errors

#define SYS_CALL(method, args) \
  if (!(method args)) \
    throw SystemError(std::string("*** SystemError at  " __FILE__ ":") \
    + __LINE__ +  ". Failed: " #method #args)

} // namespace IXE

#endif /* IXE_ERROR_H */

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.