edlqname.h

Go to the documentation of this file.

/*
 *  edlqname.h
 *
 *  Copyright (C) 2007-2026 Hybrid Software Helix Ltd. All rights reserved.
 */

 
#ifndef EDLQNAME_H
#define EDLQNAME_H
 
#include <edl/edltypes.h>
#include <edl/iedlobject.h>
#include <edl/iedlenum.h>
#include <edl/edlstring.h>
#include <jawsmako/hashable.h>
 
_BEGIN_EDL_NAMESPACE

class IEDLNamespace : public IEDLObject, public JawsMako::IHashable
{
#define IEDLNamespaceID 0xb836b26d, 0x2e4e45d2, 0x82aa6c63, 0x6ca45484
public:
    class Data : public CClassParams
    {
    public:
        EDLSysString prefix;
        EDLSysString nameSpace;
    };

    static const CClassID &classID()
    {
        static CClassID id(IEDLNamespaceID);
        return id;
    };

    virtual bool getPrefix(EDLSysString &sPrefix) const = 0;
    virtual bool setPrefix(const EDLSysString &sPrefix) = 0;
    virtual bool getNamespace(EDLSysString &sNamespace) const = 0;
    virtual bool setNamespace(const EDLSysString &sNamespace) = 0;
};
DECL_SMART_PTR(IEDLNamespace);
#define edlobj2IEDLNamespace(src) edl_cast((IEDLNamespace *)NULL, src)
 
typedef IInputEnumRC<IEDLNamespacePtr> IEDLNamespaceCollectionEnum;
DECL_SMART_PTR(IEDLNamespaceCollectionEnum);
 
#define NamespaceSeparatorL ((wchar_t *) L":")
#define NamespaceSeparator  ":"

class EDL_API EDLQName : public JawsMako::IHashable
{
public:
    EDLQName()
    {
        m_ptrNamespace = IEDLNamespacePtr(NULL);
        m_name = EDLString();
    }

    EDLQName(const EDLQName &another)
    {
        m_ptrNamespace = another.m_ptrNamespace;
        m_name = another.m_name;
    }

    EDLQName(IEDLNamespacePtr ptrNamespace, const EDLString &name)
    {
        m_ptrNamespace = ptrNamespace;
        m_name = name;
    }

    EDLQName(IEDLNamespacePtr ptrNamespace, const EDLSysString &name)
    {
        m_ptrNamespace = ptrNamespace;
        m_name = EDLSysStringToEDLString(name);
    }

    void operator =(const EDLQName &another)
    {
        if (this != &another)
        {
            m_ptrNamespace = another.m_ptrNamespace;
            m_name = another.m_name;
        }
    }

    bool operator ==(const EDLQName &another) const
    {
        if (this != &another)
        {
 
            EDLSysString ns1, ns2;
            if (m_ptrNamespace->getNamespace(ns1) && another.m_ptrNamespace->getNamespace(ns2))
                return (ns1 == ns2) && (m_name == another.m_name);
            else
                return false;
 
        }
        else
            return true;
    }

    IEDLNamespacePtr getNamespace() const
    {
        return m_ptrNamespace;
    }

    bool setNamespace(const IEDLNamespacePtr &ns)
    {
        m_ptrNamespace = ns;
        return true;
    }

    EDLString getName() const
    {
        return m_name;
    }

    bool setName(const EDLString &name)
    {
        m_name = name;
        return true;
    }

    bool setName(const EDLSysString &sysname)
    {
        m_name = EDLSysStringToEDLString(sysname);
        return true;
    }

    EDLString getNameWithPrefix() const
    {
        EDLString result(L"");
        EDLSysString sPrefix;
 
        if (m_ptrNamespace && m_ptrNamespace->getPrefix(sPrefix))
            result = EDLSysStringToEDLString(sPrefix) + NamespaceSeparatorL + m_name;
        else
            result = m_name;
        return result;
    }

    bool isEmpty ()
    {
        return m_name.empty ();
    }
 
#ifdef SWIG
    %apply unsigned long long &OUTPUT { uint64 &hash };
#endif
    virtual void updateHash(uint64 &hash) const;
#ifdef SWIG
    %clear uint64 &hash;
#endif
 
private:
    IEDLNamespacePtr m_ptrNamespace;
    EDLString m_name;
};
 
_END_EDL_NAMESPACE
 
#endif /* __EDLQNAME_H__ */