it_bus/qname.h

#ifndef _IT_BUS_QNAME_H_
#define _IT_BUS_QNAME_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_bus/types.h>

#ifndef IT_IOSTREAMS_FREE
#include <it_cal/iostream.h>
#endif 

#include <it_cal/stdexcept.h>
#include <it_dsa/hash_map.h>

namespace IT_Bus
{
    struct QNameBody;           // Private implementation.

    class PrefixResolver;
    

    class IT_AFC_API QName
    {
      public:

        QName();

        QName(
            const QName& name
        );

        QName(
            const String& namespace_prefix, 
            const String& local_part,
            const String& namespace_uri
        );

        QName(
            const String& raw_name,
            const String& namespace_uri = String::EMPTY
        );

        ~QName();

        void
        assign(
            const String& raw_name,
            const String& namespace_uri = String::EMPTY
        );

        QName& operator=(
            const QName& rhs
        );

        const String &
        get_namespace_prefix() const;

        const String &
        get_local_part() const;

        const String &
        get_namespace_uri() const;

        const String
        get_raw_name() const;

        const String
        get_raw_name(
            const PrefixResolver& resolver
        ) const;

        const String
        to_string() const;

        const String
        get_as_string_uri() const;

        const String
        get_as_canonical_string() const;

        bool
        has_unresolved_prefix() const;

        size_t
        get_hash_code() const;

        bool
        operator ==(
            const QName& rhs
        ) const;

        bool
        operator !=(
            const QName& rhs
        ) const;

        bool
        empty() const;
        
        void
        set_local_part(
            const String&
        );

        void
        set_namespace_prefix(
            const String&
        );

        void
        set_namespace_uri(
            const String&
        );

        static QName
        make_qname_from_canonical_string(
            const String qname_str
        ) throw((IT_Bus::Exception));

        static const QName EMPTY_QNAME;

        static const QName ITEM_QNAME;

      private:

        void
        assign_internal(
            const String& raw_name,
            const String& namespace_uri = String::EMPTY
        );

        void set_hash();

        QNameBody* m_body;
    };


    class IT_AFC_API QNameHash
    {
      public:
        QNameHash() {}
        ~QNameHash() {}

        size_t
        operator()(
            const QName& to_hash
        );
    };

    inline size_t
    QNameHash::operator()(
        const QName& to_hash
    )
    {
        return to_hash.get_hash_code();
    }


    class IT_AFC_API QNameEq
    {
      public:
        QNameEq() {}
        ~QNameEq() {}

        IT_Bool
        operator()(
            const QName& a1,
            const QName& s2
        );
    };

    inline IT_Bool
    QNameEq::operator()(
        const QName& s1,
        const QName& s2
    )
    {
        return s1 == s2;
    }

    template <class T>
    class QNameHashMap : public IT_HashMap<QName, T, QNameHash, QNameEq>
    {
    };

    
    class IT_AFC_API ResolverQNameFactory
    {
      public:
        static QName
        create(
            const String&           prefix, 
            const String&           local_part,
            const PrefixResolver&   prefix_resolver
        );

        static QName
        create(
            const String&           raw_name, 
            const PrefixResolver&   prefix_resolver
        );
    };
}

#ifndef IT_IOSTREAMS_FREE
inline IT_ostream& operator<< (IT_ostream& os, const IT_Bus::QName& name)
{
    return os << name.to_string();
}
#endif 

#endif  

---