/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.

 * Use of this file is governed by the BSD 3-clause license that

 * can be found in the LICENSE.txt file in the project root.

 */

#pragma once

#include "antlr4-common.h"

namespace antlr4 {

  // An exception hierarchy modelled loosely after java.lang.* exceptions.

  class ANTLR4CPP_PUBLIC RuntimeException : public std::exception {

  private:

    std::string _message;

  public:

    RuntimeException(const std::string &msg = "");

    virtual const char* what() const noexcept override;

  };

  class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {

  public:

    IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {}

    IllegalStateException(IllegalStateException const&) = default;

    ~IllegalStateException();

    IllegalStateException& operator=(IllegalStateException const&) = default;

  };

  class ANTLR4CPP_PUBLIC IllegalArgumentException : public RuntimeException {

  public:

    IllegalArgumentException(IllegalArgumentException const&) = default;

    IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {}

    ~IllegalArgumentException();

    IllegalArgumentException& operator=(IllegalArgumentException const&) = default;

  };

  class ANTLR4CPP_PUBLIC NullPointerException : public RuntimeException {

  public:

    NullPointerException(const std::string &msg = "") : RuntimeException(msg) {}

    NullPointerException(NullPointerException const&) = default;

    ~NullPointerException();

    NullPointerException& operator=(NullPointerException const&) = default;

  };

  class ANTLR4CPP_PUBLIC IndexOutOfBoundsException : public RuntimeException {

  public:

    IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {}

    IndexOutOfBoundsException(IndexOutOfBoundsException const&) = default;

    ~IndexOutOfBoundsException();

    IndexOutOfBoundsException& operator=(IndexOutOfBoundsException const&) = default;

  };

  class ANTLR4CPP_PUBLIC UnsupportedOperationException : public RuntimeException {

  public:

    UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {}

    UnsupportedOperationException(UnsupportedOperationException const&) = default;

    ~UnsupportedOperationException();

    UnsupportedOperationException& operator=(UnsupportedOperationException const&) = default;

  };

  class ANTLR4CPP_PUBLIC EmptyStackException : public RuntimeException {

  public:

    EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {}

    EmptyStackException(EmptyStackException const&) = default;

    ~EmptyStackException();

    EmptyStackException& operator=(EmptyStackException const&) = default;

  };

  // IOException is not a runtime exception (in the java hierarchy).

  // Hence we have to duplicate the RuntimeException implementation.

  class ANTLR4CPP_PUBLIC IOException : public std::exception {

  private:

    std::string _message;

  public:

    IOException(const std::string &msg = "");

    virtual const char* what() const noexcept override;

  };

  class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {

  public:

    CancellationException(const std::string &msg = "") : IllegalStateException(msg) {}

    CancellationException(CancellationException const&) = default;

    ~CancellationException();

    CancellationException& operator=(CancellationException const&) = default;

  };

  class ANTLR4CPP_PUBLIC ParseCancellationException : public CancellationException {

  public:

    ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {}

    ParseCancellationException(ParseCancellationException const&) = default;

    ~ParseCancellationException();

    ParseCancellationException& operator=(ParseCancellationException const&) = default;

  };

} // namespace antlr4