xml_qualified_name.h

 
 
#pragma once
 
#include <system/string.h>
#include <cstdint>
 
 
namespace System
{
namespace Xml
{
class IXmlNamespaceResolver;
class QueryOutputWriter;
class QueryOutputWriterV1;
namespace Schema
{
class Datatype_NOTATION;
class Datatype_QName;
class Datatype_QNameXdr;
class DtdValidator;
class Preprocessor;
class SchemaCollectionPreprocessor;
class XdrBuilder;
class XdrValidator;
class XmlSchemaAttribute;
class XmlSchemaComplexType;
class XmlSchemaElement;
class XmlSchemaSimpleTypeList;
class XmlSchemaSimpleTypeRestriction;
class XmlSchemaSimpleTypeUnion;
class XmlSchemaValidator;
class XsdBuilder;
class XsdValidator;
} // namespace Schema
class XmlNameTable;
namespace Xsl
{
class XsltArgumentList;
} // namespace Xsl
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
class ASPOSECPP_SHARED_CLASS XmlQualifiedName : public System::Object
{
    typedef XmlQualifiedName ThisType;
    typedef System::Object BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlQualifiedName>;
 
private:
    friend class QueryOutputWriter;
    friend class QueryOutputWriterV1;
    friend class Schema::Datatype_QName;
    friend class Schema::Datatype_NOTATION;
    friend class Schema::Datatype_QNameXdr;
    friend class Schema::DtdValidator;
    friend class Schema::Preprocessor;
    friend class Schema::SchemaCollectionPreprocessor;
    friend class Schema::XdrBuilder;
    friend class Schema::XdrValidator;
    friend class Schema::XmlSchemaAttribute;
    friend class Schema::XmlSchemaComplexType;
    friend class Schema::XmlSchemaElement;
    friend class Schema::XmlSchemaSimpleTypeList;
    friend class Schema::XmlSchemaSimpleTypeRestriction;
    friend class Schema::XmlSchemaSimpleTypeUnion;
    friend class Schema::XmlSchemaValidator;
    friend class Schema::XsdBuilder;
    friend class Schema::XsdValidator;
    friend class Xsl::XsltArgumentList;
    friend ASPOSECPP_SHARED_API bool operator ==(const SharedPtr<XmlQualifiedName>& a, const SharedPtr<XmlQualifiedName>& b);
    friend ASPOSECPP_SHARED_API bool operator !=(const SharedPtr<XmlQualifiedName>& a, const SharedPtr<XmlQualifiedName>& b);
 
public:
 
    static ASPOSECPP_SHARED_API SharedPtr<XmlQualifiedName> Empty;
 
    ASPOSECPP_SHARED_API String get_Namespace() const;
    ASPOSECPP_SHARED_API String get_Name() const;
    ASPOSECPP_SHARED_API bool get_IsEmpty() const;
 
    ASPOSECPP_SHARED_API XmlQualifiedName();
    ASPOSECPP_SHARED_API XmlQualifiedName(const String& name);
    ASPOSECPP_SHARED_API XmlQualifiedName(const String& name, const String& ns);
 
    ASPOSECPP_SHARED_API int32_t GetHashCode() const override;
    ASPOSECPP_SHARED_API bool Equals(SharedPtr<Object> other) override;
    static ASPOSECPP_SHARED_API String ToString(const String& name, const String& ns);
    ASPOSECPP_SHARED_API String ToString() const override;
 
protected:
 
    void Init(const String& name, const String& ns);
    void SetNamespace(const String& ns);
    void Verify();
    void Atomize(const SharedPtr<XmlNameTable>& nameTable);
    static SharedPtr<XmlQualifiedName> Parse(const String& s, const SharedPtr<IXmlNamespaceResolver>& nsmgr, String& prefix);
    SharedPtr<XmlQualifiedName> Clone();
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
    #ifdef __DBG_FOR_EACH_MEMBER
public:
    ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override;
    const char* DBG_class_name() const override { return "XmlQualifiedName"; }
    #endif
 
private:
 
    String _name;
    String _ns;
    mutable int32_t _hash;
 
    String ToString_NonConst();
    virtual ThisType* CppMemberwiseClone() const { return new ThisType(*this); }
 
};
 
ASPOSECPP_SHARED_API bool operator ==(const SharedPtr<XmlQualifiedName>& a, const SharedPtr<XmlQualifiedName>& b);
ASPOSECPP_SHARED_API bool operator !=(const SharedPtr<XmlQualifiedName>& a, const SharedPtr<XmlQualifiedName>& b);
 
} // namespace Xml
} // namespace System