it_bus/reference.h

#ifndef _IT_BUS_REFERENCE_H_
#define _IT_BUS_REFERENCE_H_

#include <it_bus/sequence_complex_type.h>
#include <it_bus/any.h>
#include <it_bus/array_t.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus/wsaddressing_xsdTypes.h>
#include <it_cal/auto_ptr.h>

#include <it_bus/reflect/element_list_impl_t.h>
#include <it_bus/reflect/model_group_impl.h>
#include <it_bus/reflect/complex_type_impl.h>
#include <it_bus/reflect/reflected_nillable_value.h>
#include <it_bus/reflect/reflected_nillable_ptr.h>

namespace WSDL_Schema
{
    class tService;
}

namespace WS_Addressing
{
    class EndpointReferenceUtil;
}

namespace IT_Bus
{
    class ReferencePort;
    class IT_ReferencePortReflection;
    typedef IT_Reflect::ReflectedNillableValue<ReferencePort> ReferencePortNillable;
    typedef IT_Reflect::ReflectedNillablePtr<ReferencePort> ReferencePortNillablePtr;
    class Reference;
    class IT_ReferenceReflection;
    typedef IT_Reflect::ReflectedNillableValue<Reference> ReferenceNillable;
    typedef IT_Reflect::ReflectedNillablePtr<Reference> ReferenceNillablePtr;

    class IT_AFC_API ReferencePort : public IT_Bus::SequenceComplexType
    {

      public:

        static const IT_Bus::QName&
        get_static_type();
        
        typedef IT_ReferencePortReflection IT_ReflectionType;
        friend class IT_ReferencePortReflection;
        
        ReferencePort();

        ReferencePort(const ReferencePort & copy);

        virtual ~ReferencePort();

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

        ReferencePort &
        operator=(const ReferencePort & rhs);

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

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

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


        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_any();

        const IT_Bus::AnyList &
        get_any() const;

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

        IT_Bus::NCName &
        get_name();

        const IT_Bus::NCName &
        get_name() const;

        void 
        set_name(const IT_Bus::NCName & val);

        IT_Bus::QName &
        get_binding();

        const IT_Bus::QName &
        get_binding() const;

        void 
        set_binding(const IT_Bus::QName & val);

