hxasvect.h

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

            insResult.first->second = newValue;
        }
        else
        {
            DEBUG_CODE(++m_Serial;)
        }
        using namespace AssocVectorHelpers;
        POSITION result = MakePosition(insResult.first - m_Data.begin());
        DEBUG_CODE(EmbedSerialNumber(result, m_Serial);)
        return result;
    }

    // removing existing (key, ?) pair
    Iterator Erase(Iterator it)
    {
        DEBUG_CODE(++m_Serial;)
        const UINT32 offset = it.value_ - m_Data.begin();
        m_Data.erase(it.value_);
        return Iterator(m_Data.begin() + offset DEBUG_CODE(DEBUG_COMMA this));
    }
    
    POSITION Remove(const Key& key)
    {
        DEBUG_CODE(++m_Serial;)
        const UINT32 offset = m_Data.find(key) - m_Data.begin();
        m_Data.erase(m_Data.begin() + offset);
        using namespace AssocVectorHelpers;
        POSITION result = MakePosition(offset);
        DEBUG_CODE(EmbedSerialNumber(result, m_Serial);)
        return result;
    }
    
    BOOL RemoveKey(const Key& key)
    {
        DEBUG_CODE(++m_Serial;)
        UINT32 oldSize = m_Data.size();
        m_Data.erase(key);
        return oldSize != m_Data.size();
    }
    
    void RemoveAll()
    {
        DEBUG_CODE(++m_Serial;)
        m_Data.clear();
    }

    // iterating all (key, value) pairs
    POSITION GetStartPosition() const
    {
        if (m_Data.empty()) return 0;

        POSITION result = AssocVectorHelpers::MakePosition(0);
        HX_ASSERT(result != 0);

        DEBUG_CODE(AssocVectorHelpers::EmbedSerialNumber(result, m_Serial));
        HX_ASSERT(result != 0);
    
        return result;
    }
    
    void GetNextAssoc(POSITION& rNextPosition, Key& rKey, Value& rValue) const
    {
        using namespace AssocVectorHelpers;
        
        DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
        HX_ASSERT(serial == m_Serial);

        UINT32 offset = GetOffset(rNextPosition);
        HX_ASSERT(offset < m_Data.size());
        const Data::value_type& val = m_Data.begin()[offset];
        rKey = val.first;
        rValue = val.second;

        if (++offset < m_Data.size())
        {
            rNextPosition = MakePosition(offset);
            DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
        }
        else
        {
            rNextPosition = 0;
        }
    }
    
    Iterator Begin()
    {
        return Iterator(m_Data.begin() DEBUG_CODE(DEBUG_COMMA this));
    }
    
    Iterator End()
    {
        return Iterator(m_Data.end() DEBUG_CODE(DEBUG_COMMA this));
    }

    void Swap(CHXGenericAssocVect& rhs)
    {
        m_Data.swap(rhs.m_Data);
        DEBUG_CODE(std::swap(m_Serial, rhs.m_Serial));
    }

// Implementation
protected:
    Data m_Data;
    DEBUG_CODE(unsigned char m_Serial;)

public:
    ~CHXGenericAssocVect()
    {
    }
};

//////////////////////////////////////////////////////////////////////////////
//
//        CHXAssocVectStringToOb
//
//////////////////////////////////////////////////////////////////////////////

struct StringCompare : public std::binary_function<CHXString, CHXString, bool>
{
    char m_PreserveCase;
        
    explicit StringCompare(char PreserveCase = TRUE) : m_PreserveCase(PreserveCase) 
    {
    }

    bool operator()(const CHXString& p1, const CHXString& p2) const
    {
        return (m_PreserveCase ? strcmp(p1, p2) : strcmpi(p1, p2)) < 0;
    }
};
    
