it_bus/fault_exception.h

#ifndef _IT_BUS_FAULT_EXCEPTION_H_
#define _IT_BUS_FAULT_EXCEPTION_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//
#include <it_bus/any.h>
#include <it_bus/types.h>
#include <it_bus/qname.h>
#include <it_bus/sequence_complex_type.h>
#include <it_bus/any_simple_type.h>

namespace IT_WSDL
{
    class WSDLPortType;
    class AnySimpleTypeReader;
}

namespace IT_Bus
{
    class ComplexTypeReader;
    class ComplexTypeWriter;

    class IT_BUS_API FaultCategory : public AnySimpleType
    {
      public:
        enum Category
        {
            NO_PERMISSION,
            CONNECTION_FAILURE,
            MARSHAL_ERROR,
            NOT_EXIST,
            TRANSIENT,
            UNKNOWN,
            TIMEOUT,
            VERSION_ERROR,
            NOT_UNDERSTOOD,
            MEMORY,
            BAD_OPERATION,
            INTERNAL,
            INVALID_REFERENCE,
            NOT_IMPLEMENTED,
            LICENSE
        };

      private:
        static const QName m_type;
        Category m_val;

      public:
        FaultCategory();

        FaultCategory(const Category value);

        FaultCategory(const FaultCategory & value);

        virtual void
        write_value(
            AnySimpleTypeWriter & writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            AnySimpleTypeReader & reader
        ) throw((DeserializationException));

        virtual const QName &
        get_type() const;

        FaultCategory &
        operator=(
            const FaultCategory & rhs
        )
        {
            (AnyType & ) (*this).copy(rhs);
            return * this;
        }

        virtual AnyType& copy (
            const AnyType& assign
        );

        Boolean operator== (
            const FaultCategory& copy
        );

        void set_value(const Category value);

        Category get_value() const;

        String
        to_string() const;

        void
        set_value(
            const String & data
        );
    };


    class IT_BUS_API FaultSource : public AnySimpleType
    {
      public:
        enum Source
        {
            CLIENT,
            SERVER,
            UNKNOWN
        };

      private:
        static const QName m_type;
        Source m_val;

      public:
        FaultSource();

        FaultSource(const Source value);

        FaultSource(const FaultSource & value);

        virtual void
        write_value(
            AnySimpleTypeWriter & writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            AnySimpleTypeReader & reader
        ) throw((DeserializationException));

        virtual const QName &
        get_type() const;

        FaultSource &
        operator=(
            const FaultSource & rhs
        )
        {
            (AnyType & ) (*this).copy(rhs);
            return * this;
        }

        virtual AnyType& copy (
            const AnyType& assign
        );

        Boolean operator== (
            const FaultSource& copy
        );

        void set_value(const Source value);

        Source get_value() const;

        String
        to_string() const;

        void
        set_value(
            const String & data
        );
    };


    class IT_BUS_API FaultCompletionStatus : public AnySimpleType
    {
      public:
        enum CompletionStatus
        {
            YES,
            NO,
            MAYBE
        };

      private:
        static const QName m_type;
        CompletionStatus m_val;

      public:
        FaultCompletionStatus();

        FaultCompletionStatus(const CompletionStatus value);

        FaultCompletionStatus(const FaultCompletionStatus & value);

        virtual void
        write_value(
            AnySimpleTypeWriter & writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            AnySimpleTypeReader & reader
        ) throw((DeserializationException));

        virtual const QName &
        get_type() const;

        FaultCompletionStatus &
        operator=(
            const FaultCompletionStatus & rhs
        )
        {
            (AnyType & ) (*this).copy(rhs);
            return * this;
        }

        virtual AnyType& copy (
            const AnyType& assign
        );

        Boolean operator== (
            const FaultCompletionStatus& copy
        );

        void set_value(const CompletionStatus value);

        CompletionStatus get_value() const;

        String
        to_string() const;

        void
        set_value(
            const String & data
        );
    };


