// **********************************************************************
//
// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.0.0
// Generated from file `Exception.ice'

#ifndef __IceSSL_Exception_h__
#define __IceSSL_Exception_h__

#include <Ice/LocalObjectF.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/UndefSysMacros.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 300
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 < 0
#       error Ice patch level mismatch!
#   endif
#endif

#ifndef ICE_SSL_API
#   ifdef ICE_SSL_API_EXPORTS
#       define ICE_SSL_API ICE_DECLSPEC_EXPORT
#   else
#       define ICE_SSL_API ICE_DECLSPEC_IMPORT
#   endif
#endif

namespace IceSSL
{

class ICE_SSL_API SslException : public ::Ice::LocalException
{
public:

    SslException(const char*, int);
    SslException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;

    ::std::string message;
};

class ICE_SSL_API ConfigurationLoadingException : public ::IceSSL::SslException
{
public:

    ConfigurationLoadingException(const char*, int);
    ConfigurationLoadingException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ConfigParseException : public ::IceSSL::SslException
{
public:

    ConfigParseException(const char*, int);
    ConfigParseException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ShutdownException : public ::IceSSL::SslException
{
public:

    ShutdownException(const char*, int);
    ShutdownException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ProtocolException : public ::IceSSL::ShutdownException
{
public:

    ProtocolException(const char*, int);
    ProtocolException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateVerificationException : public ::IceSSL::ShutdownException
{
public:

    CertificateVerificationException(const char*, int);
    CertificateVerificationException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateException : public ::IceSSL::SslException
{
public:

    CertificateException(const char*, int);
    CertificateException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateSigningException : public ::IceSSL::CertificateException
{
public:

    CertificateSigningException(const char*, int);
    CertificateSigningException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateSignatureException : public ::IceSSL::CertificateException
{
public:

    CertificateSignatureException(const char*, int);
    CertificateSignatureException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateParseException : public ::IceSSL::CertificateException
{
public:

    CertificateParseException(const char*, int);
    CertificateParseException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API PrivateKeyException : public ::IceSSL::SslException
{
public:

    PrivateKeyException(const char*, int);
    PrivateKeyException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API PrivateKeyParseException : public ::IceSSL::PrivateKeyException
{
public:

    PrivateKeyParseException(const char*, int);
    PrivateKeyParseException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateVerifierTypeException : public ::IceSSL::SslException
{
public:

    CertificateVerifierTypeException(const char*, int);
    CertificateVerifierTypeException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ContextException : public ::IceSSL::SslException
{
public:

    ContextException(const char*, int);
    ContextException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ContextInitializationException : public ::IceSSL::ContextException
{
public:

    ContextInitializationException(const char*, int);
    ContextInitializationException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API ContextNotConfiguredException : public ::IceSSL::ContextException
{
public:

    ContextNotConfiguredException(const char*, int);
    ContextNotConfiguredException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API UnsupportedContextException : public ::IceSSL::ContextException
{
public:

    UnsupportedContextException(const char*, int);
    UnsupportedContextException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateLoadException : public ::IceSSL::ContextException
{
public:

    CertificateLoadException(const char*, int);
    CertificateLoadException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API PrivateKeyLoadException : public ::IceSSL::ContextException
{
public:

    PrivateKeyLoadException(const char*, int);
    PrivateKeyLoadException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API CertificateKeyMatchException : public ::IceSSL::ContextException
{
public:

    CertificateKeyMatchException(const char*, int);
    CertificateKeyMatchException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

class ICE_SSL_API TrustedCertificateAddException : public ::IceSSL::ContextException
{
public:

    TrustedCertificateAddException(const char*, int);
    TrustedCertificateAddException(const char*, int, const ::std::string&);

    virtual const ::std::string ice_name() const;
    virtual void ice_print(::std::ostream&) const;
    virtual ::Ice::Exception* ice_clone() const;
    virtual void ice_throw() const;
};

}

#endif