        virtual IT_Reflect::Reflection*
        get_reflection() throw((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection() const throw((IT_Reflect::ReflectException));
        

      private:

        IT_Bus::AnyList *m_any;
        IT_Bus::NCName m_name;
        IT_Bus::QName m_binding;
    };

    typedef IT_AutoPtr<ReferencePort> ReferencePortPtr;

    class IT_AFC_API IT_ReferencePortReflection :
        public IT_Reflect::ReflectionImplT<IT_Bus::ReferencePort>,
        public IT_Reflect::ComplexTypeImpl,
        public IT_Reflect::ModelGroupImpl
    {
      public:

        IT_ReferencePortReflection(
            const IT_Bus::ReferencePort* value
        );
        
        ~IT_ReferencePortReflection() throw(());
        
        const IT_Reflect::Reflection*
        get_element(
            size_t i
        ) const throw((IT_Reflect::ReflectException));
        
        const IT_Reflect::Reflection*
        get_element(
            const IT_Bus::QName& name
        ) const throw((IT_Reflect::ReflectException));
        
        const IT_Reflect::Reflection*
        get_attribute_value(
            const IT_Bus::QName& name
        ) const throw((IT_Reflect::ReflectException));
        
        IT_Reflect::Reflection*
        use_attribute_value(
            const IT_Bus::QName& name
        ) throw((IT_Reflect::ReflectException));
        
        void
        remove_attribute(
            const IT_Bus::QName& name
        ) throw((IT_Reflect::ReflectException));
        
      private:

        IT_Reflect::Traits<IT_Bus::NCName >::ReflectionType m_name;
        IT_Reflect::Traits<IT_Bus::QName >::ReflectionType m_binding;
        class IT_ElementNames :
            public IT_Vector<IT_Bus::QName>
        {
          public:

            IT_ElementNames();
            
        };

        static IT_ElementNames _it_sm_element_names;
        class IT_AttributeNames :
            public IT_Vector<IT_Bus::QName>
        {
          public:

            IT_AttributeNames();
            
        };

        static IT_AttributeNames _it_sm_attribute_names;
    };

    class IT_AFC_API Reference : public IT_Bus::SequenceComplexType
    {

      public:

        static const IT_Bus::QName&
        get_static_type();
        
        typedef IT_ReferenceReflection IT_ReflectionType;
        friend class IT_ReferenceReflection;
        
        Reference();

        Reference(
            const WS_Addressing::EndpointReferenceType& epr
        );


        Reference(
            const Reference & copy
        );

        
        virtual ~Reference();

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

        Reference &
        operator=(const Reference & rhs);

        Reference &
        operator=(        
            const WS_Addressing::EndpointReferenceType & rhs
        );

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

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

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


        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::ElementListT<IT_Bus::ReferencePort> &
        get_port();

        const IT_Bus::ElementListT<IT_Bus::ReferencePort> &
        get_port() const;

        void 
        set_port(const IT_Vector<IT_Bus::ReferencePort> & val);

        IT_Bus::QName &
        get_service();

        const IT_Bus::QName &
        get_service() const;

        void 
        set_service(const IT_Bus::QName & val);

        IT_Bus::String &
        get_wsdl_location();

        const IT_Bus::String &
        get_wsdl_location() const;

        void 
        set_wsdl_location(const IT_Bus::String & val);

        virtual IT_Reflect::Reflection*
        get_reflection() throw((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection() const throw((IT_Reflect::ReflectException));

      private:

        const WS_Addressing::EndpointReferenceType&
        get_endpoint_reference() const;
        
        WS_Addressing::EndpointReferenceType&
        get_endpoint_reference();

        void
        get_service_from_epr();
    
        IT_Bus::ElementListT<IT_Bus::ReferencePort> &
        get_port_from_epr();

        void
        populate_epr_metadata_from_reference(
            WS_Addressing::EndpointReferenceType& epr
        );

        IT_Bus::ElementListT<IT_Bus::ReferencePort> m_port;
        IT_Bus::QName                               m_service_name;
        IT_Bus::String                              m_wsdl_location;
        WSDL_Schema::tService*                      m_service;
        WS_Addressing::EndpointReferenceType        m_endpoint_reference;
        bool                                        m_populate_epr_from_reference;

        friend class WS_Addressing::EndpointReferenceUtil;
    };

    typedef IT_AutoPtr<Reference> ReferencePtr;

    class IT_AFC_API IT_ReferenceReflection :
        public IT_Reflect::ReflectionImplT<IT_Bus::Reference>,
        public IT_Reflect::ComplexTypeImpl,
        public IT_Reflect::ModelGroupImpl
    {
      public:

        IT_ReferenceReflection(
            const IT_Bus::Reference* value
        );
        
        ~IT_ReferenceReflection() throw(());
        
        const IT_Reflect::Reflection*
        get_element(
            size_t i
        ) const throw((IT_Reflect::ReflectException));
        
        const IT_Reflect::Reflection*
        get_element(
            const IT_Bus::QName& name
        ) const throw((IT_Reflect::ReflectException));
        
        const IT_Reflect::Reflection*
        get_attribute_value(
            const IT_Bus::QName& name
        ) const throw((IT_Reflect::ReflectException));
        
        IT_Reflect::Reflection*
        use_attribute_value(
            const IT_Bus::QName& name
        ) throw((IT_Reflect::ReflectException));
        
        void
        remove_attribute(
            const IT_Bus::QName& name
        ) throw((IT_Reflect::ReflectException));
        
      private:

        IT_Reflect::Traits<IT_Bus::ElementListT<IT_Bus::ReferencePort> >::ReflectionType m_port;
        IT_Reflect::Traits<IT_Bus::QName  >::ReflectionType m_service_name;
        IT_Reflect::Traits<IT_Bus::String >::ReflectionType m_wsdl_location;
        class IT_ElementNames :
            public IT_Vector<IT_Bus::QName>
        {
          public:

            IT_ElementNames();
            
        };

        static IT_ElementNames _it_sm_element_names;
        class IT_AttributeNames :
            public IT_Vector<IT_Bus::QName>
        {
          public:

            IT_AttributeNames();
            
        };

        static IT_AttributeNames _it_sm_attribute_names;
    };

    bool
    IT_AFC_API operator==(
        const IT_Bus::ReferencePort & lhs,
        const IT_Bus::ReferencePort & rhs
    );
    
    bool
    IT_AFC_API operator!=(
        const IT_Bus::ReferencePort & lhs,
        const IT_Bus::ReferencePort & rhs
    );
    
    bool
    IT_AFC_API operator==(
        const IT_Bus::Reference & lhs,
        const IT_Bus::Reference & rhs
    );
    
    bool
    IT_AFC_API operator!=(
        const IT_Bus::Reference & lhs,
        const IT_Bus::Reference & rhs
    );

    bool
    IT_AFC_API operator==(
        const WS_Addressing::EndpointReferenceType & lhs,
        const WS_Addressing::EndpointReferenceType & rhs
    );
}
#endif

---