    class IT_BUS_API FaultDetail : public IT_Bus::SequenceComplexType
    {

      public:

        static const IT_Bus::QName&
        get_static_type();
        
        FaultDetail();
        FaultDetail(const FaultDetail & copy);
        virtual ~FaultDetail();

        IT_Bus::AnyType &
        copy(const IT_Bus::AnyType & rhs);

        FaultDetail &
        operator=(const FaultDetail & rhs);

        virtual const IT_Bus::QName &
        get_type() const;

        virtual void
        write_contents(
            IT_Bus::ComplexTypeWriter & writer
        ) const throw((IT_Bus::SerializationException));

        virtual void
        read_contents(
            IT_Bus::ComplexTypeReader & reader
        ) throw((IT_Bus::DeserializationException));

        IT_Bus::AnyList &
        get_detail_entries();

        const IT_Bus::AnyList &
        get_detail_entries() const;

        void 
        set_detail_entries(const IT_Vector<IT_Bus::Any> & val);

      private:
        static const QName m_type;
        IT_Bus::AnyList *var_any;        
    };

    class IT_BUS_API FaultException :
        public SequenceComplexType,
        public Exception
    {
      private:
        static const QName m_qname;

        static const QName m_category_qname;

        static const QName m_namespace_uri_qname;

        static const QName m_code_qname;

        static const QName m_detail_qname;

        static const QName m_source_qname;

        static const QName m_completion_status_qname;

        static const QName m_description_qname;

        static const QName m_server_id_qname;

      public:

        FaultException(
            const FaultCategory::Category category,
            const String & namespace_uri,
            const String & code
        );

        FaultException();

        FaultException(const FaultException& copy);

        virtual ~FaultException();

        virtual Exception*
        clone() const;
    
        virtual void
        rethrow() const;

        virtual void
        read_contents(
            ComplexTypeReader & reader
        ) throw((DeserializationException));

        virtual void
        write_contents(
            ComplexTypeWriter & writer
        ) const throw((SerializationException));

        virtual const QName &
        get_type() const;

        FaultException &
        operator=(
            const FaultException & rhs
        )
        {
            (AnyType & ) (*this).copy(rhs);
            return * this;
        }

        virtual AnyType& copy (
            const AnyType& assign
        );

        const FaultCategory &
        get_category() const;

        FaultCategory &
        get_category();

        void
        set_category(const FaultCategory & val);

        const String &
        get_namespace_uri() const;

        String &
        get_namespace_uri();

        void
        set_namespace_uri(const String & val);

        const String &
        get_code() const;

        String &
        get_code();

        void
        set_code(const String & val);

        const String &
        get_detail() const;

        String &
        get_detail();

        void
        set_detail(const String & val);

        const FaultDetail &
        get_any_detail() const;

        FaultDetail &
        get_any_detail();

        void
        set_any_detail(const FaultDetail & val);

        const FaultSource &
        get_source() const;

        FaultSource &
        get_source();

        void
        set_source(const FaultSource & val);

        const FaultCompletionStatus &
        get_completion_status() const;

        FaultCompletionStatus &
        get_completion_status();

        void
        set_completion_status(const FaultCompletionStatus & val);

        const String &
        get_description() const;

        String &
        get_description();

        void
        set_description(const String & val);

        const String &
        get_server_id() const;

        String &
        get_server_id();

        void
        set_server_id(const String & val);

        static bool
        has_fault_exception_fault_message(
            const IT_WSDL::WSDLPortType & port_type,
            const String & operation_name
        );

        const bool
        is_detail_set() const;

        bool
        is_detail_set();


    private:

        FaultCategory m_category;

        String m_namespace_uri;

        String m_code;

        String m_detail;

        FaultDetail m_any_detail;

        FaultSource m_source;

        FaultCompletionStatus m_completion_status;

        String m_description;

        String m_server_id;

        bool m_is_detail_set;
    };
}

#endif  

---