class CHXAssocVectStringToOb 
    : public CHXGenericAssocVect<CHXString, void*, StringCompare>
{
    typedef CHXGenericAssocVect<CHXString, void*, StringCompare> Base;
public:
    CHXAssocVectStringToOb(const StringCompare& comp = StringCompare())
        : Base(comp)
    {
    }
    
    void SetCaseSensitive(BOOL b)
    {
        if (!b != !m_Data.key_comp().m_PreserveCase)
        {
            CHXAssocVectStringToOb(StringCompare(char(!!b))).Swap(*this);
        }
    }

    void GetNextAssoc(POSITION& rNextPosition, CHXString& rKey, void*& rValue) const
    {
	Base::GetNextAssoc(rNextPosition, rKey, rValue);
    }

    // JE 12/11/01 - added a method which takes const char*& for key so that the
    // key returned points to memory owned by the map (in the case of small CHXStrings)
    // rather than being owned by the small string buffer of the CHXString& in the 
    // above method
    void GetNextAssoc(POSITION& rNextPosition, const char*& rKey, void*& rValue) const
    {
        using namespace AssocVectorHelpers;
        
        DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
	    HX_ASSERT(serial == m_Serial);
	
        UINT32 offset = GetOffset(rNextPosition);
        HX_ASSERT(offset < m_Data.size());
        const Data::value_type& val = m_Data.begin()[offset];
        rKey = val.first;
        rValue = val.second;
	
        if (++offset < m_Data.size())
        {
            rNextPosition = MakePosition(offset);
            DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
        }
        else
        {
            rNextPosition = 0;
        }
    }
};

/////////////////////////////////////////////////////////////////////////////

class HXEXPORT_CLASS CHXAssocVectPtrToPtr 
    : public CHXGenericAssocVect<void*, void*>
{
};

////////////////////////////////////////////////////////////////////////////

class CHXAssocVectStringToString
    : public CHXGenericAssocVect<CHXString, CHXString>
{
};

////////////////////////////////////////////////////////////////////////////

class HXEXPORT_CLASS CHXAssocVectLongToObj
    : public CHXGenericAssocVect<LONG32, void*>
{
};

////////////////////////////////////////////////////////////////////////////

class HXEXPORT_CLASS CHXAssocVectGUIDToObj
    : public CHXGenericAssocVect<GUID, void*>
{
    typedef CHXGenericAssocVect<GUID, void*> Base;
public:
    void GetNextAssoc(POSITION& rNextPosition, GUID*& rpKey, void*& rValue) const
    {
        using namespace AssocVectorHelpers;
        
        DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
        HX_ASSERT(serial == m_Serial);

        const UINT32 offset = GetOffset(rNextPosition);
        HX_ASSERT(offset < m_Data.size());
        const Data::value_type& val = m_Data.begin()[offset];
        rpKey = const_cast<GUID*>(&val.first);
        rValue = val.second;

        rNextPosition = MakePosition(offset + 1);
        DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
    }

    typedef Base::Iterator BaseIterator;

    class Iterator : public BaseIterator
    {
    public:
        Iterator(CHXAssocVectGUIDToObj* pCont, POSITION pos)
            : BaseIterator(pCont, pos)
        {
        }
        
        Iterator(Data::iterator it DEBUG_CODE(DEBUG_COMMA CHXAssocVectGUIDToObj* pCont))
            : BaseIterator(it DEBUG_CODE(DEBUG_COMMA pCont))
        {
        }

	Iterator(const BaseIterator& iter)
            : BaseIterator(iter)
        {
        }

        GUID* get_key()
        {
            return &value_->first;
        }
    };
};

////////////////////////////////////////////////////////////////////////////

#else // HX_CPP_BASIC_TEMPLATES

#include "hxmap.h"
#include "hxguidmap.h"

typedef CHXMapStringToString CHXAssocVectStringToString;
typedef CHXMapStringToOb CHXAssocVectStringToOb;
typedef CHXMapGUIDToObj CHXAssocVectGUIDToObj;
typedef CHXMapLongToObj CHXAssocVectLongToObj;
typedef CHXMapPtrToPtr CHXAssocVectPtrToPtr;

#endif // HX_CPP_BASIC_TEMPLATES

#endif // HXASVECT_H_